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

iXBRLViewerPlugin/viewer/src/js/fact.test.js

@@ -1,13 +1,16 @@
 // See COPYRIGHT.md for copyright information
 
 import { Fact } from "./fact.js";
-import { iXBRLReport } from "./report.js";
+import { ReportSet } from "./reportset.js";
 import { TestInspector } from "./test-utils.js";
+import { NAMESPACE_ISO4217 } from "./util";
 
 var testReportData = {
     "prefixes": {
         "eg": "http://www.example.com",
-        "iso4217": "http://www.xbrl.org/2003/iso4217",
+        "aa": "http://www.example.com/aa",
+        "zz": "http://www.example.com/zz",
+        "iso4217": NAMESPACE_ISO4217,
         "e": "http://example.com/entity",
     },
     "concepts": {
@@ -32,6 +35,14 @@ var testReportData = {
                 }
             }
         },
+        "eg:TextBlockConcept1": {
+            "labels": {
+                "std": {
+                    "en": "Text block concept"
+                }
+            },
+            "t": true,
+        },
         "eg:EnumConcept": {
             "labels": {
                 "std": {
@@ -48,6 +59,30 @@ var testReportData = {
             },
             "d": "e"
         },
+        "eg:Dimension2": {
+            "labels": {
+                "std": {
+                    "en": "Dimension Two"
+                }
+            },
+            "d": "e"
+        },
+        "zz:Axis1": {
+            "labels": {
+                "std": {
+                    "en": "Axis One"
+                }
+            },
+            "d": "e"
+        },
+        "aa:Dimension3": {
+            "labels": {
+                "std": {
+                    "en": "Dimension Three"
+                }
+            },
+            "d": "e"
+        },
         "eg:Member1": {
             "labels": {
                 "std": {
@@ -62,6 +97,20 @@ var testReportData = {
                 }
             }
         },
+        "eg:Member3": {
+            "labels": {
+                "std": {
+                    "en": "Member Three"
+                }
+            }
+        },
+        "eg:Member4": {
+            "labels": {
+                "std": {
+                    "en": "Member Four"
+                }
+            }
+        },
         "eg:UnlabelledMember": {
             "labels": {
             }
@@ -75,16 +124,16 @@ function testReport(facts, ixData) {
     // Deep copy of standing data
     var data = JSON.parse(JSON.stringify(testReportData));
     data.facts = facts;
-    var report = new iXBRLReport(data);
-    report.setIXNodeMap(ixData);
-    return report;
+    var reportSet = new ReportSet(data);
+    reportSet.setIXNodeMap(ixData);
+    return reportSet.reports[0];
 }
 
 function testFact(factData, ixData) {
     factData.a = factData.a || {};
     factData.a.c = factData.a.c || 'eg:Concept1';
     ixData = ixData || {};
-    return new Fact(testReport({"f1": factData}, {"f1": ixData }), "f1");
+    return new Fact(testReport({"f1": factData}, {"f1": ixData }), "f1", factData);
 }
 
 var insp = new TestInspector();
@@ -108,7 +157,6 @@ describe("Simple fact properties", () => {
         expect(f.isMonetaryValue()).toBeTruthy();
         expect(f.readableValue()).toEqual("US $ 1,000");
         expect(f.unit().value()).toEqual("iso4217:USD");
-        expect(f.measure()).toEqual("iso4217:USD");
         expect(f.conceptQName().prefix).toEqual("eg");
         expect(f.conceptQName().localname).toEqual("Concept1");
         expect(f.conceptQName().namespace).toEqual("http://www.example.com");
@@ -128,9 +176,8 @@ describe("Simple fact properties", () => {
         expect(f.isNumeric()).toBeTruthy();
         expect(f.decimals()).toEqual(-3);
         expect(f.isMonetaryValue()).toBeFalsy();
-        expect(f.readableValue()).toEqual("1,000 eg:USD");
+        expect(f.readableValue()).toEqual("1,000 USD");
         expect(f.unit().value()).toEqual("eg:USD");
-        expect(f.measure()).toEqual("eg:USD");
         expect(f.conceptQName().prefix).toEqual("eg");
         expect(f.conceptQName().localname).toEqual("Concept1");
         expect(f.conceptQName().namespace).toEqual("http://www.example.com");
@@ -149,9 +196,8 @@ describe("Simple fact properties", () => {
         expect(f.decimals()).toBeUndefined();
         expect(f.isNumeric()).toBeTruthy();
         expect(f.isMonetaryValue()).toBeFalsy();
-        expect(f.readableValue()).toEqual("1,000,000.0125 eg:USD");
+        expect(f.readableValue()).toEqual("1,000,000.0125 USD");
         expect(f.unit().value()).toEqual("eg:USD");
-        expect(f.measure()).toEqual("eg:USD");
         expect(f.conceptQName().prefix).toEqual("eg");
         expect(f.conceptQName().localname).toEqual("Concept1");
         expect(f.conceptQName().namespace).toEqual("http://www.example.com");
@@ -539,7 +585,7 @@ describe("Readable value", () => {
     test("Other numeric", () => {
 
         expect(testFact({ "v": "10", d: -2, a: { u: "xbrli:foo" } }).readableValue())
-            .toBe("10 xbrli:foo");
+            .toBe("10 foo");
 
     });
 
@@ -552,20 +598,43 @@ describe("Readable value", () => {
 
     });
 
-    test("Strip HTML tags and normalise whitespace", () => {
+    test("Escaped string", () => {
 
         expect(testFact({ "v": "<b>foo</b>" }, {"escaped": true }).readableValue())
-            .toBe("foo");
+            .toBe("<b>foo</b>");
 
         expect(testFact({ "v": "    <b>foo</b>bar" }, {"escaped": true }).readableValue())
-            .toBe("foobar");
+            .toBe("    <b>foo</b>bar");
 
         expect(testFact({ "v": "\u00a0<b>foo</b>" }, {"escaped": true }).readableValue())
+            .toBe("\u00a0<b>foo</b>");
+
+    });
+
+    test("Strip HTML tags and normalise whitespace", () => {
+
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "<b>foo</b>" }, {"escaped": true }).readableValue())
+            .toBe("foo");
+
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "    <b>foo</b>bar" }, {"escaped": true }).readableValue())
+            .toBe("foobar");
+
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "\u00a0<b>foo</b>" }, {"escaped": true }).readableValue())
+            .toBe("foo");
+
+    });
+
+    test("Strip non-escaped text block facts", () => {
+
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "\u00a0<b>foo</b>" }, {"escaped": false }).readableValue())
+            .toBe("foo");
+
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "\u00a0<b>foo</b>" }, {  }).readableValue())
             .toBe("foo");
 
     });
 
-    test("Don't strip non-escaped facts", () => {
+    test("Don't strip non-text-block facts", () => {
 
         expect(testFact({ "v": "\u00a0<b>foo</b>" }, {"escaped": false }).readableValue())
             .toBe("\u00a0<b>foo</b>");
@@ -576,40 +645,40 @@ describe("Readable value", () => {
     });
 
     test("Detect and strip HTML tags - XHTML tags and attributes", () => {
-        expect(testFact({ "v": "<xhtml:b>foo</xhtml:b>" }, {"escaped": true }).readableValue())
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "<xhtml:b>foo</xhtml:b>" }, {"escaped": true }).readableValue())
             .toBe("foo");
 
-        expect(testFact({ "v": '<xhtml:span style="font-weight: bold">foo</xhtml:span>' }, {"escaped": true }).readableValue())
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": '<xhtml:span style="font-weight: bold">foo</xhtml:span>' }, {"escaped": true }).readableValue())
             .toBe("foo");
     });
 
     test("Detect and strip HTML tags - check behaviour with invalid HTML", () => {
         /* Invalid HTML  */
-        expect(testFact({ "v": "<b:b:b>foo</b:b:b>" }, {"escaped": true }).readableValue())
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "<b:b:b>foo</b:b:b>" }, {"escaped": true }).readableValue())
             .toBe("foo");
 
-        expect(testFact({ "v": "<foo<bar>baz</bar>" }, {"escaped": true }).readableValue())
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "<foo<bar>baz</bar>" }, {"escaped": true }).readableValue())
             .toBe("baz");
     });
 
     test("Text in consecutive inline elements should be contiguous", () => {
 
-        expect(testFact({ "v": "<b>foo</b><i>bar</i>" }, {"escaped":true }).readableValue())
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "<b>foo</b><i>bar</i>" }, {"escaped":true }).readableValue())
             .toBe("foobar");
 
     });
 
     test("Text in block/table elements should be separated.", () => {
 
-        expect(testFact({ "v": "<p>foo</p><p>bar</p>" }, {"escaped":true }).readableValue())
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "<p>foo</p><p>bar</p>" }, {"escaped":true }).readableValue())
             .toBe("foo bar");
 
         /* This should really return "foo bar", but we don't correctly detect
          * block tags in prefixed XHTML */
-        expect(testFact({ "v": '<xhtml:p xmlns:xhtml="https://www.w3.org/1999/xhtml/">foo</xhtml:p><xhtml:p>bar</xhtml:p>' }, {"escaped":true }).readableValue())
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": '<xhtml:p xmlns:xhtml="https://www.w3.org/1999/xhtml/">foo</xhtml:p><xhtml:p>bar</xhtml:p>' }, {"escaped":true }).readableValue())
             .toBe("foobar");
 
-        expect(testFact({ "v": "<table><tr><td>cell1</td><td>cell2</td></tr></table>" }, {"escaped":true })
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "<table><tr><td>cell1</td><td>cell2</td></tr></table>" }, {"escaped":true })
             .readableValue())
             .toBe("cell1 cell2");
 
@@ -617,7 +686,7 @@ describe("Readable value", () => {
 
     test("Whitespace normalisation", () => {
 
-        expect(testFact({ "v": "<p>bar  foo</p> <p>bar</p>" }, {"escaped":true }).readableValue())
+        expect(testFact({ "a": { "c": "eg:TextBlockConcept1" }, "v": "<p>bar  foo</p> <p>bar</p>" }, {"escaped":true }).readableValue())
             .toBe("bar foo bar");
 
     });
@@ -635,8 +704,7 @@ describe("Unit aspect handling", () => {
         expect(f.isNumeric()).toBeTruthy();
         expect(f.isMonetaryValue()).toBeFalsy();
         expect(f.unit()).toBeUndefined();
-        expect(f.measure()).toBeUndefined();
-        expect(f.measureLabel()).toBe("<NOUNIT>");
+        expect(f.unitLabel()).toBe("<NOUNIT>");
     });
 
     test("Non-numeric, no unit", () => {    
@@ -647,7 +715,6 @@ describe("Unit aspect handling", () => {
         });
         expect(f.isNumeric()).toBeFalsy();
         expect(f.unit()).toBeUndefined();
-        expect(f.measure()).toBeUndefined();
     });
 });
 
@@ -663,10 +730,13 @@ describe("Get Label", () => {
 
     test("Get standard label", () => {
         expect(f.getLabel("std")).toEqual("English label")
+        expect(f.getLabelAndLang("std").label).toEqual("English label")
+        expect(f.getLabelAndLang("std").lang).toEqual("en")
     });
 
     test("Get non-existent label", () => {
         expect(f.getLabel("doc")).toBeUndefined();
+        expect(f.getLabelAndLang("doc").label).toBeUndefined();
     });
 
 });
@@ -690,6 +760,68 @@ describe("Aspect methods", () => {
     });
 });
 
+describe("Aspect sorting", () => {
+    var f = testFact({
+            "d": -3,
+            "v": 1000,
+            "a": {
+                "c": "eg:Concept1",
+                "u": "iso4217:USD",
+                "p": "2018-01-01/2019-01-01",
+                "eg:Dimension2": "eg:Member1",
+                "aa:Dimension3": "eg:Member2",
+                "zz:Axis1":      "eg:Member3",
+                "eg:Dimension1": "eg:Member4"
+            }});
+    test("Fact.aspects() is sorted", () => {
+        expect(f.aspects().length).toEqual(7);
+        expect(f.aspects().filter(a => a.isTaxonomyDefined()).length).toEqual(4);
+
+        expect(f.aspects().filter(a => a.isTaxonomyDefined())[0].name()).toEqual("aa:Dimension3");
+        expect(f.aspects().filter(a => a.isTaxonomyDefined())[0].label()).toEqual("Dimension Three");
+        expect(f.aspects().filter(a => a.isTaxonomyDefined())[0].value()).toEqual("eg:Member2");
+        expect(f.aspects().filter(a => a.isTaxonomyDefined())[0].valueLabel()).toEqual("Member Two");
+
+        expect(f.aspects().filter(a => a.isTaxonomyDefined()).at(-1).label()).toEqual("Axis One");
+        expect(f.aspects().filter(a => a.isTaxonomyDefined()).at(-1).valueLabel()).toEqual("Member Three");
+
+        expect(f.aspects().filter(a => a.isTaxonomyDefined()).map(k => k.name())).toEqual(["aa:Dimension3", "eg:Dimension1", "eg:Dimension2", "zz:Axis1"]);
+        expect(f.aspects().filter(a => !a.isTaxonomyDefined()).map(k => k.name())).toEqual(["c", "p", "u"]);
+    });
+});
+
+describe("Aspect sorting consistent between facts", () => {
+    var fact1 = testFact({
+            "d": -3,
+            "v": 1000,
+            "a": {
+                "c": "eg:Concept1",
+                "u": "iso4217:USD",
+                "p": "2018-01-01/2019-01-01",
+                "eg:Dimension2": "eg:Member1",
+                "aa:Dimension3": "eg:Member2",
+                "zz:Axis1":      "eg:Member3",
+                "eg:Dimension1": "eg:Member4"
+            }});
+    var fact2 = testFact({
+            "d": -3,
+            "v": 1001,
+            "a": {
+                "c": "eg:Concept2",
+                "u": "iso4217:USD",
+                "p": "2018-01-01/2019-01-01",
+                "zz:Axis1":      "eg:Member1",
+                "eg:Dimension2": "eg:Member2",
+                "aa:Dimension3": "eg:Member3",
+                "eg:Dimension1": "eg:Member4"
+            }});
+    test("fact1 dims are sorted as expected and in exactly the same order as fact2 dims", () => {
+        expect(fact1.aspects().filter(a => a.isTaxonomyDefined()).map(k => k.name())).toEqual(["aa:Dimension3", "eg:Dimension1", "eg:Dimension2", "zz:Axis1"]);
+        expect(fact1.aspects().filter(a => a.isTaxonomyDefined()).map(k => k.name())).toEqual(fact2.aspects().filter(a => a.isTaxonomyDefined()).map(k => k.name()));
+    });
+});
+
+
 describe("Fact errors", () => {
     test("iXBRL Invalid", () => {
         var f = testFact({
@@ -707,7 +839,6 @@ describe("Fact errors", () => {
         expect(f.isMonetaryValue()).toBeTruthy();
         expect(f.readableValue()).toEqual("Invalid value");
         expect(f.unit().value()).toEqual("iso4217:USD");
-        expect(f.measure()).toEqual("iso4217:USD");
         expect(f.conceptQName().prefix).toEqual("eg");
         expect(f.conceptQName().localname).toEqual("Concept1");
         expect(f.conceptQName().namespace).toEqual("http://www.example.com");

iXBRLViewerPlugin/viewer/src/js/factset.js

@@ -2,18 +2,31 @@
 
 import { Fact } from "./fact.js";
 import { Footnote } from "./footnote.js";
+import { Interval } from './interval.js';
 
 export class FactSet {
-    constructor(items) {
-        this._items = items;
+
+    constructor (items) {
+        this.itemMap = new Map();
+        for (const item of items ?? []) {
+            this.add(item)
+        }
+    }
+
+    add(item) {
+        this.itemMap.set(item.vuid, item);
+    }
+
+    items() {
+        return Array.from(this.itemMap.values());
     }
 
     /* Returns the union of dimensions present on facts in the set */
     _allDimensions() {
-        var dims = {};
-        var facts = this._items.filter((item) => item instanceof Fact);
-        for (var i = 0; i < facts.length; i++) {
-            var dd = Object.keys(facts[i].dimensions());
+        const dims = {};
+        const facts = this.items().filter((item) => item instanceof Fact);
+        for (const fact of facts) {
+            const dd = Object.keys(fact.dimensions());
             for (var j = 0; j < dd.length; j++) {
                 dims[dd[j]] = true;
             }
@@ -30,17 +43,17 @@ export class FactSet {
      */
     minimallyUniqueLabel(fact) {
         if (!this._minimallyUniqueLabels) {
-            var facts = this._items.filter((item) => item instanceof Fact);
+            var facts = this.items().filter((item) => item instanceof Fact);
             var allLabels = {};
             var allAspects = ["c", "p"].concat(this._allDimensions());
             /* Assemble a map of arrays of all aspect labels for all facts, in a
              * consistent order */
             for (var i = 0; i < facts.length; i++) {
                 var f = facts[i];
-                allLabels[f.id] = [];
+                allLabels[f.vuid] = [];
                 for (var j = 0; j < allAspects.length; j++) {
                     var dd = f.aspect(allAspects[j]);
-                    allLabels[f.id].push(dd ? dd.valueLabel() : null);
+                    allLabels[f.vuid].push(dd ? dd.valueLabel() : null);
                 }
             }
             /* Iterate each aspect label and compare that label across all facts in
@@ -49,7 +62,7 @@ export class FactSet {
             for (var j = 0; j < allAspects.length; j++) {
                 var labelMap = {};
                 for (var i = 0; i < facts.length; i++) {
-                    labelMap[allLabels[facts[i].id][j]] = true;
+                    labelMap[allLabels[facts[i].vuid][j]] = true;
                 }
 
                 var uniqueLabelsByLabel = {};
@@ -57,7 +70,7 @@ export class FactSet {
                     /* We have at least two different labels, so include this
                      * aspect in the label for all facts in the set */
                     for (var i = 0; i < facts.length; i++) {
-                        var fid = facts[i].id;
+                        var fid = facts[i].vuid;
                         var l = allLabels[fid][j];
                         var ul = uniqueLabels[fid] || [];
                         if (l !== null) {
@@ -79,19 +92,55 @@ export class FactSet {
              * of them */
             if (Object.keys(uniqueLabels).length < facts.length) {
                 for (var i = 0; i < facts.length; i++) {
-                    var fid = facts[i].id;
+                    var fid = facts[i].vuid;
                     var ul = uniqueLabels[fid] || [];
                     ul.unshift(allLabels[fid][0]);
                     uniqueLabels[fid] = ul;
                 }
             }
 
-            this._items.filter((item) => item instanceof Footnote).forEach((fn) => {
-                uniqueLabels[fn.id] = [fn.title];
+            this.items().filter((item) => item instanceof Footnote).forEach((fn) => {
+                uniqueLabels[fn.vuid] = [fn.title];
             });
 
             this._minimallyUniqueLabels = uniqueLabels;
         }
-        return this._minimallyUniqueLabels[fact.id].join(", ");
+        return this._minimallyUniqueLabels[fact.vuid].join(", ");
+    }
+
+    isEmpty() {
+        return this.itemMap.size == 0;
+    }
+
+    /*
+     * Returns an Interval for the intersection of all values in the set, or
+     * undefined if there is no intersection (inconsistent duplicates)
+     */
+    valueIntersection() {
+        const duplicates = this.items().map(fact => Interval.fromFact(fact));
+        return Interval.intersection(...duplicates);
+    }
+
+    completeDuplicates() {
+        return this.items().every(f => f.isCompleteDuplicate(this.items()[0]));
+    }
+
+    isConsistent() {
+        if (this.itemMap.size == 0) {
+            return true;
+        }
+        const duplicates = this.items().map(fact => Interval.fromFact(fact));
+        return Interval.intersection(...duplicates) !== undefined;
+    }
+
+    size() {
+        return this.itemMap.size;
+    }
+
+    /*
+     * Return the most precise (highest decimals) value within the set.
+     */
+    mostPrecise() {
+        return this.items().reduce((a, b) => b.isMorePrecise(a) ? b : a);
     }
 }