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

iXBRLViewerPlugin/viewer/src/js/search.test.js

@@ -1,7 +1,9 @@
 // See COPYRIGHT.md for copyright information
 
 import { ReportSearch } from "./search.js"
-import {iXBRLReport} from "./report";
+import { ReportSet } from "./reportset.js";
+import { viewerUniqueId } from "./util.js";
+import { createSimpleFact, createNumericFact } from './test-utils.js';
 
 const testReportData = {
     "concepts": {},
@@ -13,6 +15,7 @@ const testReportData = {
     "rels": {},
 };
 
+
 function getReportSearch(report) {
     const reportSearch = new ReportSearch(report);
     const searchIndex = reportSearch.buildSearchIndex(() => {});
@@ -25,6 +28,7 @@ function createDimensionConcept(name, label, isExplicit= true) {
     c[name]["d"] = isExplicit ? "e": "t";
     return c;
 }
+
 function createSimpleConcept(name, label=null) {
     return {
         [name]: {
@@ -49,58 +53,63 @@ function createDimensionalizedFact(id, concept, options=null, dimensions= {}) {
     return fact;
 }
 
-function createSimpleFact(id, concept, options=null) {
-    options = options || {};
-    return {
-        [id]: {
-            "a": {
-                "c": concept,
-                "u": options["unit"],
-                "p": options["period"],
-            },
-            "d": options["decimals"],
-            "v": options["value"]
-        }
-    };
+// Returns a report set with a single report
+function testReport(testData, sourceIXData) {
+    return testReportSet([ {data: testData, ixData: sourceIXData ?? { } } ])
 }
 
-function createNumericFact(id, concept, unit, period, value) {
-    return createSimpleFact(id, concept, {
-        "unit": unit,
-        "period": period,
-        "value": value
-    });
+function mergeDicts(a, b) {
+    a ??= {};
+    b ??= {};
+    return { ...a, ...b };
 }
 
-function testReport(ixData, testData) {
-    // Deep copy of standing data
-    const data = {
-        ...JSON.parse(JSON.stringify(testReportData)),
-        ...testData
-    }
-    Object.keys(data['facts']).forEach(id => {
-        if (!(id in ixData)) {
-            ixData[id] = {};
+function testReportSet(reports) {
+    const targetReports = [];
+    const reportSetData = {
+        "sourceReports": [{ "targetReports": targetReports }],
+    };
+
+    const ixData = {};
+    for (const report of reports.values()) {
+        const targetReport = {};
+        for (const key of ["languages", "prefixes", "roles"]) {
+            reportSetData[key] = mergeDicts(reportSetData[key], report.data[key]);
+        }
+        for (const key of ["concepts", "facts", "roleDefs", "rels"]) {
+            targetReport[key] = report.data[key] ?? {};
         }
-    })
-    const report = new iXBRLReport(data);
-    report.setIXNodeMap(ixData);
-    return report;
+        targetReport["target"] = report.data["target"] ?? null;
+
+        for (const id of Object.keys(targetReport.facts)) {
+            if (!(id in ixData)) {
+                ixData[viewerUniqueId(0, id)] = report.ixData?.[id] ?? {};
+            }
+        } 
+        targetReports.push(targetReport);
+    }
+    const reportSet = new ReportSet(reportSetData);
+    for (const [id, data] of Object.entries(ixData)) {
+        ixData[id].isHidden ??= false;
+    }
+    reportSet.setIXNodeMap(ixData);
+    return reportSet;
 }
 
 function testSearchSpec(searchString='') {
     const spec = {};
     spec.searchString = searchString;
-    spec.showVisibleFacts = true;
-    spec.showHiddenFacts = true;
+    spec.visibilityFilter = '*';
     spec.namespacesFilter = [];
     spec.unitsFilter = [];
     spec.scalesFilter = [];
     spec.periodFilter = [];
     spec.conceptTypeFilter = '*';
+    spec.dataTypesFilter = [];
     spec.dimensionTypeFilter = [];
     spec.factValueFilter = '*';
     spec.calculationsFilter = [];
+    spec.targetDocumentFilter = [];
     return spec;
 }
 
@@ -108,7 +117,6 @@ describe("Search fact value filter", () => {
     const cashConcept = 'us-gaap:Cash';
     const cashUnit = 'iso4217:USD';
     const report = testReport(
-            {'positive': {}, 'negative': {}, 'zero': {}, 'text': {}, 'undefined': {}},
             {
                 'concepts': {
                     ...createSimpleConcept(cashConcept, 'Cash')
@@ -129,7 +137,7 @@ describe("Search fact value filter", () => {
         spec.factValueFilter = 'negative'
         const results = reportSearch.search(spec);
         expect(results.length).toEqual(1)
-        expect(results[0]["fact"]["id"]).toEqual("negative")
+        expect(results[0]["fact"].localId()).toEqual("negative")
     });
 
     test("Fact Value Negative filter works with other filter", () => {
@@ -138,7 +146,7 @@ describe("Search fact value filter", () => {
         spec.periodFilter = ['2018-01-01/2019-01-01']
         const results = reportSearch.search(spec);
         expect(results.length).toEqual(1)
-        expect(results[0]["fact"]["id"]).toEqual("negative")
+        expect(results[0]["fact"].localId()).toEqual("negative")
     });
 
     test("Fact Value Positive filter works", () => {
@@ -146,7 +154,7 @@ describe("Search fact value filter", () => {
         spec.factValueFilter = 'positive'
         const results = reportSearch.search(spec);
         expect(results.length).toEqual(1)
-        expect(results[0]["fact"]["id"]).toEqual("positive")
+        expect(results[0]["fact"].localId()).toEqual("positive")
     });
 
     test("Fact Value Positive filter works with other filter", () => {
@@ -155,13 +163,12 @@ describe("Search fact value filter", () => {
         spec.periodFilter = ['2018-01-01/2019-01-01']
         const results = reportSearch.search(spec);
         expect(results.length).toEqual(1)
-        expect(results[0]["fact"]["id"]).toEqual("positive")
+        expect(results[0]["fact"].localId()).toEqual("positive")
     });
 });
 
 describe("Search calculation filter", () => {
     const report = testReport(
-            {'summation': {}, 'item1': {}, 'item2': {}, 'other': {}},
             {
                 "concepts": {
                     ...createSimpleConcept("test:Summation", "Summation"),
@@ -192,32 +199,31 @@ describe("Search calculation filter", () => {
     test("Calculations 'all' filter works", () => {
         const spec = testSearchSpec();
         spec.calculationsFilter = [];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['item1', 'item2', 'other', 'summation']);
     });
 
     test("Calculations 'contributor' filter works", () => {
         const spec = testSearchSpec();
         spec.calculationsFilter = ['contributor'];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['item1', 'item2']);
     });
 
     test("Calculations 'summation' filter works", () => {
         const spec = testSearchSpec();
         spec.calculationsFilter = ['summation'];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['summation']);
     });
 
     test("Calculations 'summation' and 'contributor' filter works", () => {
         const spec = testSearchSpec();
         spec.calculationsFilter = ['summation', 'contributor'];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['item1', 'item2', 'summation']);
     });
     const emptyReport = testReport(
-            {'fact': {}},
             {
                 "concepts": {
                     ...createSimpleConcept("test:Concept", "Concept"),
@@ -232,14 +238,13 @@ describe("Search calculation filter", () => {
     test("Calculations filter works on empty report", () => {
         const spec = testSearchSpec();
         spec.calculationsFilter = ['summation', 'contributor'];
-        const results = emptyReportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = emptyReportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual([]);
     });
 });
 
 describe("Search namespaces filter", () => {
     const report = testReport(
-            {'itemA1': {}, 'itemA2': {}, 'itemB1': {}, 'itemC1': {}},
             {
                 "concepts": {
                     ...createSimpleConcept("a:ItemA1", "ItemA1"),
@@ -264,45 +269,44 @@ describe("Search namespaces filter", () => {
     const reportSearch = getReportSearch(report)
 
     test("Namespaces filter only shows used prefixes", () => {
-        const prefixes = Array.from(report.getUsedPrefixes()).sort();
+        const prefixes = Array.from(report.getUsedConceptPrefixes()).sort();
         expect(prefixes).toEqual(['a', 'b', 'c']);
     });
 
     test("Namespaces filter works without selection", () => {
         const spec = testSearchSpec();
         spec.namespacesFilter = [];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['itemA1', 'itemA2', 'itemB1', 'itemC1']);
     });
 
     test("Namespaces filter works with single selection", () => {
         const spec = testSearchSpec();
         spec.namespacesFilter = ['a'];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['itemA1', 'itemA2']);
     });
 
     test("Namespaces filter works with multiple selections", () => {
         const spec = testSearchSpec();
         spec.namespacesFilter = ['a', 'b'];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['itemA1', 'itemA2', 'itemB1']);
     });
 
     test("Namespaces filter works with all selections", () => {
         const spec1 = testSearchSpec();
-        spec1.namespacesFilter = Array.from(report.getUsedPrefixes());
-        const results1 = reportSearch.search(spec1).map(r => r.fact.id).sort();
+        spec1.namespacesFilter = Array.from(report.getUsedConceptPrefixes());
+        const results1 = reportSearch.search(spec1).map(r => r.fact.localId()).sort();
         const spec2 = testSearchSpec();
         spec2.namespacesFilter = [];
-        const results2 = reportSearch.search(spec2).map(r => r.fact.id).sort();
+        const results2 = reportSearch.search(spec2).map(r => r.fact.localId()).sort();
         expect(results1).toEqual(results2);
         expect(results1).toEqual(['itemA1', 'itemA2', 'itemB1', 'itemC1'])
     });
 });
 
 describe("Search units filter", () => {
-
     const cashUnit = 'test:USD';
     const shareUnit = 'test:share';
     const cashShareUnit = `${cashUnit} / ${shareUnit}`
@@ -314,7 +318,6 @@ describe("Search units filter", () => {
 
     beforeAll(() => {
         report = testReport(
-                {'itemA': {}, 'itemAB': {}, 'itemB': {}, 'itemBA': {}},
                 {
                     "concepts": {
                         ...createSimpleConcept("a:ItemA", "ItemA"),
@@ -343,31 +346,31 @@ describe("Search units filter", () => {
     test("Units filter works without selection", () => {
         const spec = testSearchSpec();
         spec.unitsFilter = [];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['itemA', 'itemAB', 'itemB', 'itemBA', 'other']);
     });
 
     test("Units filter works with single selection", () => {
         const spec = testSearchSpec();
         spec.unitsFilter = [cashShareUnit];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['itemAB']);
     });
 
     test("Units filter works with multiple selections", () => {
         const spec = testSearchSpec();
         spec.unitsFilter = [cashUnit, cashShareUnit];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['itemA', 'itemAB']);
     });
 
     test("Units filter with all selections matches numeric filter", () => {
         const spec1 = testSearchSpec();
         spec1.unitsFilter = Array.from(report.getUsedUnits());
-        const results1 = reportSearch.search(spec1).map(r => r.fact.id).sort();
+        const results1 = reportSearch.search(spec1).map(r => r.fact.localId()).sort();
         const spec2 = testSearchSpec()
         spec2.conceptTypeFilter = 'numeric';
-        const results2 = reportSearch.search(spec2).map(r => r.fact.id).sort();
+        const results2 = reportSearch.search(spec2).map(r => r.fact.localId()).sort();
         expect(results1).toEqual(results2);
         expect(results1).toEqual(['itemA', 'itemAB', 'itemB', 'itemBA'])
     });
@@ -375,7 +378,6 @@ describe("Search units filter", () => {
 
 describe("Search dimension type filter", () => {
     const report = testReport(
-            {},
             {
                 "concepts": {
                     ...createSimpleConcept("test:Concept", "Concept"),
@@ -403,33 +405,32 @@ describe("Search dimension type filter", () => {
     test("Dimension 'all' filter works", () => {
         const spec = testSearchSpec();
         spec.dimensionTypeFilter = [];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['explicit', 'explicit2', 'explicitAndTyped', 'explicitAndTyped2', 'simple', 'simple2', 'typed', 'typed2']);
     });
 
     test("Dimension 'explicit' filter works", () => {
         const spec = testSearchSpec();
         spec.dimensionTypeFilter = ['explicit'];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['explicit', 'explicit2', 'explicitAndTyped', 'explicitAndTyped2']);
     });
 
     test("Dimension 'typed' filter works", () => {
         const spec = testSearchSpec();
         spec.dimensionTypeFilter = ['typed'];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['explicitAndTyped', 'explicitAndTyped2', 'typed', 'typed2']);
     });
 
     test("Dimension 'explicit' and 'typed' filter works", () => {
         const spec = testSearchSpec();
         spec.dimensionTypeFilter = ['explicit', 'typed'];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['explicit', 'explicit2', 'explicitAndTyped', 'explicitAndTyped2', 'typed', 'typed2']);
     });
 
     const emptyReport = testReport(
-            {'fact': {}},
             {
                 "concepts": {
                     ...createSimpleConcept("test:Concept", "Concept"),
@@ -444,7 +445,7 @@ describe("Search dimension type filter", () => {
     test("Dimension filter works on empty report", () => {
         const spec = testSearchSpec();
         spec.dimensionTypeFilter = ['explicit'];
-        const results = emptyReportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = emptyReportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual([]);
     });
 });
@@ -453,18 +454,6 @@ describe("Search scales filter", () => {
     const cashUnit = 'test:USD';
     const period = '2018-01-01/2019-01-01';
     const report = testReport(
-            {
-                "item-3": { "scale": -3 },
-                "item-2": { "scale": -2 },
-                "item-1": { "scale": -1 },
-                "item0": { },
-                "item1": { "scale": 1 },
-                "item2": { "scale": 2 },
-                "item3": { "scale": 3 },
-                "item6": { "scale": 6 },
-                "item9": { "scale": 9 },
-                "item12": { "scale": 12 },
-            },
             {
                 "concepts": {
                     ...createSimpleConcept("a:Item-3"),
@@ -492,6 +481,18 @@ describe("Search scales filter", () => {
                     ...createNumericFact("item12", "a:Item12", cashUnit, period, 1000000000000),
                     ...createSimpleFact("itemOther", "a:Other"),
                 },
+            },
+            {
+                "item-3": { "scale": -3 },
+                "item-2": { "scale": -2 },
+                "item-1": { "scale": -1 },
+                "item0": { },
+                "item1": { "scale": 1 },
+                "item2": { "scale": 2 },
+                "item3": { "scale": 3 },
+                "item6": { "scale": 6 },
+                "item9": { "scale": 9 },
+                "item12": { "scale": 12 },
             }
     )
     const reportSearch = getReportSearch(report);
@@ -499,21 +500,120 @@ describe("Search scales filter", () => {
     test("Scales filter works without selection", () => {
         const spec = testSearchSpec();
         spec.scalesFilter = [];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['item-1', 'item-2', 'item-3', 'item0', 'item1', 'item12', 'item2', 'item3', 'item6', 'item9', 'itemOther']);
     });
 
     test("Scales filter works with single selection", () => {
         const spec = testSearchSpec();
         spec.scalesFilter = [-2];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['item-2']);
     });
 
     test("Scales filter works with multiple selections", () => {
         const spec = testSearchSpec();
         spec.scalesFilter = [-2, 2];
-        const results = reportSearch.search(spec).map(r => r.fact.id).sort();
+        const results = reportSearch.search(spec).map(r => r.fact.localId()).sort();
         expect(results).toEqual(['item-2', 'item2']);
     });
 });
+
+describe("Search target document filter", () => {
+    const cashUnit = 'test:USD';
+    const period = '2018-01-01/2019-01-01';
+    const singleReport = testReport(
+            {
+                "concepts": {
+                    ...createSimpleConcept("a:Item0"),
+                    ...createSimpleConcept("a:Item1"),
+                    ...createSimpleConcept("a:Item2"),
+                },
+                "facts": {
+                    ...createNumericFact("item0", "a:Item0", cashUnit, period, 1),
+                    ...createNumericFact("item1", "a:Item1", cashUnit, period, 10),
+                    ...createNumericFact("item2", "a:Item2", cashUnit, period, 100),
+                },
+            },
+    );
+    const singleReportSearch = getReportSearch(singleReport);
+
+    test("Target document filter works without selection", () => {
+        const spec = testSearchSpec();
+        spec.targetDocumentFilter = [];
+        const results = singleReportSearch.search(spec).map(r => r.fact.localId()).sort();
+        expect(results).toEqual(['item0', 'item1', 'item2' ]);
+    });
+
+    test("Target document filter with default document", () => {
+        const spec = testSearchSpec();
+        spec.targetDocumentFilter = [ ':default' ];
+        const results = singleReportSearch.search(spec).map(r => r.fact.localId()).sort();
+        expect(results).toEqual(['item0', 'item1', 'item2' ]);
+    });
+
+    const multiReport = testReportSet([ 
+        {
+            data: {
+                target: null,
+                "concepts": {
+                    ...createSimpleConcept("a:Item0"),
+                    ...createSimpleConcept("a:Item1"),
+                    ...createSimpleConcept("a:Item2"),
+                },
+                "facts": {
+                    ...createNumericFact("item0", "a:Item0", cashUnit, period, 1),
+                    ...createNumericFact("item1", "a:Item1", cashUnit, period, 10),
+                    ...createNumericFact("item2", "a:Item2", cashUnit, period, 100),
+                },
+            },
+        },
+        {
+            data: {
+                target: "ABC",
+                "concepts": {
+                    ...createSimpleConcept("a:Item3"),
+                    ...createSimpleConcept("a:Item4"),
+                    ...createSimpleConcept("a:Item5"),
+                },
+                "facts": {
+                    ...createNumericFact("item3", "a:Item3", cashUnit, period, 1),
+                    ...createNumericFact("item4", "a:Item4", cashUnit, period, 10),
+                    ...createNumericFact("item5", "a:Item5", cashUnit, period, 100),
+                },
+            },
+        }
+
+    ]);
+
+    const multiReportSearch = getReportSearch(multiReport);
+
+    test("Target document filter works without selection (multiple targets)", () => {
+        const spec = testSearchSpec();
+        spec.targetDocumentFilter = [];
+        const results = multiReportSearch.search(spec).map(r => r.fact.localId()).sort();
+        expect(results).toEqual(['item0', 'item1', 'item2', 'item3', 'item4', 'item5' ]);
+    });
+
+    test("Target document filter works with default (multiple targets)", () => {
+        const spec = testSearchSpec();
+        spec.targetDocumentFilter = [ ':default' ];
+        const results = multiReportSearch.search(spec).map(r => r.fact.localId()).sort();
+        expect(results).toEqual(['item0', 'item1', 'item2']);
+    });
+
+    test("Target document filter works with second target (multiple targets)", () => {
+        const spec = testSearchSpec();
+        spec.targetDocumentFilter = [ 'ABC' ];
+        const results = multiReportSearch.search(spec).map(r => r.fact.localId()).sort();
+        expect(results).toEqual(['item3', 'item4', 'item5']);
+    });
+
+    test("Target document filter works with multi-select (multiple targets)", () => {
+        const spec = testSearchSpec();
+        spec.targetDocumentFilter = [ ':default', 'ABC' ];
+        const results = multiReportSearch.search(spec).map(r => r.fact.localId()).sort();
+        expect(results).toEqual(['item0', 'item1', 'item2', 'item3', 'item4', 'item5' ]);
+    });
+
+});

iXBRLViewerPlugin/viewer/src/js/summary.js

@@ -68,8 +68,8 @@ class LocalDocuments {
 }
 
 export class DocumentSummary {
-    constructor(report) {
-        this._report = report;
+    constructor(reportSet) {
+        this._reportSet = reportSet;
     }
 
     _getTagCounter(tagCounts, element) {
@@ -86,21 +86,25 @@ export class DocumentSummary {
 
     _buildTagCounts() {
         const tagCounts = new Map();
-        for (const fact of this._report.facts()) {
+        for (const fact of this._reportSet.facts()) {
             let counter = this._getTagCounter(tagCounts, fact.conceptName());
             counter.addPrimaryItem(fact.conceptName());
             for (const [dimension, member] of Object.entries(fact.dimensions())) {
                 counter = this._getTagCounter(tagCounts, dimension);
                 counter.addDimension(dimension);
 
-                const dimensionConcept = this._report.getConcept(dimension);
-                if (dimensionConcept.isTypedDimension()) {
+                const dimensionConcept = fact.report.getConcept(dimension);
+                if (!dimensionConcept.hasDefinition) {
+                    console.log("Missing definition for dimension: " + dimension);
+                }
+                else if (dimensionConcept.isTypedDimension()) {
                     const typedDomainElement = dimensionConcept.typedDomainElement();
                     if (typedDomainElement) {
                         counter = this._getTagCounter(tagCounts, typedDomainElement);
                         counter.addMember(typedDomainElement);
                     }
-                } else {
+                } 
+                else {
                     counter = this._getTagCounter(tagCounts, member);
                     counter.addMember(member);
                 }
@@ -113,18 +117,32 @@ export class DocumentSummary {
 
     _buildLocalFileSummary() {
         this._localFileSummary = new LocalDocuments();
-        for (const [document, documentTypes] of Object.entries(this._report.localDocuments())) {
+        for (const [document, documentTypes] of this._reportSet.reports.flatMap(r => Object.entries(r.localDocuments()))) {
             this._localFileSummary.addDocument(document, documentTypes);
         }
     }
 
     totalFacts() {
         if (this._totalFacts === undefined) {
-            this._totalFacts = this._report.facts().length;
+            this._totalFacts = this._reportSet.facts().length;
         }
         return this._totalFacts;
     }
 
+    hiddenFacts() {
+        if (this._hiddenFacts === undefined) {
+            this._hiddenFacts = this._reportSet.facts().filter(f => f.isHidden()).length;
+        }
+        return this._hiddenFacts;
+    }
+
+    mandatoryFacts() {
+        if (this._mandatoryFacts === undefined) {
+            this._mandatoryFacts = this._reportSet.facts().filter(f => f.isMandatory()).length;
+        }
+        return this._mandatoryFacts;
+    }
+
     tagCounts() {
         if (this._tagCounts === undefined) {
             this._buildTagCounts();
@@ -138,4 +156,12 @@ export class DocumentSummary {
         }
         return this._localFileSummary.getDocuments()
     }
+
+
+    /**
+     * @return {Array[String]} Report set's list of software credit text values.
+     */
+    getSoftwareCredits() {
+        return this._reportSet.getSoftwareCredits();
+    }
 }