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

iXBRLViewerPlugin/viewer/src/js/report.js

@@ -1,419 +1,328 @@
 // See COPYRIGHT.md for copyright information
 
-import { Fact } from "./fact.js"
-import { Footnote } from "./footnote.js"
-import { QName } from "./qname.js"
 import { Concept } from "./concept.js";
-import { Unit } from "./unit";
-import { ViewerOptions } from "./viewerOptions.js";
-import { setDefault, titleCase } from "./util.js";
-import $ from 'jquery'
+import { setDefault } from "./util.js";
 import i18next from "i18next";
 
-export function iXBRLReport (data) {
-    this.data = data;
-    // A map of IDs to Fact and Footnote objects
-    this._items = {};
-    this._ixNodeMap = {};
-    this._viewerOptions = new ViewerOptions();
-    this._reverseRelationshipCache = {};
-}
+// Class to represent the XBRL data from a single target document in a single
+// Inline XBRL Document or Document Set.
 
-/*
- * Set additional information about facts obtained from parsing the iXBRL.
- */
-iXBRLReport.prototype.setIXNodeMap = function(ixData) {
-    this._ixNodeMap = ixData;
-    this._initialize();
-}
+export class XBRLReport {
 
-iXBRLReport.prototype._initialize = function () {
+    constructor(reportSet, reportData) {
+        this.reportSet = reportSet;
+        this._reportData = reportData;
+        // A map of IDs to Fact and Footnote objects
+        this._reverseRelationshipCache = {};
+    }
 
-    // Build an array of footnotes IDs in document order so that we can assign
-    // numbers to foonotes
-    var fnorder = Object.keys(this._ixNodeMap).filter((id) => this._ixNodeMap[id].footnote);
-    fnorder.sort((a,b) => this._ixNodeMap[a].docOrderindex - this._ixNodeMap[b].docOrderindex);
+    availableLanguages() {
+        if (!this._availableLanguages) {
+            this._availableLanguages = new Set()
+            for (const c of Object.values(this._reportData.concepts)) {
+                for (const ll of Object.values(c.labels)) {
+                    for (const lang of Object.keys(ll)) {
+                        this._availableLanguages.add(lang);
+                    }
+                }
+            }
+        }
+        return this._availableLanguages;
+    }
 
-    // Create Fact objects for all facts.
-    for (const id in this.data.facts) {
-        this._items[id] = new Fact(this, id);
+    facts() {
+        return this.reportSet.factsForReport(this);
     }
 
-    // Now resolve footnote references, creating footnote objects for "normal"
-    // footnotes, and finding Fact objects for fact->fact footnotes.  
-    //
-    // Associate source facts with target footnote/facts to allow two way
-    // navigation.
-    for (const id in this.data.facts) {
-        const f = this._items[id];
-        const fns = this.data.facts[id].fn || [];
-        fns.forEach((fnid) => {
-            var fn = this._items[fnid];
-            if (fn === undefined) {
-                fn = new Footnote(this, fnid, "Footnote " + (fnorder.indexOf(fnid) + 1));
-                this._items[fnid] = fn;
-            }
-            // Associate fact with footnote
-            fn.addLinkedFact(f);
-        });
+    targetDocument() {
+        return this._reportData.target ?? null;
     }
-}
 
-iXBRLReport.prototype.isCalculationContributor = function(c) {
-    if (this._calculationContributors === undefined) {
-        if (this.data.rels?.calc) {
-            this._calculationContributors = new Set(Object.values(this.data.rels.calc).flatMap(calculations => {
-                return Object.values(calculations).flatMap(contributors => {
-                    return contributors.map(c => c.t);
-                });
-            }));
-        } else {
-            this._calculationContributors = new Set();
+    getChildRelationships(conceptName, arcrole) {
+        const rels = {}
+        const elrs = this._reportData.rels[arcrole] || {};
+        for (const elr in elrs) {
+            if (conceptName in elrs[elr]) {
+                rels[elr] = elrs[elr][conceptName];
+            }
         }
+        return rels;
     }
-    return this._calculationContributors.has(c);
-}
 
-iXBRLReport.prototype.isCalculationSummation = function(c) {
-    if (this._calculationSummations === undefined) {
-        if (this.data.rels?.calc) {
-            this._calculationSummations = new Set(Object.values(this.data.rels.calc).flatMap(calculations => {
-                return Object.keys(calculations);
-            }));
-        } else {
-            this._calculationSummations = new Set();
+    /* 
+     * Build and cache an inverse map of relationships for a given arcrole for
+     * efficient lookup of parents concept from a child.
+     *
+     * Map is arcrole => elr => target => [ rel, ... ]
+     *
+     * "rel" is modified to have a "src" property with the source concept.
+     */
+    _reverseRelationships(arcrole) {
+        if (!(arcrole in this._reverseRelationshipCache)) {
+            const rrc = {};
+            const elrs = this._reportData.rels[arcrole] || {};
+            for (const [elr, relSet] of Object.entries(elrs)) {
+                for (const [src, rels] of Object.entries(relSet)) {
+                    for (const r of rels) {
+                        r.src = src;
+                        setDefault(setDefault(rrc, elr, {}), r.t, []).push(r);
+                    }
+                }
+            }
+            this._reverseRelationshipCache[arcrole] = rrc;
         }
+        return this._reverseRelationshipCache[arcrole];
     }
-    return this._calculationSummations.has(c);
-}
 
-iXBRLReport.prototype.getLabel = function(c, rolePrefix, showPrefix) {
-    rolePrefix = rolePrefix || 'std';
-    var lang = this._viewerOptions.language;
-    const concept = this.data.concepts[c];
-    if (concept === undefined) {
-        console.log("Attempt to get label for undefined concept: " + c);
-        return "<no label>";
-    }
-    const labels = concept.labels[rolePrefix]
-    if (labels === undefined || Object.keys(labels).length == 0) {
-        return undefined;
-    }
-    else {
-        var label;
-        if (lang && labels[lang]) {
-            label = labels[lang];
-        }
-        else {
-            // Fall back on English, then any label deterministically.
-            label = labels["en"] || labels["en-us"] || labels[Object.keys(labels).sort()[0]];
-        }
-        if (label === undefined) {
-            return undefined;
-        }
-        var s = '';
-        if (showPrefix && this._viewerOptions.showPrefixes) {
-            s = "(" + this.qname(c).prefix + ") ";
+    getParentRelationships(conceptName, arcrole) {
+        const rels = {}
+        for (const [elr, relSet] of Object.entries(this._reverseRelationships(arcrole))) {
+            if (conceptName in relSet) {
+                rels[elr] = relSet[conceptName];
+            }
         }
-        s += label;
-        return s;
+        return rels;
     }
-}
 
-iXBRLReport.prototype.getLabelOrName = function(c, rolePrefix, showPrefix) {
-    const label = this.getLabel(c, rolePrefix, showPrefix);
-    if (label === undefined) {
-        return c;
+    getParentRelationshipsInGroup(conceptName, arcrole, elr) {
+        const relSet = this._reverseRelationships(arcrole)[elr] || {};
+        return relSet[conceptName] || [];
     }
-    return label;
-}
-
-iXBRLReport.prototype.availableLanguages = function() {
-    if (!this._availableLanguages) {
-        var map = {};
-        $.each(this.data.concepts, function (k,v) {
-            $.each(v.labels, function (rolePrefx, ll) {
-                $.each(ll, function (lang, v) {
-                    map[lang] = 1;
-                });
-            });
-        });
-        this._availableLanguages = Object.keys(map);
 
+    dimensionDefault(dimensionName) {
+        // ELR is irrelevant for dimension-default relationships, so check all of
+        // them, and return the first (illegal for there to be more than one
+        for (const rel of Object.values(this._reportData.rels["d-d"] || {})) {
+            if (dimensionName in rel) {
+                return rel[dimensionName][0].t;
+            }
+        }
+        return undefined;
     }
-    return this._availableLanguages;
-}
-
-iXBRLReport.prototype.languageNames = function() {
-    return this.data.languages;
-}
-
-iXBRLReport.prototype.getItemById = function(id) {
-    return this._items[id];
-}
-
-iXBRLReport.prototype.getIXNodeForItemId = function(id) {
-    return this._ixNodeMap[id] || {};
-}
-
-iXBRLReport.prototype.facts = function() {
-    return Object.keys(this.data.facts).map(id => this.getItemById(id));
-}
-
-iXBRLReport.prototype.filingDocuments = function() {
-    return this.data.filingDocuments;
-}
-
-iXBRLReport.prototype.prefixMap = function() {
-    return this.data.prefixes;
-}
 
-iXBRLReport.prototype.getUsedPrefixes = function() {
-    if (this._usedPrefixes === undefined) {
-        this._usedPrefixes = new Set(Object.values(this._items)
-                .filter(f => f instanceof Fact)
-                .map(f => f.getConceptPrefix()));
+    relationshipGroups(arcrole) {
+        return Object.keys(this._reportData.rels[arcrole] || {});
     }
-    return this._usedPrefixes;
-}
 
-/**
- * Returns a set of OIM format unit strings used by facts on this report. Lazy-loaded.
- * @return {Set[String]} Set of OIM format unit strings
- */
-iXBRLReport.prototype.getUsedUnits = function() {
-    if (this._usedUnits === undefined) {
-        this._usedUnits = new Set(Object.values(this._items)
-                .filter(f => f instanceof Fact)
-                .map(f => f.unit()?.value())
-                .filter(f => f)
-                .sort());
+    relationshipGroupRoots(arcrole, elr) {
+        const roots = [];
+        for (const conceptName in this._reportData.rels[arcrole][elr]) {
+            if (!(elr in this.getParentRelationships(conceptName, arcrole))) {
+                roots.push(conceptName);
+            }
+        }
+        return roots;
     }
-    return this._usedUnits;
-}
 
-/**
- * Returns details about the provided unit. Lazy-loaded once per unit.
- * @param  {String} unitKey  Unit in OIM format
- * @return {Unit}  Unit instance corresponding with provided key
- */
-iXBRLReport.prototype.getUnit = function(unitKey) {
-    if (this._unitsMap === undefined) {
-        this._unitsMap = {};
-    }
-    if (this._unitsMap[unitKey] === undefined) {
-        this._unitsMap[unitKey] = new Unit(this, unitKey)
+    getAlignedFacts(f, coveredAspects) {
+        // XXX should filter to current report facts?
+        const all = this.reportSet.facts();
+        const aligned = [];
+        if (!coveredAspects) {
+            coveredAspects = {};
+        }
+        for (const ff of all) {
+            if (ff.isAligned(f, coveredAspects)) {
+                aligned.push(ff);
+            }
+        }
+        return aligned; 
     }
-    return this._unitsMap[unitKey];
-}
 
-iXBRLReport.prototype.getUsedScalesMap = function() {
-    // Do not lazy load. This is language-dependent so needs to re-evaluate after language changes.
-    const usedScalesMap = {};
-    Object.values(this._items)
-        .filter(f => f instanceof Fact)
-        .forEach(fact => {
-            const scale = fact.scale();
-            if (scale !== null && scale !== undefined) {
-                if (!(scale in usedScalesMap)) {
-                    usedScalesMap[scale] = new Set();
-                }
-                const labels = usedScalesMap[scale];
-                const label = titleCase(fact.getScaleLabel(scale));
-                if (label && !labels.has(label)) {
-                    labels.add(label);
+    deduplicate(facts) {
+        const ff = [];
+        for (const f of facts) {
+            let dupe = false;
+            for (const other of ff) {
+                if (other.isAligned(f,{})) {
+                    dupe = true;
                 }
             }
-        });
-    return usedScalesMap;
-}
-
-iXBRLReport.prototype.roleMap = function() {
-    return this.data.roles;
-}
-
-iXBRLReport.prototype.qname = function(v) {
-    return new QName(this.prefixMap(), v);
-}
-
-iXBRLReport.prototype.getChildRelationships = function(conceptName, arcrole) {
-    var rels = {}
-    const elrs = this.data.rels[arcrole] || {};
-    for (const elr in elrs) {
-        if (conceptName in elrs[elr]) {
-            rels[elr] = elrs[elr][conceptName];
+            if (!dupe) {
+                ff.push(f);
+            }
         }
+        return ff;
     }
-    return rels;
-}
 
-/* 
- * Build and cache an inverse map of relationships for a given arcrole for
- * efficient lookup of parents concept from a child.
- *
- * Map is arcrole => elr => target => [ rel, ... ]
- *
- * "rel" is modified to have a "src" property with the source concept.
- */
-iXBRLReport.prototype._reverseRelationships = function(arcrole) {
-    if (!(arcrole in this._reverseRelationshipCache)) {
-        const rrc = {};
-        const elrs = this.data.rels[arcrole] || {};
-        for (const [elr, relSet] of Object.entries(elrs)) {
-            for (const [src, rels] of Object.entries(relSet)) {
-                for (const r of rels) {
-                    r.src = src;
-                    setDefault(setDefault(rrc, elr, {}), r.t, []).push(r);
-                }
+    getConcept(name) {
+        return new Concept(this, name);
+    }
+
+    getRoleLabel(rolePrefix) {
+        /* This is currently hard-coded to "en" as the generator does not yet
+         * support generic labels, and instead provides the (non-localisable) role
+         * definition as a single "en" label.
+         *
+         * Returns the ELR URI if there is no label
+         */
+        const labels = this._reportData.roleDefs[rolePrefix];
+        if (labels !== undefined) {
+            const label = labels["en"];
+            // Earlier versions of the generator added a "null" label if no labels
+            // were available.
+            if (label !== undefined && label !== null) {
+                return label;
             }
         }
-        this._reverseRelationshipCache[arcrole] = rrc;
+        return undefined;
     }
-    return this._reverseRelationshipCache[arcrole];
-}
 
-iXBRLReport.prototype.getParentRelationships = function(conceptName, arcrole) {
-    var rels = {}
-    for (const [elr, relSet] of Object.entries(this._reverseRelationships(arcrole))) {
-        if (conceptName in relSet) {
-            rels[elr] = relSet[conceptName];
-        }
+    getRoleLabelOrURI(rolePrefix) {
+        return this.getRoleLabel(rolePrefix) ?? this.reportSet.roleMap()[rolePrefix];
     }
-    return rels;
-}
 
-iXBRLReport.prototype.getParentRelationshipsInGroup = function(conceptName, arcrole, elr) {
-    var rels = {}
-    const relSet = this._reverseRelationships(arcrole)[elr] || {};
-    return relSet[conceptName] || [];
-}
+    getLabelRoleLabel(rolePrefix) {
+        const roleURI = this.reportSet.roleMap()[rolePrefix];
+        if (roleURI === undefined) {
+            return undefined;
+        }
 
-iXBRLReport.prototype.dimensionDefault = function(dimensionName) {
-    // ELR is irrelevant for dimension-default relationships, so check all of
-    // them, and return the first (illegal for there to be more than one
-    for (const rel of Object.values(this.data.rels["d-d"] || {})) {
-        if (dimensionName in rel) {
-            return rel[dimensionName][0].t;
+        // Built-in label roles don't have a definition in the taxonomy. Do an
+        // i18n look-up on the last part of the URI. For "en" the camel-case
+        // splitter will do what we want for everything except standard label
+        // and documentation label 
+        const suffix = roleURI.split("/").pop();
+        if (roleURI.startsWith("http://www.xbrl.org/2003/role/") && i18next.exists(`labelRoles:${suffix}`)) {
+            return i18next.t(`labelRoles:${suffix}`);
         }
-    }
-    return undefined;
-}
 
-iXBRLReport.prototype.relationshipGroups = function(arcrole) {
-    return Object.keys(this.data.rels[arcrole] || {});
-}
+        // Attempt to get a label from the role definition
+        const label = this.getRoleLabel(rolePrefix);
+        if (label !== undefined) {
+            return label;
+        }
+
+        // Fall back on de-camel-casing the last part of the URI
+        return suffix
+            .replaceAll(/([A-Z][a-z]+)/g, ' $1')
+            .trim()
+            .replace(/^./, s => s.toUpperCase());
+    }
 
-iXBRLReport.prototype.relationshipGroupRoots = function(arcrole, elr) {
-    var roots = [];
-    for (const conceptName in this.data.rels[arcrole][elr]) {
-        if (!(elr in this.getParentRelationships(conceptName, arcrole))) {
-            roots.push(conceptName);
+    localDocuments() {
+        if (this._reportData.localDocs === undefined) {
+            return {}
         }
+        return this._reportData.localDocs;
     }
-    return roots;
-}
 
-iXBRLReport.prototype.getAlignedFacts = function(f, coveredAspects) {
-    var all = this.facts();
-    var aligned = [];
-    if (!coveredAspects) {
-        coveredAspects = {};
+    qname(v) {
+        return this.reportSet.qname(v);
     }
-    $.each(all, function (i, ff) {
-        if (ff.isAligned(f, coveredAspects)) {
-            aligned.push(ff);
-        }
-    });
-    return aligned; 
-}
 
-iXBRLReport.prototype.deduplicate = function (facts) {
-    var ff = [];
-    $.each(facts, function (i, f) {
-        var dupe = false;
-        $.each(ff, function (j, of) {
-            if (of.isAligned(f,{})) {
-                dupe = true;
+    getScaleLabel(scale, unit) {
+        let label = i18next.t(`scale:${scale}`, {defaultValue:"noName"});
+        if (unit && unit.isMonetary() && scale === -2) {
+            let measure = unit.value() ?? '';
+            if (measure) {
+                measure = this.qname(measure).localname;
             }
-        });
-        if (!dupe){
-            ff.push(f);
+            label = i18next.t(`currencies:cents${measure}`, {defaultValue: label});
         }
-    });
-    return ff;
-}
-
-iXBRLReport.prototype.setViewerOptions = function (vo) {
-    this._viewerOptions = vo;
-}
+        if (label === "noName") {
+            return null;
+        }
+        return label;
+    }
 
-iXBRLReport.prototype.namespaceGroups = function () {
-    var counts = {};
-    $.each(this.facts(), function (i, f) {
-        counts[f.conceptQName().prefix] = counts[f.conceptQName().prefix] || 0;
-        counts[f.conceptQName().prefix]++;
-    });
-    var prefixes = Object.keys(counts);
-    prefixes.sort(function (a, b) { return counts[b] - counts[a] });
-    return prefixes;
-}
+    concepts() {
+        return this._reportData.concepts;
+    }
 
-iXBRLReport.prototype.getConcept = function(name) {
-    return new Concept(this, name);
-}
+    getLabel(c, rolePrefix, showPrefix) {
+        return this.getLabelAndLang(c, rolePrefix, showPrefix).label;
+    }
 
-iXBRLReport.prototype.getRoleLabel = function(rolePrefix, viewerOptions) {
-    /* This is currently hard-coded to "en" as the generator does not yet
-     * support generic labels, and instead provides the (non-localisable) role
-     * definition as a single "en" label.
-     *
-     * Returns the ELR URI if there is no label
-     */
-    const labels = this.data.roleDefs[rolePrefix];
-    if (labels !== undefined) {
-        const label = labels["en"];
-        // Earlier versions of the generator added a "null" label if no labels
-        // were available.
-        if (label !== undefined && label !== null) {
-            return label;
+    getLabelAndLang(c, rolePrefix, showPrefix) {
+        rolePrefix = rolePrefix || 'std';
+        const lang = this.reportSet.viewerOptions.language;
+        const concept = this._reportData.concepts[c];
+        if (concept === undefined) {
+            console.log("Attempt to get label for undefined concept: " + c);
+            return { label: "<no label>" };
+        }
+        const labels = concept.labels[rolePrefix]
+        if (labels === undefined || Object.keys(labels).length == 0) {
+            return { label: undefined };
+        }
+        else {
+            let label;
+            let actualLang;
+            if (lang && labels[lang]) {
+                label = labels[lang];
+                actualLang = lang;
+            }
+            else {
+                // Fall back on English, then any label deterministically.
+                for (const l of ["en", "en-us", Object.keys(labels).sort()[0]]) {
+                    if (labels[l] !== undefined) {
+                        label = labels[l];
+                        actualLang = l;
+                        break;
+                    }
+                }
+            }
+            if (label === undefined) {
+                return {label: undefined};
+            }
+            let s = '';
+            if (showPrefix && this.reportSet.viewerOptions.showPrefixes) {
+                s = "(" + this.reportSet.taxonomyNamer.fromQName(this.qname(c)).prefix + ") ";
+            }
+            s += label;
+            return { label: s, lang: actualLang };
         }
     }
-    return this.roleMap()[rolePrefix];
-}
 
-iXBRLReport.prototype.localDocuments = function() {
-    if (this.data.localDocs === undefined) {
-        return {}
+    getLabelOrName(c, rolePrefix, showPrefix) {
+        const label = this.getLabel(c, rolePrefix, showPrefix);
+        if (label === undefined) {
+            return c;
+        }
+        return label;
     }
-    return this.data.localDocs;
-}
 
-iXBRLReport.prototype.documentSetFiles = function() {
-    if (this.data.docSetFiles === undefined) {
-        return []
+    getLabelOrNameAndLang(c, rolePrefix, showPrefix) {
+        const labelLang = this.getLabelAndLang(c, rolePrefix, showPrefix);
+        if (labelLang.label === undefined) {
+            return { label: c };
+        }
+        return labelLang;
     }
-    return this.data.docSetFiles;
-}
-
-iXBRLReport.prototype.isDocumentSet = function() {
-    return this.documentSetFiles().length > 1;
-}
-
-iXBRLReport.prototype.usesAnchoring = function() {
-    return this.data.rels["w-n"] !== undefined;
-}
 
-iXBRLReport.prototype.hasValidationErrors = function() {
-    return this.data.validation !== undefined && this.data.validation.length > 0;
-}
+    isCalculationContributor(c) {
+        if (this._calculationContributors === undefined) {
+            if (this._reportData.rels?.calc) {
+                this._calculationContributors = new Set(Object.values(this._reportData.rels.calc).flatMap(calculations => {
+                    return Object.values(calculations).flatMap(contributors => {
+                        return contributors.map(c => c.t);
+                    });
+                }));
+            } else {
+                this._calculationContributors = new Set();
+            }
+        }
+        return this._calculationContributors.has(c);
+    }
 
-iXBRLReport.prototype.getScaleLabel = function(scale, isMonetaryValue, currency=null) {
-    var label = i18next.t(`scale.${scale}`, {defaultValue:"noName"});
-    if (isMonetaryValue && scale === -2) {
-        label = i18next.t(`currencies:cents${currency}`, {defaultValue: label});
+    isCalculationSummation(c) {
+        if (this._calculationSummations === undefined) {
+            if (this._reportData.rels?.calc) {
+                this._calculationSummations = new Set(Object.values(this._reportData.rels.calc).flatMap(calculations => {
+                    return Object.keys(calculations);
+                }));
+            } else {
+                this._calculationSummations = new Set();
+            }
+        }
+        return this._calculationSummations.has(c);
     }
-    if (label === "noName") {
-        return null;
+
+    /**
+     * @return {Array[String]} Software credit text labels provided with this report for display purposes.
+     */
+    softwareCredits() {
+        return this._reportData.softwareCredits ?? [];
     }
-    return label;
 }