Work on nghyd#169

src/nub.ts

 import { ParamDefinition, ParamsEquation, Session, Structure } from ".";
 import { ComputeNode } from "./compute-node";
 import { Dichotomie } from "./dichotomie";
-import { INamedIterableValues, IterableValues } from "./param/param-value-iterator";
 import { ParamValueMode } from "./param/param-value-mode";
+import { ParamValues } from "./param/param-values";
 import { Props } from "./props";
 import { IObservable, Observable, Observer } from "./util/observer";
 import { Result } from "./util/result";
@@ -110,7 +110,8 @@ export abstract class Nub extends ComputeNode implements IObservable {
     public CalcSerie(rInit?: number, sDonnee?: any): Result {
         let computedParam: ParamDefinition;
         // instance de ParamValues utilisée pour le paramètre varié (qui peut être un paramètre référencé (importé))
-        let variatedValues: IterableValues;
+        let variatedParam: ParamDefinition;
+        let variatedValues: ParamValues;
 
         // chain computation
         const requiredNubs1stLevel = Session.getInstance().getRequiredNubs(this);
@@ -137,7 +138,7 @@ export abstract class Nub extends ComputeNode implements IObservable {
 
                 case ParamValueMode.LISTE:
                 case ParamValueMode.MINMAX:
-                    variatedValues = this.setVariatedValues(p, variatedValues);
+                    variatedParam = this.setVariatedValues(p, variatedParam);
                     break;
 
                 case ParamValueMode.CALCUL:
@@ -149,17 +150,16 @@ export abstract class Nub extends ComputeNode implements IObservable {
                         && p.referencedValue.isResult()
                         && (p.referencedValue.element as Result).nbResultElements > 1
                     ) {
-                        variatedValues = this.setVariatedValues(p, variatedValues);
+                        variatedParam = this.setVariatedValues(p, variatedParam);
                     }
                     break;
 
                 case ParamValueMode.LINK:
                     if (
                         p.isReferenceDefined()
-                        && p.referencedValue.isResult()
-                        && (p.referencedValue.element as Result).nbResultElements > 1
+                        && p.referencedValue.hasMultipleValues()
                     ) {
-                        variatedValues = this.setVariatedValues(p, variatedValues);
+                        variatedParam = this.setVariatedValues(p, variatedParam);
                     }
                     break;
 
@@ -183,9 +183,13 @@ export abstract class Nub extends ComputeNode implements IObservable {
             rInit = computedParam.v;
         }
 
-        if (variatedValues === undefined) {
+        if (variatedParam === undefined) {
             this._result = this.Calc(computedSymbol, rInit); // résultat dans this._result
         } else {
+            // extract variated values from variated Parameter
+            // (in LINK mode, proxies to target data)
+            variatedValues = variatedParam.paramValues;
+
             const res = new Result();
             variatedValues.initValuesIterator(false);
             while (variatedValues.hasNext) {
@@ -661,7 +665,7 @@ export abstract class Nub extends ComputeNode implements IObservable {
     /**
      * Sets the variated values and warns if there were already some
      */
-    private setVariatedValues(newValues: INamedIterableValues, oldValues: IterableValues) {
+    private setVariatedValues(newValues: ParamDefinition, oldValues: ParamDefinition): ParamDefinition {
         if (oldValues === undefined) {
             return newValues;
         } else {

src/value_ref/object_ref.ts

@@ -103,13 +103,36 @@ export class LinkedValue {
         }
 
         if (this.isParameter()) {
-            // simple proxy to parameter; target might be in CALC mode
-            ret = (this.element as ParamDefinition).paramValues;
+            const targetParam = (this.element as ParamDefinition);
+
+            // target might be in CALC mode
+            if (targetParam.valueMode === ParamValueMode.CALCUL) {
+                // if already computed, expose handmade fake param values for iterability
+                if (this.nub.result) {
+                    ret = new ParamValues();
+                    if (targetParam.hasMultipleValues) {
+                        const multipleRes = this.nub.result.getCalculatedValues();
+                        ret.setValues(multipleRes);
+                    } else {
+                        const singleRes = this.nub.result.vCalc;
+                        ret.setSingleValue(singleRes);
+                    }
+                } else {
+                    // else simple parameter proxy (see below)
+                    ret = targetParam.paramValues;
+                }
+
+            } else {
+                // simple proxy to target parameter values; if target parameter is
+                // also a LINK, ParamDefinition.paramValues will recursively call
+                // LinkedValue.getParamValues() (this method)
+                ret = targetParam.paramValues;
+            }
 
         } else if (this.isExtraResult()) {
             // is result available ?
             if (this.nub.result) {
-                // handmade fake param values
+                // expose handmade fake param values for iterability
                 ret = new ParamValues();
 
                 if (this.nub.resultHasMultipleValues()) {