jupiter-dynamic-forms 1.20.1 → 1.20.2

package/dist/index.mjs

@@ -6154,6 +6154,7 @@ let JupiterFormSection = class extends LitElement {
     this.periodStartDate = "";
     this.periodEndDate = "";
     this.language = "en";
+    this.calculationEnabled = false;
     this._expanded = true;
     this._showAddColumnDialog = false;
     this._sectionPeriodType = "duration";
@@ -6162,7 +6163,7 @@ let JupiterFormSection = class extends LitElement {
     this._boundFieldBlur = (e2) => {
       this._clearHighlights();
       this._focusedConceptId = null;
-      if (this.mode === "readonly")
+      if (this.mode === "readonly" || !this.calculationEnabled)
         return;
       const detail = e2.detail;
       if ((detail == null ? void 0 : detail.conceptId) && (detail == null ? void 0 : detail.columnId)) {
@@ -6198,8 +6199,12 @@ let JupiterFormSection = class extends LitElement {
     if (changedProperties.has("isFirstSection") || changedProperties.has("section")) {
       this._checkAndExpandFirstSection();
     }
-    if (changedProperties.has("section") && ((_a = this.section) == null ? void 0 : _a.concepts)) {
-      this._buildTotalMaps(this.section.concepts);
+    if (changedProperties.has("section") || changedProperties.has("calculationEnabled")) {
+      if (this.calculationEnabled && ((_a = this.section) == null ? void 0 : _a.concepts)) {
+        this._buildTotalMaps(this.section.concepts);
+      } else {
+        this._clearCalculationState();
+      }
     }
   }
   _checkAndExpandFirstSection() {
@@ -6435,6 +6440,21 @@ let JupiterFormSection = class extends LitElement {
     this._totalChildConceptsMap.clear();
     this._traverseTotalGroups(concepts);
   }
+  /**
+   * JDF-041: drops all calculation-warning state — used when the feature is disabled/toggled off.
+   * Clears each existing mismatch through `_clearCalculationMismatch` (rather than resetting the
+   * map directly) so the parent's validation summary, which tracks mismatches via the dispatched
+   * `calculation-mismatch-changed` events, is told about each removal instead of being left stale.
+   */
+  _clearCalculationState() {
+    this._totalChildrenMap.clear();
+    this._memberParentMap.clear();
+    this._totalConceptMap.clear();
+    this._totalChildConceptsMap.clear();
+    for (const key of Array.from(this._calculationMismatches.keys())) {
+      this._clearCalculationMismatch(key);
+    }
+  }
   /**
    * JDF-038: XBRL uses more than one preferredLabel role to mark a "total" row — the plain
    * `.../role/totalLabel` and the sign-flipped `.../role/negatedTotalLabel` (used for subtotals of
@@ -6445,6 +6465,15 @@ let JupiterFormSection = class extends LitElement {
   static _isTotalLabel(preferredLabel) {
     return !!(preferredLabel == null ? void 0 : preferredLabel.toLowerCase().includes("totallabel"));
   }
+  /**
+   * JDF-041: distinguishes a self-contained "deduction block" subtotal (negatedTotalLabel, e.g.
+   * "Total of sum of expenses") from a plain cascading/running total. Only the latter is treated as
+   * additively built on the total before it — a negatedTotalLabel row summarizes just the raw items
+   * directly before it and must not also absorb an unrelated earlier total into its own check.
+   */
+  static _isNegatedTotalLabel(preferredLabel) {
+    return !!(preferredLabel == null ? void 0 : preferredLabel.toLowerCase().includes("negatedtotallabel"));
+  }
   /**
    * A member of a total's sibling/child group can itself be a presentation-only abstract wrapper
    * (e.g. "Group equity" wrapping Equity + Third party share + "Total of group equity") rather than
@@ -6475,6 +6504,47 @@ let JupiterFormSection = class extends LitElement {
       this._memberParentMap.set(memberId, totalConcept.id);
     }
   }
+  /**
+   * JDF-041: computes the JDF-030 sibling-fallback member set for a total at `concepts[i]`, given the
+   * nearest preceding total's index (`lastTotalIdx`, -1 if none) and the raw siblings between them.
+   *
+   * - No preceding total → members are just the raw siblings (unchanged, e.g. the very first total
+   *   in the role).
+   * - This total is itself a negatedTotalLabel (a self-contained deduction-block subtotal, e.g.
+   *   "Total of sum of expenses") → the preceding total stays a scan boundary only, never a member —
+   *   it summarizes just its own raw siblings, same as before JDF-041.
+   * - Otherwise (a plain totalLabel, cascading/running total) with raw siblings before it → the
+   *   preceding total is included as a real member alongside them, since this total is built
+   *   additively on top of it.
+   * - Otherwise (a plain totalLabel adjacent to the preceding total, zero raw siblings between them):
+   *   if that preceding total is itself a negatedTotalLabel subtotal, it doesn't carry the running
+   *   total from before it forward (per the rule above) — reach one more hop back to also include the
+   *   total the subtotal was deducted from (e.g. "Net operating result" needs both "Gross operating
+   *   result" and "Total of sum of expenses", not just the latter). Otherwise, the single preceding
+   *   total is the member, as it was for JDF-038's original adjacent-boundary case.
+   */
+  _resolveTotalGroupMembers(concepts, i2, lastTotalIdx, siblings) {
+    if (lastTotalIdx < 0)
+      return siblings;
+    const concept = concepts[i2];
+    if (JupiterFormSection._isNegatedTotalLabel(concept.preferredLabel)) {
+      return siblings.length > 0 ? siblings : [concepts[lastTotalIdx]];
+    }
+    if (siblings.length > 0) {
+      return [concepts[lastTotalIdx], ...siblings];
+    }
+    if (JupiterFormSection._isNegatedTotalLabel(concepts[lastTotalIdx].preferredLabel)) {
+      let grandTotalIdx = -1;
+      for (let k = lastTotalIdx - 1; k >= 0; k--) {
+        if (JupiterFormSection._isTotalLabel(concepts[k].preferredLabel)) {
+          grandTotalIdx = k;
+          break;
+        }
+      }
+      return grandTotalIdx >= 0 ? [concepts[grandTotalIdx], concepts[lastTotalIdx]] : [concepts[lastTotalIdx]];
+    }
+    return [concepts[lastTotalIdx]];
+  }
   _traverseTotalGroups(concepts) {
     var _a, _b;
     for (let i2 = 0; i2 < concepts.length; i2++) {
@@ -6491,10 +6561,9 @@ let JupiterFormSection = class extends LitElement {
             }
           }
           const siblings = concepts.slice(lastTotalIdx + 1, i2);
-          if (siblings.length > 0) {
-            this._registerTotalGroup(concept, siblings);
-          } else if (lastTotalIdx >= 0) {
-            this._registerTotalGroup(concept, [concepts[lastTotalIdx]]);
+          const members = this._resolveTotalGroupMembers(concepts, i2, lastTotalIdx, siblings);
+          if (members.length > 0) {
+            this._registerTotalGroup(concept, members);
           }
         }
       }
@@ -6529,7 +6598,7 @@ let JupiterFormSection = class extends LitElement {
       return;
     }
     const children = this._totalChildConceptsMap.get(totalConceptId) || [];
-    const { calculatedSum, hasAnyValue, breakdown } = JupiterFormSection._buildCalculationBreakdown(
+    const { calculatedSum, hasAnyValue, breakdown } = this._buildCalculationBreakdown(
       children,
       this.formData,
       columnId,
@@ -6576,19 +6645,46 @@ let JupiterFormSection = class extends LitElement {
   static _resolveWeight(totalBalance, childBalance) {
     return !totalBalance || !childBalance || totalBalance === childBalance ? 1 : -1;
   }
-  static _buildCalculationBreakdown(children, formData, columnId, totalBalance) {
+  /**
+   * JDF-041: a group member can itself be a registered cascading total with no entered value (e.g. a
+   * customer who fills in "Operating income" directly without ever populating the "Net operating
+   * result" running-subtotal row it's built on). Treating a blank member as a zero contribution
+   * silently drops whatever it's actually built from and produces a false-positive mismatch. Instead,
+   * look through a blank total member into its own registered members, recursively, so the check
+   * reaches the real entered values wherever they are in the chain. `visited`/`depth` guard against
+   * cycles and unbounded recursion (mirrors `_resolveValueConcept`'s depth cutoff).
+   */
+  _resolveMemberContributions(member, weight, formData, columnId, visited, depth = 0) {
     var _a;
+    const val = parseFloat((_a = formData[member.id]) == null ? void 0 : _a[columnId]);
+    if (!isNaN(val)) {
+      return [{ conceptId: member.id, label: member.label, value: val, balance: member.balance, weight }];
+    }
+    if (depth >= 5 || visited.has(member.id))
+      return [];
+    const nestedMembers = this._totalChildConceptsMap.get(member.id);
+    if (!nestedMembers)
+      return [];
+    const nextVisited = new Set(visited).add(member.id);
+    const contributions = [];
+    for (const nested of nestedMembers) {
+      const nestedWeight = weight * JupiterFormSection._resolveWeight(member.balance, nested.balance);
+      contributions.push(...this._resolveMemberContributions(nested, nestedWeight, formData, columnId, nextVisited, depth + 1));
+    }
+    return contributions;
+  }
+  _buildCalculationBreakdown(children, formData, columnId, totalBalance) {
     let calculatedSum = 0;
     let hasAnyValue = false;
     const breakdown = [];
     for (const child of children) {
-      const val = parseFloat((_a = formData[child.id]) == null ? void 0 : _a[columnId]);
-      if (isNaN(val))
-        continue;
-      hasAnyValue = true;
       const weight = JupiterFormSection._resolveWeight(totalBalance, child.balance);
-      calculatedSum += weight * val;
-      breakdown.push({ conceptId: child.id, label: child.label, value: val, balance: child.balance, weight });
+      const contributions = this._resolveMemberContributions(child, weight, formData, columnId, /* @__PURE__ */ new Set());
+      for (const contribution of contributions) {
+        calculatedSum += contribution.weight * contribution.value;
+        hasAnyValue = true;
+        breakdown.push(contribution);
+      }
     }
     return { calculatedSum, hasAnyValue, breakdown };
   }
@@ -7251,6 +7347,9 @@ __decorateClass$3([
 __decorateClass$3([
   n2({ type: String })
 ], JupiterFormSection.prototype, "language", 2);
+__decorateClass$3([
+  n2({ type: Boolean })
+], JupiterFormSection.prototype, "calculationEnabled", 2);
 __decorateClass$3([
   r()
 ], JupiterFormSection.prototype, "_expanded", 2);
@@ -9292,6 +9391,7 @@ let JupiterDynamicForm = class extends LitElement {
     this.initialData = {};
     this.disabled = false;
     this.readonly = false;
+    this.calculationEnabled = false;
     this.periodStartDate = "2025-01-01";
     this.periodEndDate = "2025-12-31";
     this.language = "en";
@@ -13035,6 +13135,7 @@ let JupiterDynamicForm = class extends LitElement {
             .masterData="${this._effectiveMasterData}"
             .periodStartDate="${this.periodStartDate}"
             .periodEndDate="${this.periodEndDate}"
+            .calculationEnabled="${this.calculationEnabled}"
             @field-change="${this._handleFieldChange}"
             @period-change="${this._handlePeriodChange}"
             @typed-member-change="${this._handleTypedMemberChange}"
@@ -13182,6 +13283,7 @@ let JupiterDynamicForm = class extends LitElement {
                 .masterData="${this._effectiveMasterData}"
                 .periodStartDate="${this.periodStartDate}"
                 .periodEndDate="${this.periodEndDate}"
+                .calculationEnabled="${this.calculationEnabled}"
                 @field-change="${this._handleFieldChange}"
                 @typed-member-change="${this._handleTypedMemberChange}"
                 @add-concept-repeat="${this._handleAddConceptRepeat}"
@@ -14518,6 +14620,9 @@ __decorateClass([
 __decorateClass([
   n2({ type: Boolean })
 ], JupiterDynamicForm.prototype, "readonly", 2);
+__decorateClass([
+  n2({ type: Boolean, attribute: "calculation-enabled" })
+], JupiterDynamicForm.prototype, "calculationEnabled", 2);
 __decorateClass([
   n2({ type: String })
 ], JupiterDynamicForm.prototype, "periodStartDate", 2);