#45 modif de la propriété ParamValues.valueMode (renvoie maintenant la valeur...

 #45 modif de la propriété ParamValues.valueMode (renvoie maintenant la valeur de _valueMode et non éventuellement celle référencée)
- modif de Nub.CalcSerie() en conséquence

src/nub.ts

@@ -76,13 +76,19 @@ export abstract class Nub extends ComputeNode implements IReferencedObject {
     public CalcSerie(rPrec: number = 0.001, rInit?: number, sDonnee?: string): Result {
         let variatedParam: ParamDefinition;
         let computedParam: ParamDefinition;
-        for (const p of this.parameterIterator) {
+        let prmValue: ParamValues; // instance de ParamValues utilisée pour le paramètre varié (qui peut être un paramètre référencé (importé))
 
+        for (const p of this.parameterIterator) {
             switch (p.valueMode) {
+                case ParamValueMode.SINGLE:
+                    break;
+
                 case ParamValueMode.LISTE:
                 case ParamValueMode.MINMAX:
-                    if (variatedParam == undefined)
+                    if (variatedParam == undefined) {
                         variatedParam = p;
+                        prmValue = p.paramValues;
+                    }
                     else
                         throw new Error(`CalcSerie() : il y plusieurs paramètres à varier (au moins ${variatedParam.symbol} et ${p.symbol})`);
                     break;
@@ -95,6 +101,39 @@ export abstract class Nub extends ComputeNode implements IReferencedObject {
                             throw new Error(`CalcSerie() : il y plusieurs paramètres à calculer (au moins ${computedParam.symbol} et ${p.symbol})`);
                     }
                     break;
+
+                case ParamValueMode.LINK:
+                    if (p.referencedParamValues !== undefined)
+                        switch (p.referencedParamValues.valueMode) {
+                            case ParamValueMode.SINGLE:
+                                break;
+
+                            case ParamValueMode.LISTE:
+                            case ParamValueMode.MINMAX:
+                                if (variatedParam == undefined) {
+                                    variatedParam = p;
+                                    prmValue = p.referencedParamValues;
+                                }
+                                else
+                                    throw new Error(`CalcSerie() : il y plusieurs paramètres à varier (au moins ${variatedParam.symbol} et ${p.symbol})`);
+                                break;
+
+                            case ParamValueMode.CALCUL:
+                                if (sDonnee == undefined) {
+                                    if (computedParam == undefined)
+                                        computedParam = p;
+                                    else
+                                        throw new Error(`CalcSerie() : il y plusieurs paramètres à calculer (au moins ${computedParam.symbol} et ${p.symbol})`);
+                                }
+                                break;
+
+                            default:
+                                throw new Error(`CalcSerie() : valeur référencée de ParamValueMode ${ParamValueMode[p.referencedParamValues.valueMode]} non prise en charge`);
+                        }
+                    break;
+
+                default:
+                    throw new Error(`CalcSerie() : valeur de ParamValueMode ${ParamValueMode[p.valueMode]} non prise en charge`);
             }
         }
 
@@ -113,9 +152,9 @@ export abstract class Nub extends ComputeNode implements IReferencedObject {
             this._result = this.Calc(computedSymbol, rInit, rPrec); // résultat dans this._result
         else {
             const res = new Result();
-            variatedParam.paramValues.initIterator();
-            while (variatedParam.paramValues.hasNext) {
-                variatedParam.paramValues.next;
+            prmValue.initIterator();
+            while (prmValue.hasNext) {
+                prmValue.next;
                 this.Calc(computedSymbol, rInit, rPrec);  // résultat dans this._result
                 if (this._result.ok) {
                     res.addResultElement(this._result.resultElement);

src/param/param-values.ts

@@ -81,16 +81,7 @@ export class ParamValues implements IObjectReference, IterableValues {
     }
 
     public get valueMode() {
-        switch (this._valueMode) {
-            case ParamValueMode.LINK:
-                const pv = this.referencedParamValues;
-                if (pv == undefined)
-                    return undefined;
-                return pv.valueMode;
-
-            default:
-                return this._valueMode;
-        }
+        return this._valueMode;
     }
 
     public set valueMode(m: ParamValueMode) {