ixbrl-viewer 1.4.1__py3-none-any.whl → 1.4.86__py3-none-any.whl

iXBRLViewerPlugin/viewer/src/js/fact.js

@@ -4,44 +4,62 @@ import $ from 'jquery'
 import i18next from "i18next";
 import { Aspect } from "./aspect.js";
 import { Period } from './period.js';
-import { formatNumber } from "./util.js";
+import { formatNumber, localId } from "./util.js";
 import Decimal from "decimal.js";
+import { Interval } from './interval.js';
 
 export class Fact {
     
-    constructor(report, factId) {
-        this.f = report.data.facts[factId];
-        this.ixNode = report.getIXNodeForItemId(factId);
-        this._report = report;
-        this.id = factId;
+    constructor(report, factId, factData) {
+        this.f = factData;
+        this.ixNode = report.reportSet.getIXNodeForItemId(factId);
+        this.report = report;
+        this.vuid = factId;
         this.linkedFacts = [];
+        this._footnotes = [];
     }
 
-    report() {
-        return this._report;
+    localId() {
+        return localId(this.vuid);
+    }
+
+    isMandatory() {
+        return this.f.a.m
     }
 
     getLabel(rolePrefix, withPrefix) {
-        return this._report.getLabel(this.f.a.c, rolePrefix, withPrefix);
+        return this.report.getLabel(this.f.a.c, rolePrefix, withPrefix);
+    }
+
+    getLabelAndLang(rolePrefix, withPrefix) {
+        return this.report.getLabelAndLang(this.f.a.c, rolePrefix, withPrefix);
     }
 
     getLabelOrName(rolePrefix, withPrefix) {
-        return this._report.getLabelOrName(this.f.a.c, rolePrefix, withPrefix);
+        return this.report.getLabelOrName(this.f.a.c, rolePrefix, withPrefix);
+    }
+
+    getLabelOrNameAndLang(rolePrefix, withPrefix) {
+        return this.report.getLabelOrNameAndLang(this.f.a.c, rolePrefix, withPrefix);
     }
 
     conceptName() {
         return this.f.a.c;
     }
 
+    conceptDisplayName() {
+        return this.report.reportSet.taxonomyNamer.convertQName(this.conceptQName());
+    }
+
     concept() {
-        return this._report.getConcept(this.f.a.c); 
+        return this.report.getConcept(this.f.a.c); 
     }
 
     conceptQName() {
-        return this._report.qname(this.f.a.c);
+        return this.report.qname(this.f.a.c);
     }
 
-    period(){
+    period() {
         return new Period(this.f.a.p);
     }
 
@@ -62,10 +80,17 @@ export class Fact {
         return this.f.v;
     }
 
-    readableValue() {
-        let v = this.f.v;
+    readableValue(val) {
+        return this.readableValueHTML(val).textContent;
+    }
+
+    readableValueHTML(val) {
+        let v = val === undefined ? this.f.v : val;
+        const span = document.createElement("span");
+        span.classList.add("fact-value");
         if (this.isInvalidIXValue()) {
-            v = "Invalid value";
+            span.classList.add("fact-value-invalid");
+            span.append(document.createTextNode("Invalid value"));
         }
         else if (this.isNumeric()) {
             const d = this.decimals();
@@ -77,16 +102,19 @@ export class Fact {
                 formattedNumber = formatNumber(v, d);
             }
             if (this.isMonetaryValue()) {
-                v = this.measureLabel() + " " + formattedNumber;
+                span.append(this.unitLabelHTML());
+                span.append(document.createTextNode(" " + formattedNumber));
             }
             else {
-                v = formattedNumber + " " + this.measureLabel();
+                span.append(document.createTextNode(formattedNumber + " "));
+                span.append(this.unitLabelHTML());
             }
         }
         else if (this.isNil()) {
-            v = "nil";
+            span.classList.add("fact-value-nil");
+            span.append(document.createTextNode("nil"));
         }
-        else if (this.escaped()) {
+        else if (this.isTextBlock()) {
             const html = $("<div>").append($($.parseHTML(v, null, false)));
             /* Insert an extra space at the beginning and end of block elements to
              * preserve separation of sections of text. */
@@ -96,31 +124,20 @@ export class Fact {
                 .prepend(document.createTextNode(' '));
             /* Replace runs of whitespace (including nbsp) with a single space */
             v = html.text().replace(/[\u00a0\s]+/g, " ").trim();
+            span.append(document.createTextNode(v));
         }
         else if (this.isEnumeration()) {
             const labels = [];
             for (const qn of v.split(' ')) {
-                labels.push(this._report.getLabelOrName(qn, 'std'));
+                labels.push(this.report.getLabelOrName(qn, 'std'));
             }
             v = labels.join(', ');
+            span.append(document.createTextNode(v));
         }
-        return v;
-    }
-
-    /**
-     * Returns the qname of the first numerator in the fact's unit
-     * @return {String} QName string of a measure
-     */
-    measure() {
-        return this.unit()?.measure();
-    }
-
-    /**
-     * Returns a readable label representing the first numerator in the fact's unit
-     * @return {String} Label representing measure
-     */
-    measureLabel() {
-        return this.unit()?.measureLabel() ?? i18next.t("factDetails.noUnit");
+        else {
+            span.append(document.createTextNode(v));
+        }
+        return span;
     }
 
     /**
@@ -133,25 +150,37 @@ export class Fact {
             if (!unitKey) {
                 return undefined;
             }
-            this._unit = this.report().getUnit(unitKey);
+            this._unit = this.report.reportSet.getUnit(unitKey);
         }
         return this._unit;
     }
 
+    /**
+     * Returns a readable label representing the fact's unit
+     * @return {String} Label representing unit
+     */
+    unitLabel() {
+        return this.unit()?.label() ?? i18next.t("factDetails.noUnit");
+    }
+
+    unitLabelHTML() {
+        return this.unit()?.html() ?? document.createTextNode(i18next.t("factDetails.noUnit"));
+    }
+
     getConceptPrefix() {
         return this.conceptName().split(':')[0];
     }
 
     isCalculationContributor() {
         if (this._isCalculationContributor === undefined) {
-            this._isCalculationContributor = this._report.isCalculationContributor(this.f.a.c);
+            this._isCalculationContributor = this.report.isCalculationContributor(this.f.a.c);
         }
         return this._isCalculationContributor;
     }
 
     isCalculationSummation() {
         if (this._isCalculationSummation === undefined) {
-            this._isCalculationSummation = this._report.isCalculationSummation(this.f.a.c);
+            this._isCalculationSummation = this.report.isCalculationSummation(this.f.a.c);
         }
         return this._isCalculationSummation;
     }
@@ -171,11 +200,11 @@ export class Fact {
     }
 
     hasExplicitDimension() {
-        return Object.keys(this.dimensions()).some(d => !this._report.getConcept(d).isTypedDimension());
+        return Object.keys(this.dimensions()).some(d => !this.report.getConcept(d).isTypedDimension());
     }
 
     hasTypedDimension() {
-        return Object.keys(this.dimensions()).some(d => this._report.getConcept(d).isTypedDimension());
+        return Object.keys(this.dimensions()).some(d => this.report.getConcept(d).isTypedDimension());
     }
 
     isMonetaryValue() {
@@ -186,17 +215,30 @@ export class Fact {
         return this.concept().isTextBlock();
     }
 
+    /**
+     * Get all defined Aspects (sorted by aspect name).
+     *
+     * @returns {Aspect[]} An array of instantiated Aspect objects.
+     */
     aspects() {
-        return Object.keys(this.f.a).map(k => this.aspect(k));
+        return Object.keys(this.f.a)
+            .map(k => this.aspect(k))
+            .sort((a, b) => a.compareTo(b));
     }
 
+    /**
+     * Retrieves or lazily creates an Aspect instance for the given aspect key.
+     *
+     * @param {string} a - The aspect key to retrieve or create.
+     * @returns {Aspect|undefined} The Aspect instance associated with the key, or undefined if not defined in `this.f.a`.
+     */
     aspect(a) {
         if (this._aspects === undefined) {
             this._aspects = {}
         }
         if (this._aspects[a] === undefined) {
             if (this.f.a[a] !== undefined) {
-                this._aspects[a] = new Aspect(a, this.f.a[a], this._report);
+                this._aspects[a] = new Aspect(a, this.f.a[a], this.report);
             }
         }
         return this._aspects[a];
@@ -242,15 +284,17 @@ export class Fact {
     }
 
     duplicates() {
-        return this._report.getAlignedFacts(this);
+        return this.report.getAlignedFacts(this);
     }
 
     isNil() {
         return this.f.v === null;
     }
+
     isNegative() {
         return this.isNumeric() && !this.isNil() && this.value() !== undefined && new Decimal(this.value()).isNegative() && !this.isZero();
     }
+
     isPositive() {
         return this.isNumeric() && !this.isNil() && this.value() !== undefined && new Decimal(this.value()).isPositive() && !this.isZero();
     }
@@ -258,22 +302,18 @@ export class Fact {
     isZero() {
         return this.isNumeric() && !this.isNil() && this.value() !== undefined && new Decimal(this.value()).isZero();
     }
+
     isInvalidIXValue() {
         return this.f.err == 'INVALID_IX_VALUE';
     }
 
     getScaleLabel(value, isAccuracy=false) {
-        let measure = this.measure() ?? '';
-        if (measure) {
-            measure = this.report().qname(measure).localname;
-        }
-        return this._report.getScaleLabel(
+        return this.report.getScaleLabel(
                 // We use the same table of labels for scale and accuracy,
                 // but decimals means "accurate to 10^-N" whereas scale means 10^N,
                 // so invert N for accuracy.
                 isAccuracy ? -value : value,
-                this.isMonetaryValue(),
-                measure
+                this.unit()
         );
     }
 
@@ -311,7 +351,7 @@ export class Fact {
     }
 
     identifier() {
-        return this._report.qname(this.f.a.e);
+        return this.report.qname(this.f.a.e);
     }
 
     escaped() {
@@ -322,8 +362,12 @@ export class Fact {
         return this.concept().isEnumeration();
     }
 
+    addFootnote(fn) {
+        this._footnotes.push(fn);
+    }
+
     footnotes() {
-        return (this.f.fn || []).map((fn, i) => this._report.getItemById(fn));
+        return this._footnotes;
     }
 
     isHidden() {
@@ -336,7 +380,7 @@ export class Fact {
 
     widerConcepts() {
         const concepts = [];
-        const parentsByELR = this._report.getParentRelationships(this.conceptName(), "w-n");
+        const parentsByELR = this.report.getParentRelationships(this.conceptName(), "w-n");
         for (const elr in parentsByELR) {
             concepts.push(...$.map(parentsByELR[elr], (rel) => rel.src));
         }
@@ -345,16 +389,69 @@ export class Fact {
 
     narrowerConcepts() {
         const concepts = [];
-        const childrenByELR = this._report.getChildRelationships(this.conceptName(), "w-n");
+        const childrenByELR = this.report.getChildRelationships(this.conceptName(), "w-n");
         for (const elr in childrenByELR) {
             concepts.push(...$.map(childrenByELR[elr], (rel) => rel.t));
         }
         return concepts;
     }
 
-    // Facts that are the source of relationships to this fact.
+    /*
+     * Facts that are the source of relationships to this fact.
+     */
     addLinkedFact(f) {
         this.linkedFacts.push(f);
     }
-}
 
+    /*
+     * Returns the fact's value, rounded according to the value of its decimals
+     * property.  This is an odd thing to do, as it implies that more figures
+     * were reported than the decimals property suggest are accurate, but this
+     * is required for Calc 1.0 validation.
+     *
+     * valueInterval() is a more meaningful.
+     */
+    roundedValue() {
+        Decimal.rounding = Decimal.ROUND_HALF_UP;
+        const v = new Decimal(this.value());
+        const d = this.decimals();
+        if (d === undefined) {
+            return v;
+        }
+        return v.mul(10 ** d).round().mul(10 ** (0-d));
+    }
+
+    isCompleteDuplicate(other) {
+        return this.value() === other.value() && this.decimals() === other.decimals();
+    }
+
+    /*
+     * Facts that are the source of relationships to this fact.
+     */
+    addLinkedFact(f) {
+        this.linkedFacts.push(f);
+    }
+
+    /*
+     * Returns an Interval for the fact's value, as implied by its decimals
+     * property.
+     */
+    valueInterval() {
+        return Interval.fromFact(this);
+    }
+
+    isMorePrecise(of) {
+        // decimals of "undefined" indicates infinite precision
+        if (of.decimals() === undefined) {
+            return false;
+        }
+        if (this.decimals() === undefined) {
+            return true;
+        }
+        return this.decimals() > of.decimals();
+    }
+
+    targetDocument() {
+        return this.report.targetDocument();
+    }
+}