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

iXBRLViewerPlugin/viewer/src/js/report.test.js

@@ -1,7 +1,9 @@
 // See COPYRIGHT.md for copyright information
 
-import { iXBRLReport } from "./report.js";
+import { ReportSet } from "./reportset.js";
 import { ViewerOptions } from "./viewerOptions.js";
+import { TestInspector } from "./test-utils.js";
+import { NAMESPACE_ISO4217 } from "./util";
 
 var testReportData = {
     "languages": {
@@ -10,13 +12,17 @@ var testReportData = {
     },
     "prefixes": {
         "eg": "http://www.example.com",
-        "iso4217": "http://www.xbrl.org/2003/iso4217"
+        "iso4217": NAMESPACE_ISO4217
     },
     "roles": {
         "role1": "https://www.example.com/role1",
         "role2": "https://www.example.com/role2",
         "role3": "https://www.example.com/role3",
-        "role4": "https://www.example.com/role4"
+        "role4": "https://www.example.com/role4MoreWords",
+        "std": "http://www.xbrl.org/2003/role/label",
+        "doc": "http://www.xbrl.org/2003/role/documentation",
+        "verbose": "http://www.xbrl.org/2003/role/verboseLabel",
+        "total": "http://www.xbrl.org/2003/role/totalLabel",
     },
     "roleDefs": {
         "role1": { "en": "Role 1 Label" },
@@ -61,68 +67,78 @@ var testReportData = {
                 "p": "2018-01-01/2019-01-01",
             }
         }
-    }
+    },
+
+    "softwareCredits": ["Example credit text A", "Example credit text B"],
 };
 
+var insp = new TestInspector();
+beforeAll(() => {
+    return insp.i18nInit();
+});
 
 describe("Language options", () => {
-    var testReport = new iXBRLReport(testReportData);
-    testReport._initialize();
+    const testReportSet = new ReportSet(testReportData);
+    testReportSet._initialize();
     test("Available languages", () => {
-        var al = testReport.availableLanguages();
+        const al = testReportSet.availableLanguages();
         expect(al).toHaveLength(6);
         expect(al).toEqual(expect.arrayContaining(["en", "en-us", "en-gb", "fr", "de", "es"]));
     });
-
-    test("Names for available languages", () => {
-        var ln = testReport.languageNames();
-        expect(Object.keys(ln)).toHaveLength(2);
-        expect(ln['en']).toBe("English");
-        expect(ln['en-us']).toBe("English (US)");
-    });
 });
 
 describe("Fetching facts", () => {
-    var testReport = new iXBRLReport(testReportData);
-    testReport._initialize();
+    const testReportSet = new ReportSet(testReportData);
+    testReportSet._initialize();
 
     test("Successful", () => {
-        var f = testReport.getItemById("f1");
-        testReport._initialize();
+        const f = testReportSet.getItemById("0-f1");
         expect(f).not.toBeNull();
         expect(f.decimals()).toEqual(-3);
     });
 
     test("Non-existent fact", () => {
-        var f = testReport.getItemById("fact-does-not-exist");
+        const f = testReportSet.getItemById("fact-does-not-exist");
         expect(f).toBeUndefined();
     });
 });
 
 describe("Concept labels", () => {
-    var testReport = new iXBRLReport(testReportData);
-    var vo = new ViewerOptions();
-    testReport.setViewerOptions(vo);
+    const testReportSet = new ReportSet(testReportData);
+    testReportSet._initialize();
+    const testReport = testReportSet.reports[0];
+    const vo = new ViewerOptions();
+    testReportSet.viewerOptions = vo;
     test("Label fallback", () => {
         vo.language = 'fr';
         expect(testReport.getLabel('eg:Concept3', 'std')).toBe("Concept trois");
+        expect(testReport.getLabelAndLang('eg:Concept3', 'std').label).toBe("Concept trois");
+        expect(testReport.getLabelAndLang('eg:Concept3', 'std').lang).toBe("fr");
         expect(testReport.getLabelOrName('eg:Concept3', 'std')).toBe("Concept trois");
         vo.language = 'es';
         expect(testReport.getLabel('eg:Concept3', 'std')).toBe("Concept cuatro");
+        expect(testReport.getLabelAndLang('eg:Concept3', 'std').label).toBe("Concept cuatro");
+        expect(testReport.getLabelAndLang('eg:Concept3', 'std').lang).toBe("es");
         expect(testReport.getLabelOrName('eg:Concept3', 'std')).toBe("Concept cuatro");
         // No English label, so fall back on German (de is first alphabetically)
         vo.language = 'en';
         expect(testReport.getLabel('eg:Concept3', 'std')).toBe("Concept vier");
+        expect(testReport.getLabelAndLang('eg:Concept3', 'std').label).toBe("Concept vier");
+        expect(testReport.getLabelAndLang('eg:Concept3', 'std').lang).toBe("de");
         expect(testReport.getLabelOrName('eg:Concept3', 'std')).toBe("Concept vier");
 
         // Attempt to get an undefined label type 
         expect(testReport.getLabel('eg:Concept3', 'doc')).toBeUndefined();
+        expect(testReport.getLabelAndLang('eg:Concept3', 'doc').label).toBeUndefined();
+        expect(testReport.getLabelAndLang('eg:Concept3', 'doc').lang).toBeUndefined();
         expect(testReport.getLabelOrName('eg:Concept3', 'doc')).toBe('eg:Concept3');
     });
 
     test("With prefix", () => {
         vo.language = 'fr';
         expect(testReport.getLabel('eg:Concept3', 'std', true)).toBe("(eg) Concept trois");
+        expect(testReport.getLabelAndLang('eg:Concept3', 'std', true).label).toBe("(eg) Concept trois");
+        expect(testReport.getLabelAndLang('eg:Concept3', 'std', true).lang).toBe("fr");
         expect(testReport.getLabelOrName('eg:Concept3', 'std', true)).toBe("(eg) Concept trois");
 
         expect(testReport.getLabel('eg:Concept3', 'doc', true)).toBeUndefined();
@@ -132,18 +148,70 @@ describe("Concept labels", () => {
 });
 
 describe("ELR labels", () => {
-    const testReport = new iXBRLReport(testReportData);
+    const testReportSet = new ReportSet(testReportData);
+    testReportSet._initialize();
+    const testReport = testReportSet.reports[0];
     test("Present", () => {
-        expect(testReport.getRoleLabel("role1")).toBe("Role 1 Label");
+        expect(testReport.getRoleLabelOrURI("role1")).toBe("Role 1 Label");
     });
     test("Null", () => {
-        expect(testReport.getRoleLabel("role2")).toBe("https://www.example.com/role2");
+        expect(testReport.getRoleLabelOrURI("role2")).toBe("https://www.example.com/role2");
     });
     test("No label", () => {
-        expect(testReport.getRoleLabel("role3")).toBe("https://www.example.com/role3");
+        expect(testReport.getRoleLabelOrURI("role3")).toBe("https://www.example.com/role3");
     });
     test("Not present in roleDef", () => {
-        expect(testReport.getRoleLabel("role4")).toBe("https://www.example.com/role4");
+        expect(testReport.getRoleLabelOrURI("role4")).toBe("https://www.example.com/role4MoreWords");
     });
+});
 
+describe("Label role labels", () => {
+    const testReportSet = new ReportSet(testReportData);
+    testReportSet._initialize();
+    const testReport = testReportSet.reports[0];
+    test("Built-in (via i18n)", () => {
+        expect(testReport.getLabelRoleLabel("std")).toBe("Standard Label");
+    });
+    test("Built-in (via i18n)", () => {
+        expect(testReport.getLabelRoleLabel("doc")).toBe("Documentation Label");
+    });
+    test("Built-in (via de-camelcase)", () => {
+        expect(testReport.getLabelRoleLabel("verbose")).toBe("Verbose Label");
+    });
+    test("Present", () => {
+        expect(testReport.getLabelRoleLabel("role1")).toBe("Role 1 Label");
+    });
+    test("Null", () => {
+        expect(testReport.getLabelRoleLabel("role2")).toBe("Role2");
+    });
+    test("No label", () => {
+        expect(testReport.getLabelRoleLabel("role3")).toBe("Role3");
+    });
+    test("Not present in roleDef", () => {
+        expect(testReport.getLabelRoleLabel("role4")).toBe("Role4 More Words");
+    });
+
+});
+
+describe("Fetching software credit", () => {
+
+    test("Successful", () => {
+        const testReportSet = new ReportSet(testReportData);
+        testReportSet._initialize();
+        const report = testReportSet.reports[0];
+
+        const softwareCredits = report.softwareCredits();
+        expect(softwareCredits).toEqual(["Example credit text A", "Example credit text B"]);
+    });
+
+    test("Unset", () => {
+        let alternateData = JSON.parse(JSON.stringify(testReportData));
+        delete alternateData.softwareCredits;
+        const testReportSet = new ReportSet(alternateData);
+        testReportSet._initialize();
+        const report = testReportSet.reports[0];
+
+        const softwareCredits = report.softwareCredits();
+        expect(softwareCredits).toEqual([]);
+    });
 });

iXBRLViewerPlugin/viewer/src/js/reportset.js

@@ -0,0 +1,264 @@
+// See COPYRIGHT.md for copyright information
+
+import { XBRLReport } from './report.js';
+import { Fact } from "./fact.js"
+import { Footnote } from "./footnote.js"
+import { Unit } from "./unit";
+import { titleCase, viewerUniqueId } from "./util.js";
+import { QName } from "./qname.js";
+import { ViewerOptions } from './viewerOptions.js';
+import { TaxonomyNamer } from './taxonomynamer.js';
+
+// Class represents the set of XBRL "target" reports shown in the viewer.
+// Each contained report represents the data from a single target document in a
+// single iXBRL Document or iXBRL Document Set
+
+export class ReportSet {
+    constructor(data) {
+        this._data = data;
+        this._ixNodeMap = {};
+        this.viewerOptions = new ViewerOptions()
+        this.taxonomyNamer = new TaxonomyNamer(new Map());
+    }
+
+    /*
+     * Set additional information about facts obtained from parsing the iXBRL.
+     */
+    setIXNodeMap(ixData) {
+        this._ixNodeMap = ixData;
+        this._initialize();
+    }
+
+    _initialize() {
+        this._items = {};
+        this.reports = [];
+        // Build an array of footnotes IDs in document order so that we can assign
+        // numbers to foonotes
+        const fnorder = Object.keys(this._ixNodeMap).filter((id) => this._ixNodeMap[id].footnote);
+        fnorder.sort((a,b) => this._ixNodeMap[a].docOrderindex - this._ixNodeMap[b].docOrderindex);
+
+        // Create Fact objects for all facts.
+        for (const [reportIndex, sourceReport] of (this._data.sourceReports ?? [ { "targetReports": [ this._data ] } ]).entries()) {
+            for (const reportData of sourceReport.targetReports) {
+                const report = new XBRLReport(this, reportData);
+                this.reports.push(report);
+                for (const [id, factData] of Object.entries(reportData.facts)) {
+                    const vuid = viewerUniqueId(reportIndex, id);
+                    this._items[vuid] = new Fact(report, vuid, factData);
+                }
+
+                // 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, factData] of Object.entries(reportData.facts)) {
+                    const vuid = viewerUniqueId(reportIndex, id);
+                    const fact = this._items[vuid];
+                    const fns = factData.fn || [];
+                    fns.forEach((fnid) => {
+                        const fnvuid = viewerUniqueId(reportIndex, fnid);
+                        var fn = this._items[fnvuid];
+                        if (fn === undefined) {
+                            fn = new Footnote(fact.report, fnvuid, "Footnote " + (fnorder.indexOf(fnvuid) + 1));
+                            this._items[fnvuid] = fn;
+                        }
+                        // Associate fact with footnote
+                        fn.addLinkedFact(fact);
+                        fact.addFootnote(fn);
+                    });
+                }
+            }
+        }
+    }
+
+    availableLanguages() {
+        return Array.from(this.reports.reduce(
+            (langs, report) => new Set([...langs, ...report.availableLanguages()]), 
+            new Set()
+        ));
+    }
+
+    getItemById(vuid) {
+        return this._items[vuid];
+    }
+
+    getIXNodeForItemId(vuid) {
+        return this._ixNodeMap[vuid] || {};
+    }
+
+    facts() {
+        return Object.values(this._items).filter(i => i instanceof Fact);
+    }
+
+    filingDocuments() {
+        return this._data.filingDocuments;
+    }
+
+    prefixMap() {
+        return this._data.prefixes;
+    }
+
+    preferredPrefix(prefix) {
+        return this.taxonomyNamer.getName(prefix, this._data.prefixes[prefix]).prefix;
+    }
+
+    namespaceGroups() {
+        const counts = {};
+        for (const f of this.facts()) {
+            counts[f.conceptQName().prefix] = (counts[f.conceptQName().prefix] || 0) + 1;
+        }
+        const prefixes = Object.keys(counts);
+        prefixes.sort((a, b) => counts[b] - counts[a]);
+        return prefixes;
+    }
+
+    getUsedConceptPrefixes() {
+        if (this._usedPrefixes === undefined) {
+            this._usedPrefixes = new Set(Object.values(this._items)
+                    .filter(f => f instanceof Fact)
+                    .map(f => f.getConceptPrefix()));
+        }
+        return this._usedPrefixes;
+    }
+
+    getUsedConceptDataTypes() {
+        if (this._usedDataTypes === undefined) {
+            const map = new Map()
+            for (const dt of Object.values(this._items)
+                    .filter(f => f instanceof Fact)
+                    .map(f => ({ dataType: f.concept().dataType(), isNumeric: f.isNumeric() }))
+                    .filter(t => t.dataType !== undefined)) {
+                map.set(dt.dataType.name, dt);
+            }
+            this._usedDataTypes = map.values().toArray();
+        }
+        return this._usedDataTypes;
+    }
+
+    /**
+     * @return {Array[String]} Sorted list of unique software credit text values
+     */
+    getSoftwareCredits() {
+        let softwareCredits = new Set(this.reports.flatMap(r => r.softwareCredits()));
+        return Array.from(softwareCredits).sort();
+    }
+
+    getTargetDocuments() {
+        if (this._targetDocuments === undefined) {
+            this._targetDocuments = new Set(Object.values(this._items)
+                    .filter(f => f instanceof Fact)
+                    .map(f => f.targetDocument()));
+        }
+        return this._targetDocuments;
+    }
+
+    /**
+     * 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
+     */
+    getUsedUnits() {
+        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());
+        }
+        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
+     */
+    getUnit(unitKey) {
+        if (this._unitsMap === undefined) {
+            this._unitsMap = {};
+        }
+        if (this._unitsMap[unitKey] === undefined) {
+            this._unitsMap[unitKey] = new Unit(this, unitKey)
+        }
+        return this._unitsMap[unitKey];
+    }
+
+    getUsedScalesMap() {
+        // 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);
+                    }
+                }
+            });
+        return usedScalesMap;
+    }
+
+    roleMap() {
+        return this._data.roles;
+    }
+
+    qname(v) {
+        return new QName(this.prefixMap(), v);
+    }
+
+    reportsData() {
+        return this._data.sourceReports?.flatMap(sr => sr.targetReports) ?? [ this._data ];
+    }
+
+    /**
+     * Returns a flat list of source files for all reports in the report set.
+     * Each entry in the list is an object with:
+     *   file - name of the file
+     *   index - index of the report that it is for
+     * May return an empty list for single file, non-stub viewers.
+     * @return {List}   A list of objects describing each file
+     */
+    reportFiles() {
+        const sourceReports = this._data.sourceReports ?? [ this._data ];
+        return sourceReports.map((x, n) => (x.docSetFiles ?? []).map(file => ({ index: n, file: file }))).flat();
+    }
+
+    /**
+     * Returns true if the viewer is for more than one Inline XBRL document
+     * This may be a single document set with multiple files, or multiple
+     * document sets
+     * @return {Boolean}   true if the viewer covers more than one iXBRL
+     *                     document
+     */
+
+    isMultiDocumentViewer() {
+        return this.reportFiles().length > 1;
+    }
+
+    usesAnchoring() {
+        return this.reportsData().some(r => r.rels?.["w-n"] !== undefined);
+    }
+
+    usesCalculations() {
+        return this.reportsData().some(r => Object.keys(r.rels?.calc ?? {}).length > 0);
+    }
+
+    hasValidationErrors() {
+        return this._data.validation !== undefined && this._data.validation.length > 0;
+    }
+
+    validation() {
+        return this._data.validation;
+    }
+
+    factsForReport(report) {
+        return Object.values(this._items).filter(i => i instanceof Fact && i.report == report);
+    }
+
+}