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

iXBRLViewerPlugin/viewer/src/js/inspector.test.js

@@ -1,14 +1,14 @@
 // 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, SHOW_FACT, viewerUniqueId } from "./util.js";
 
 
-var testReportData = {
+const testReportData = {
     "prefixes": {
         "eg": "http://www.example.com",
-        "iso4217": "http://www.xbrl.org/2003/iso4217",
+        "iso4217": NAMESPACE_ISO4217,
         "e": "http://example.com/entity",
     },
     "concepts": {
@@ -39,42 +39,42 @@ var testReportData = {
     "roles": {},
     "roleDefs": {},
     "rels": {},
-    "units": {},
 };
 
 function testReport(facts, ixData) {
     // Deep copy of standing data
-    var data = JSON.parse(JSON.stringify(testReportData));
+    const data = JSON.parse(JSON.stringify(testReportData));
     data.facts = facts;
-    var report = new iXBRLReport(data);
-    report.setIXNodeMap(ixData);
-    return report;
+    const reportSet = new ReportSet(data);
+    reportSet.setIXNodeMap(ixData);
+    return reportSet;
 }
 
 function fromFact(value) {
-    var factData = {
+    const factData = {
                 "v": value,
                 "a": {
                     "c": "eg:Concept1",
                     "u": "iso4217:USD", 
                     "p": "2017-01-01/2018-01-01",
                 }};
-    return new Fact(testReport({"f1": factData}, {"f1": {} }), "f1");
+    return testReport({"f1": factData}, {"f1": {} }).getItemById("0-f1");
 }
 
 function toFact(value) {
-    var factData = {
+    const factData = {
                 "v": value,
                 "a": {
                     "c": "eg:Concept1",
                     "u": "iso4217:USD", 
                     "p": "2018-01-01/2019-01-01",
                 }};
-    return new Fact(testReport({"f1": factData}, {"f1": {} }), "f1");
+    
+    return testReport({"f1": factData}, {"f1": {} }).getItemById("0-f1");
 }
 
 describe("Describe changes", () => {
-    var insp = new TestInspector();
+    const insp = new TestInspector();
     beforeAll(() => {
         return insp.i18nInit();
     });
@@ -117,7 +117,7 @@ describe("Scales filter options", () => {
         if (scale !== 0) {
             ixNode["scale"] = scale;
         }
-        ixData[id] = ixNode;
+        ixData[viewerUniqueId(0, id)] = ixNode;
     }
     const nonMonetaryFactData = {};
     for (let scale = -4; scale < 11; scale++) {
@@ -127,16 +127,16 @@ describe("Scales filter options", () => {
         if (scale !== 0) {
             ixNode["scale"] = scale;
         }
-        ixData[id] = ixNode;
+        ixData[viewerUniqueId(0, id)] = ixNode;
     }
 
     test("Scales filter options with monetary and non-monetary facts", () => {
-        var insp = new TestInspector();
-        const report = testReport({
+        const insp = new TestInspector();
+        const reportSet = testReport({
             ...monetaryFactData,
             ...nonMonetaryFactData,
         }, ixData);
-        insp.initialize(report)
+        insp.initialize(reportSet)
         insp.i18nInit();
         const scalesOptions = insp._getScalesOptions();
         expect(scalesOptions).toEqual({
@@ -158,11 +158,11 @@ describe("Scales filter options", () => {
     })
 
     test("Scales filter options with only monetary facts", () => {
-        var insp = new TestInspector();
-        const report = testReport({
+        const insp = new TestInspector();
+        const reportSet = testReport({
             ...monetaryFactData,
         }, ixData);
-        insp.initialize(report)
+        insp.initialize(reportSet)
         insp.i18nInit();
         const scalesOptions = insp._getScalesOptions();
         expect(scalesOptions).toEqual({
@@ -184,11 +184,11 @@ describe("Scales filter options", () => {
     })
 
     test("Scales filter options with only non-monetary facts", () => {
-        var insp = new TestInspector();
-        const report = testReport({
+        const insp = new TestInspector();
+        const reportSet = testReport({
             ...nonMonetaryFactData,
         }, ixData);
-        insp.initialize(report)
+        insp.initialize(reportSet)
         insp.i18nInit();
         const scalesOptions = insp._getScalesOptions();
         expect(scalesOptions).toEqual({
@@ -209,3 +209,121 @@ describe("Scales filter options", () => {
         });
     })
 });
+
+describe("Fact deep link", () => {
+    const insp = new TestInspector();
+    insp._reportSet = {
+        getItemById: jest.fn(id => ["0-123", "1-abc"].includes(id) ? true : undefined),
+    };
+    const mockSelect = jest.fn(id => true);
+    insp.selectItem = mockSelect;
+    test("Old style fact deep link", () => {
+        mockSelect.mockClear();
+        location.hash = "#f-123";
+        insp.handleFactDeepLink();
+        expect(mockSelect).toHaveBeenCalledWith("0-123");
+    })
+    test("Old style fact deep link (non-existent)", () => {
+        mockSelect.mockClear();
+        location.hash = "#f-1234";
+        insp.handleFactDeepLink();
+        expect(mockSelect).not.toHaveBeenCalled();
+    })
+    test("New style fact deep link", () => {
+        mockSelect.mockClear();
+        location.hash = "#f0-123";
+        insp.handleFactDeepLink();
+        expect(mockSelect).toHaveBeenCalledWith("0-123");
+    })
+    test("New style fact deep link", () => {
+        mockSelect.mockClear();
+        location.hash = "#f1-abc";
+        insp.handleFactDeepLink();
+        expect(mockSelect).toHaveBeenCalledWith("1-abc");
+    })
+    test("New style fact deep link (non-existent)", () => {
+        mockSelect.mockClear();
+        location.hash = "#f0-1234";
+        insp.handleFactDeepLink();
+        expect(mockSelect).not.toHaveBeenCalled();
+    })
+});
+
+describe("Handle message", () => {
+    const generateEvent = (data) => {
+        return {
+            originalEvent: {
+                data: JSON.stringify(data)
+            }
+        };
+    }
+    const insp = new TestInspector();
+    insp._reportSet = {
+        getItemById: jest.fn(id => ["0-123", "1-abc"].includes(id) ? true : undefined),
+    };
+    const mockSelect = jest.fn(id => true);
+    insp.selectItem = mockSelect;
+    it.each([
+        ["0", "0-123"],
+        [0, "0-123"],
+        [undefined, "0-123"],
+        ["1", "1-123"],
+        [1, "1-123"],
+        ["X", "0-123"],
+    ])("SHOW_FACT task with valid factID and %p docSetId selects VUID %p", (docSetId, result) => {
+        mockSelect.mockClear();
+        const data = {
+            task: SHOW_FACT,
+            factId: "123",
+        }
+        if (docSetId !== undefined) {
+            data["docSetId"] = docSetId
+        }
+        const event = generateEvent({
+            task: SHOW_FACT,
+            factId: "123",
+            docSetId: docSetId
+        });
+        insp.handleMessage(event);
+        expect(mockSelect).toHaveBeenCalledWith(result);
+    });
+    test("SHOW_FACT with no factId", () => {
+        mockSelect.mockClear();
+        const event = generateEvent({
+            task: SHOW_FACT,
+            docSetId: "0",
+        });
+        insp.handleMessage(event);
+        expect(mockSelect).toHaveBeenCalledWith(null);
+    })
+    test("SHOW_FACT with empty factId", () => {
+        mockSelect.mockClear();
+        const event = generateEvent({
+            task: SHOW_FACT,
+            factId: "",
+        });
+        insp.handleMessage(event);
+        expect(mockSelect).toHaveBeenCalledWith("0-");
+    })
+    test("Invalid task", () => {
+        mockSelect.mockClear();
+        const event = generateEvent({
+            task: "INVALID_TASK",
+        });
+        insp.handleMessage(event);
+        expect(mockSelect).not.toHaveBeenCalled();
+    })
+    test("Invalid JSON", () => {
+        mockSelect.mockClear();
+        const event = {
+            originalEvent: {
+                data: `{
+                    task: "SHOW_TASK"
+                    factId: "f1-abc"
+                }`
+            }
+        };
+        insp.handleMessage(event);
+        expect(mockSelect).not.toHaveBeenCalled();
+    })
+});

iXBRLViewerPlugin/viewer/src/js/interval.js

@@ -0,0 +1,70 @@
+// See COPYRIGHT.md for copyright information
+
+import Decimal from 'decimal.js';
+
+/*
+ * Class for working with numeric intervals, of the form: [a, b]
+ *
+ * Interval is closed (includes both bounds)
+ * a must be <= b
+ */
+export class Interval {
+
+    constructor(a, b) {
+        this.a = typeof a == 'object' ? a : new Decimal(a);
+        this.b = typeof b == 'object' ? b : new Decimal(b);
+    }
+
+    static fromFact(fact) {
+        if (!fact.isNumeric()) {
+            return undefined;
+        }
+        const decimals = fact.decimals();
+        let width = 0;
+        if (decimals !== undefined) {
+            const x = new Decimal(10);
+            width = x.pow(0-decimals).times(0.5);
+        }
+        let value;
+        const factValue = fact.value();
+        try {
+            value = new Decimal(factValue);
+        } catch (e) {
+            if (e instanceof Error && /DecimalError/.test(e.message)) {
+                return undefined;
+            }
+            throw e;
+        }
+        return new Interval(value.minus(width), value.plus(width));
+    }
+
+    intersection(other) {
+        return Interval.intersection(this, other);
+    }
+
+    static intersection(...intervals) {
+        if (intervals.includes(undefined) || intervals.length == 0) {
+            return undefined;
+        }
+        const aa = intervals.map(x => x.a);
+        const bb = intervals.map(x => x.b);
+        const a = Decimal.max(...aa);
+        const b = Decimal.min(...bb);
+        if (b.lessThan(a)) {
+            return undefined;
+        }
+        return new Interval(a, b);
+    }
+
+    plus(other) {
+        return new Interval(this.a.plus(other.a), this.b.plus(other.b));
+    }
+
+    times(x) {
+        return x > 0 ? new Interval(this.a.times(x), this.b.times(x)) : new Interval(this.b.times(x), this.a.times(x));
+    }
+
+    midpoint() {
+        return Decimal.add(this.a, this.b).div(2);
+    }
+}

iXBRLViewerPlugin/viewer/src/js/interval.test.js

@@ -0,0 +1,153 @@
+// Copyright 2019 Workiva Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { Fact } from "./fact.js";
+import { Interval } from "./interval.js";
+import { ReportSet } from "./reportset.js";
+import Decimal from 'decimal.js';
+import { viewerUniqueId } from "./util.js";
+import './test-utils.js';
+
+function testReportSet(facts) {
+    const reportset = new ReportSet({
+            prefixes: {},
+            concepts: {},
+            facts: facts
+        });
+    reportset._initialize();
+    return reportset;
+}
+
+function testFact(factData) {
+    factData.a = factData.a || {};
+    factData.a.c = factData.a.c || 'eg:Concept1';
+    if (!('u' in factData.a)) {
+        factData.a.u = 'eg:pure';
+    }
+    else if (factData.a.u === undefined) {
+        delete factData.a.u;
+    }
+    return testReportSet({"f1": factData}).getItemById(viewerUniqueId(0, "f1"));
+}
+
+describe("From facts", () => {
+    test("Infinite precision", () => {
+        var i = Interval.fromFact(testFact({v: 20}));
+        expect(i.a).toEqualDecimal(20);
+        expect(i.b).toEqualDecimal(20);
+
+        i = Interval.fromFact(testFact({v: -20}));
+        expect(i.a).toEqualDecimal(-20);
+        expect(i.b).toEqualDecimal(-20);
+    });
+
+    test("Finite precision", () => {
+        var i = Interval.fromFact(testFact({v: 20, d: 0}));
+        expect(i.a).toEqualDecimal(19.5);
+        expect(i.b).toEqualDecimal(20.5);
+
+        i = Interval.fromFact(testFact({v: -20.123, d: 3}));
+        expect(i.a).toEqualDecimal(-20.1235);
+        expect(i.b).toEqualDecimal(-20.1225);
+
+        i = Interval.fromFact(testFact({v: -20.123, d: -1}));
+        expect(i.a).toEqualDecimal(-25.123);
+        expect(i.b).toEqualDecimal(-15.123);
+    });
+
+    test("Non numeric", () => {
+        var i = Interval.fromFact(testFact({v: 20, a: {u: undefined}}));
+        expect(i).toBeUndefined();
+
+        // This would be invalid XBRL
+        i = Interval.fromFact(testFact({v: "abc" }));
+        expect(i).toBeUndefined();
+    });
+});
+
+
+describe("Intersect", () => {
+    test("Intersecting", () => {
+        var x = new Interval(5, 15);
+        var y = new Interval(10, 25);
+        var ii = x.intersection(y);
+        expect(ii.a).toEqualDecimal(10);
+        expect(ii.b).toEqualDecimal(15);
+
+        ii = Interval.intersection(x, y);
+        expect(ii.a).toEqualDecimal(10);
+        expect(ii.b).toEqualDecimal(15);
+
+        ii = y.intersection(x);
+        expect(ii.a).toEqualDecimal(10);
+        expect(ii.b).toEqualDecimal(15);
+
+        y = new Interval(15, 25);
+        ii = x.intersection(y);
+        expect(ii.a).toEqualDecimal(15);
+        expect(ii.b).toEqualDecimal(15);
+
+        x = new Interval(10, 20);
+        y = new Interval(15, 25);
+        var z = new Interval(18, 30);
+        ii = Interval.intersection(x, y, z);
+        expect(ii.a).toEqualDecimal(18);
+        expect(ii.b).toEqualDecimal(20);
+
+    });
+
+    test("No intersection", () => {
+        var x = new Interval(5, 15);
+        expect(x.intersection(new Interval(20, 25))).toBeUndefined();
+        expect(x.intersection(new Interval(1, 4.99))).toBeUndefined();
+
+        x = new Interval(10, 20);
+        var y = new Interval(15, 25);
+        var z = new Interval(21, 30);
+        expect(Interval.intersection(x, y, z)).toBeUndefined();
+    });
+})
+
+describe("Arithmetic", () => {
+    test("Add", () => {
+        var i = new Interval(5, 15);
+        var ii = i.plus(new Interval(10, 20));
+        expect(ii.a).toEqualDecimal(15);
+        expect(ii.b).toEqualDecimal(35);
+    });
+
+    test("Multiply", () => {
+        var i = new Interval(5, 15);
+        var ii = i.times(2);
+        expect(ii.a).toEqualDecimal(10);
+        expect(ii.b).toEqualDecimal(30);
+
+        ii = i.times(-2);
+        expect(ii.a).toEqualDecimal(-30);
+        expect(ii.b).toEqualDecimal(-10);
+
+        i = new Interval(-10, -5);
+        ii = i.times(2);
+        expect(ii.a).toEqualDecimal(-20);
+        expect(ii.b).toEqualDecimal(-10);
+
+        ii = i.times(-2);
+        expect(ii.a).toEqualDecimal(10);
+        expect(ii.b).toEqualDecimal(20);
+
+    });
+
+});
+
+