ixbrl-viewer 1.4.39__py3-none-any.whl → 1.4.41__py3-none-any.whl

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

@@ -159,7 +159,7 @@ describe("Scales filter options", () => {
     })
 
     test("Scales filter options with only monetary facts", () => {
-        var insp = new TestInspector();
+        const insp = new TestInspector();
         const reportSet = testReport({
             ...monetaryFactData,
         }, ixData);

iXBRLViewerPlugin/viewer/src/js/ixbrlviewer.js

@@ -5,11 +5,17 @@ import $ from 'jquery'
 import { ReportSet } from "./reportset.js";
 import { Viewer, DocumentTooLargeError } from "./viewer.js";
 import { Inspector } from "./inspector.js";
+import { initializeTheme } from './theme.js';
+import { TaxonomyNamer } from './taxonomynamer.js';
+import {FEATURE_GUIDE_LINK, FEATURE_REVIEW, FEATURE_SUPPORT_LINK, FEATURE_SURVEY_LINK} from "./util";
+
+const featureFalsyValues = new Set([undefined, null, '', 'false', false]);
 
 export class iXBRLViewer {
 
     constructor(options) {
-        this._features = new Set();
+        this._staticFeatures = {};
+        this._dynamicFeatures = {};
         this._plugins = [];
         this.inspector = new Inspector(this);
         this.viewer = null;
@@ -76,40 +82,68 @@ export class iXBRLViewer {
         });
     }
 
-    setFeatures(featureNames, queryString) {
-        const featureMap = {}
-        // Enable given features initially
-        featureNames.forEach(f => {
-            featureMap[f] = true;
-        });
+    setFeatures(features, queryString) {
+        this._staticFeatures = {}
+        for (const [key, value] of Object.entries(features)) {
+            this._staticFeatures[key] = value;
+        }
 
-        // Enable/disable features based on query string
         const urlParams = new URLSearchParams(queryString);
+        this._dynamicFeatures = {}
         urlParams.forEach((value, key) => {
-            // Do nothing if feature has already been disabled by query
-            if (featureMap[key] !== false) {
-                // Disable feature if value is exactly 'false', anything else enables the feature
-                featureMap[key] = value !== 'false';
+            if (value === '') {
+                if (this._dynamicFeatures[key] === undefined) {
+                    value = 'true'
+                } else {
+                    return;
+                }
             }
+            this._dynamicFeatures[key] = value;
         });
+    }
 
-        // Gather results in _features set
-        if (this._features.size > 0) {
-            this._features = new Set();
-        }
-        for (const [feature, enabled] of Object.entries(featureMap)) {
-            if (enabled) {
-                this._features.add(feature);
-            }
+    getStaticFeatureValue(featureName) {
+        return this._staticFeatures[featureName];
+    }
+
+    getFeatureValue(featureName) {
+        if (this._dynamicFeatures[featureName]) {
+            return this._dynamicFeatures[featureName];
         }
+        return this.getStaticFeatureValue(featureName);
     }
 
     isFeatureEnabled(featureName) {
-        return this._features.has(featureName);
+        return !featureFalsyValues.has(this.getFeatureValue(featureName));
+    }
+
+    isStaticFeatureEnabled(featureName) {
+        return !featureFalsyValues.has(this.getStaticFeatureValue(featureName));
     }
 
     isReviewModeEnabled() {
-        return this.isFeatureEnabled('review');
+        return this.isFeatureEnabled(FEATURE_REVIEW);
+    }
+
+    getGuideLinkUrl() {
+        if (!this.isStaticFeatureEnabled(FEATURE_GUIDE_LINK)) {
+            return null;
+        }
+        return this.resolveRelativeUrl(this.getStaticFeatureValue(FEATURE_GUIDE_LINK));
+    }
+
+    getSupportLinkUrl() {
+        if (!this.isStaticFeatureEnabled(FEATURE_SUPPORT_LINK)) {
+            return null;
+        }
+        return this.resolveRelativeUrl(this.getStaticFeatureValue(FEATURE_SUPPORT_LINK));
+    }
+
+    getSurveyLinkUrl() {
+        if (!this.isStaticFeatureEnabled(FEATURE_SURVEY_LINK)) {
+            return null;
+        }
+        return this.resolveRelativeUrl(this.getStaticFeatureValue(FEATURE_SURVEY_LINK));
     }
 
     isViewerEnabled() {
@@ -117,16 +151,34 @@ export class iXBRLViewer {
         return (urlParams.get('disable-viewer') ?? 'false') === 'false';
     }
 
+    // Resolves URL relative to the config file
+    resolveRelativeUrl(url) {
+        if (this.options.configUrl === undefined) {
+            return url;
+        }
+        const resolvedUrl = new URL(url, this.options.configUrl.href);
+        return resolvedUrl.href;
+    }
+
     _loadInspectorHTML() {
         /* Insert HTML and CSS styles into body */
-        $(require('../html/inspector.html')).prependTo('body');
+        const footerLogoHtml = this.runtimeConfig.skin?.footerLogoHtml ?? require("../html/footer-logo.html");
+        $(require('../html/inspector.html'))
+            .prependTo('body')
+            .find("#footer-logo").html(footerLogoHtml);
         const inspector_css = require('../less/inspector.less').toString(); 
         $('<style id="ixv-style"></style>')
             .prop("type", "text/css")
             .text(inspector_css)
             .appendTo('head');
+        if (this.runtimeConfig.skin?.stylesheetUrl !== undefined) {
+            $('<link rel="stylesheet" id="ixv-style-skin" />')
+                .attr("href", this.resolveRelativeUrl(this.runtimeConfig.skin.stylesheetUrl))
+                .appendTo('head');
+        }
+        const favIconUrl = this.runtimeConfig.skin?.faviconUrl !== undefined ? this.resolveRelativeUrl(this.runtimeConfig.skin.faviconUrl) : require("../img/favicon.ico");
         $('<link id="ixv-favicon" type="image/x-icon" rel="shortcut icon" />')
-            .attr('href', require('../img/favicon.ico'))
+            .attr('href', favIconUrl)
             .appendTo('head');
 
         try {
@@ -140,7 +192,7 @@ export class iXBRLViewer {
     _reparentDocument() {
         const iframeContainer = $('#ixv #iframe-container');
 
-        const iframe = $('<iframe title="iXBRL document view"/>')
+        const iframe = $('<iframe title="iXBRL document view" tabindex="0"/>')
             .data("report-index", 0)
             .appendTo(iframeContainer)[0];
 
@@ -160,7 +212,8 @@ export class iXBRLViewer {
             $('html').attr("lang", "en-US");
         }
 
-        $('head').children().not("script").not("style#ixv-style").not("link#ixv-favicon").appendTo($(iframe).contents().find('head'));
+        $('head')
+            .children().not("script, style#ixv-style, link#ixv-style-skin, link#ixv-favicon").appendTo($(iframe).contents().find('head'));
 
         $('<title>').text(docTitle).appendTo($('head'));
 
@@ -197,11 +250,41 @@ export class iXBRLViewer {
         }
     }
 
+    _loadRuntimeConfig() {
+        return new Promise((resolve, reject) => {
+            if (this.options.configUrl === undefined) {
+                resolve({});
+            }
+            else {
+                fetch(this.options.configUrl)
+                    .then((resp) => {
+                        if (resp.status == 404) {
+                            return Promise.resolve({});
+                        }
+                        else if (resp.status != 200) {
+                            return Promise.reject("Fetch failed: " + resp.status);
+                        }
+                        return resp.json();
+                    })
+                    .then((data) => {
+                        resolve(data);
+                    })
+                    .catch((err) => {
+                        console.log(err);
+                        resolve({});
+                    });
+            }
+        });
+    }
+
     load() {
         const iv = this;
         const inspector = this.inspector;
+    
+        this._loadRuntimeConfig().then((runtimeConfig) => {
+            this.runtimeConfig = runtimeConfig;
+            initializeTheme();
 
-        setTimeout(function () {
             const stubViewer = $('body').hasClass('ixv-stub-viewer');
 
             // If viewer is disabled, but not in stub viewer mode, just abort
@@ -217,9 +300,25 @@ export class iXBRLViewer {
             // We need to parse JSON first so that we can determine feature enablement before loading begins.
             const taxonomyData = iv._getTaxonomyData();
             const parsedTaxonomyData = taxonomyData && JSON.parse(taxonomyData);
-            iv.setFeatures((parsedTaxonomyData && parsedTaxonomyData["features"]) || [], window.location.search);
+            let features = parsedTaxonomyData && parsedTaxonomyData["features"];
+            if (!features) {
+                features = {};
+            }
+            // `features` was previously an array of flag values
+            // Support this for backwards compatability
+            else if (Array.isArray(features)) {
+                features = features.reduce((obj, val) => {
+                    obj[val] = true;
+                    return obj;
+                }, {});
+            }
+            if (this.runtimeConfig.features !== undefined) {
+                features = {...this.runtimeConfig.features, features};
+            }
+            iv.setFeatures(features, window.location.search);
 
             const reportSet = new ReportSet(parsedTaxonomyData);
+            reportSet.taxonomyNamer = new TaxonomyNamer(new Map(Object.entries(this.runtimeConfig.taxonomyNames ?? {})));
 
             // Viewer disabled in stub viewer mode => redirect to first iXBRL document
             if (!iv.isViewerEnabled()) {
@@ -239,7 +338,7 @@ export class iXBRLViewer {
             const ds = reportSet.reportFiles();
             let hasExternalIframe = false;
             for (let i = stubViewer ? 0 : 1; i < ds.length; i++) {
-                const iframe = $("<iframe />").attr("src", ds[i].file).data("report-index", ds[i].index).appendTo("#ixv #iframe-container");
+                const iframe = $('<iframe tabindex="0" />').attr("src", ds[i].file).data("report-index", ds[i].index).appendTo("#ixv #iframe-container");
                 iframes = iframes.add(iframe);
                 hasExternalIframe = true;
             }
@@ -292,7 +391,6 @@ export class iXBRLViewer {
                                 $('#ixv .loader').remove();
 
                                 /* Focus on fact specified in URL fragment, if any */
-                                inspector.handleFactDeepLink();
                                 if (iv.options.showValidationWarningOnStart) {
                                     inspector.showValidationWarning();
                                 }

iXBRLViewerPlugin/viewer/src/js/ixbrlviewer.test.js

@@ -1,6 +1,12 @@
 // See COPYRIGHT.md for copyright information
 
 import {iXBRLViewer} from "./ixbrlviewer";
+import {
+    FEATURE_GUIDE_LINK,
+    FEATURE_REVIEW,
+    FEATURE_SUPPORT_LINK,
+    FEATURE_SURVEY_LINK
+} from "./util";
 describe("Feature enablement", () => {
     var viewer = null;
     beforeAll(() => {
@@ -8,58 +14,99 @@ describe("Feature enablement", () => {
     });
 
     test("Query parameter with no value results in enablement", () => {
-        viewer.setFeatures([], 'a')
-        expect(viewer._features).toEqual(new Set(['a']));
+        viewer.setFeatures({}, 'a')
+        expect(viewer._staticFeatures).toEqual({});
+        expect(viewer._dynamicFeatures).toEqual({'a': 'true'});
         expect(viewer.isFeatureEnabled('a')).toBeTruthy();
     });
 
     test("Excluded from JSON, excluded from query", () => {
-        viewer.setFeatures([], '')
-        expect(viewer._features).toEqual(new Set([]));
+        viewer.setFeatures({}, '')
+        expect(viewer._staticFeatures).toEqual({});
+        expect(viewer._dynamicFeatures).toEqual({});
         expect(viewer.isFeatureEnabled('a')).toBeFalsy();
     });
 
     test("Excluded from JSON, enabled in query", () => {
-        viewer.setFeatures([], 'a=true')
-        expect(viewer._features).toEqual(new Set(['a']));
+        viewer.setFeatures({}, 'a=true')
+        expect(viewer._staticFeatures).toEqual({});
+        expect(viewer._dynamicFeatures).toEqual({'a': 'true'});
         expect(viewer.isFeatureEnabled('a')).toBeTruthy();
     });
 
     test("Excluded from JSON, disabled in query", () => {
-        viewer.setFeatures([], 'a=false')
-        expect(viewer._features).toEqual(new Set([]));
+        viewer.setFeatures({}, 'a=false')
+        expect(viewer._staticFeatures).toEqual({});
+        expect(viewer._dynamicFeatures).toEqual({'a': 'false'});
         expect(viewer.isFeatureEnabled('a')).toBeFalsy();
     });
 
     test("Excluded from JSON, enabled and disabled in query", () => {
-        viewer.setFeatures([], 'a=true&a=false&a')
-        expect(viewer._features).toEqual(new Set([]));
+        viewer.setFeatures({}, 'a=true&a=false&a')
+        expect(viewer._staticFeatures).toEqual({});
+        expect(viewer._dynamicFeatures).toEqual({'a': 'false'});
         expect(viewer.isFeatureEnabled('a')).toBeFalsy();
     });
 
     test("Included in JSON, excluded from query", () => {
-        viewer.setFeatures(['a'], '')
-        expect(viewer._features).toEqual(new Set(['a']));
+        viewer.setFeatures({'a': true}, '')
+        expect(viewer._staticFeatures).toEqual({'a': true});
+        expect(viewer._dynamicFeatures).toEqual({});
         expect(viewer.isFeatureEnabled('a')).toBeTruthy();
     });
 
     test("Included in JSON, enabled in query", () => {
-        viewer.setFeatures(['a'], 'a=true')
-        expect(viewer._features).toEqual(new Set(['a']));
+        viewer.setFeatures({'a': true}, 'a=true')
+        expect(viewer._staticFeatures).toEqual({'a': true});
+        expect(viewer._dynamicFeatures).toEqual({'a': 'true'});
         expect(viewer.isFeatureEnabled('a')).toBeTruthy();
     });
 
     test("Included in JSON, disabled in query", () => {
-        viewer.setFeatures(['a'], 'a=false')
-        expect(viewer._features).toEqual(new Set([]));
+        viewer.setFeatures({'a': true}, 'a=false')
+        expect(viewer._staticFeatures).toEqual({'a': true});
+        expect(viewer._dynamicFeatures).toEqual({'a': 'false'});
         expect(viewer.isFeatureEnabled('a')).toBeFalsy();
     });
 
     test("Included in JSON, enabled and disabled in query", () => {
-        viewer.setFeatures(['a'], 'a=true&a=false&a')
-        expect(viewer._features).toEqual(new Set([]));
+        viewer.setFeatures({'a': true}, 'a=true&a=false&a')
+        expect(viewer._staticFeatures).toEqual({'a': true});
+        expect(viewer._dynamicFeatures).toEqual({'a': 'false'});
         expect(viewer.isFeatureEnabled('a')).toBeFalsy();
     });
+
+    test("Value set in JSON, not included in query", () => {
+        viewer.setFeatures({'a': '1'}, '')
+        expect(viewer._staticFeatures).toEqual({'a': '1'});
+        expect(viewer._dynamicFeatures).toEqual({});
+        expect(viewer.getFeatureValue('a')).toEqual('1');
+        expect(viewer.isFeatureEnabled('a')).toBeTruthy();
+    });
+
+    test("Value not set in JSON, set in query", () => {
+        viewer.setFeatures({}, 'a=1')
+        expect(viewer._staticFeatures).toEqual({});
+        expect(viewer._dynamicFeatures).toEqual({'a': '1'});
+        expect(viewer.getFeatureValue('a')).toEqual('1');
+        expect(viewer.isFeatureEnabled('a')).toBeTruthy();
+    });
+
+    test("Value set in JSON, overwritten in query", () => {
+        viewer.setFeatures({'a': '1'}, 'a=2')
+        expect(viewer._staticFeatures).toEqual({'a': '1'});
+        expect(viewer._dynamicFeatures).toEqual({'a': '2'});
+        expect(viewer.getFeatureValue('a')).toEqual('2');
+        expect(viewer.isFeatureEnabled('a')).toBeTruthy();
+    });
+
+    test("Value set in JSON, overwritten in query with blank", () => {
+        viewer.setFeatures({'a': '1'}, 'a')
+        expect(viewer._staticFeatures).toEqual({'a': '1'});
+        expect(viewer._dynamicFeatures).toEqual({'a': 'true'});
+        expect(viewer.getFeatureValue('a')).toEqual('true');
+        expect(viewer.isFeatureEnabled('a')).toBeTruthy();
+    });
 });
 
 describe("Review mode enablement", () => {
@@ -69,12 +116,78 @@ describe("Review mode enablement", () => {
     });
 
     test("Review mode enabled", () => {
-        viewer.setFeatures(['review'], '')
+        viewer.setFeatures({[FEATURE_REVIEW]: true}, '')
         expect(viewer.isReviewModeEnabled()).toBeTruthy();
     });
 
     test("Review mode disabled", () => {
-        viewer.setFeatures(['a'], '')
+        viewer.setFeatures({'a': true}, '')
         expect(viewer.isReviewModeEnabled()).toBeFalsy();
     });
 });
+
+describe("Support link enablement", () => {
+    var viewer = null;
+    beforeAll(() => {
+        viewer = new iXBRLViewer({})
+    });
+
+    test("Support link enabled by JSON", () => {
+        viewer.setFeatures({[FEATURE_SUPPORT_LINK]: '/help'}, '')
+        expect(viewer.getSupportLinkUrl()).toEqual('/help');
+    });
+
+    test("Support link enabled by query", () => {
+        viewer.setFeatures({}, FEATURE_SUPPORT_LINK + '=/help')
+        expect(viewer.getSupportLinkUrl()).toEqual(null);
+    });
+
+    test("Support link disabled by query", () => {
+        viewer.setFeatures({[FEATURE_SUPPORT_LINK]: '/help'}, FEATURE_SUPPORT_LINK + '=false')
+        expect(viewer.getSupportLinkUrl()).toEqual('/help');
+    });
+});
+
+describe("Survey link enablement", () => {
+    var viewer = null;
+    beforeAll(() => {
+        viewer = new iXBRLViewer({})
+    });
+
+    test("Survey link enabled by JSON", () => {
+        viewer.setFeatures({[FEATURE_SURVEY_LINK]: '/survey'}, '')
+        expect(viewer.getSurveyLinkUrl()).toEqual('/survey');
+    });
+
+    test("Survey link enabled by query", () => {
+        viewer.setFeatures({}, FEATURE_SURVEY_LINK + '=/survey')
+        expect(viewer.getSurveyLinkUrl()).toEqual(null);
+    });
+
+    test("Survey link disabled by query", () => {
+        viewer.setFeatures({[FEATURE_SURVEY_LINK]: '/survey'}, FEATURE_SURVEY_LINK + '=false')
+        expect(viewer.getSurveyLinkUrl()).toEqual('/survey');
+    });
+});
+
+describe("Guide link enablement", () => {
+    var viewer = null;
+    beforeAll(() => {
+        viewer = new iXBRLViewer({})
+    });
+
+    test("Guide link enabled by JSON", () => {
+        viewer.setFeatures({[FEATURE_GUIDE_LINK]: '/guide'}, '')
+        expect(viewer.getGuideLinkUrl()).toEqual('/guide');
+    });
+
+    test("Guide link enabled by query", () => {
+        viewer.setFeatures({}, FEATURE_GUIDE_LINK + '=/guide')
+        expect(viewer.getGuideLinkUrl()).toEqual(null);
+    });
+
+    test("Guide link disabled by query", () => {
+        viewer.setFeatures({[FEATURE_GUIDE_LINK]: '/guide'}, FEATURE_GUIDE_LINK + '=false')
+        expect(viewer.getGuideLinkUrl()).toEqual('/guide');
+    });
+});

iXBRLViewerPlugin/viewer/src/js/menu.js

@@ -1,6 +1,7 @@
 // See COPYRIGHT.md for copyright information
 
 import $ from 'jquery'
+import i18next from "i18next";
 
 export class Menu {
     constructor(elt, attr) {
@@ -65,14 +66,14 @@ export class Menu {
                 $('<input type="checkbox"></input>')
                     .prop("checked", onByDefault)
                     .change(function () {
-                        callback($(this).prop("checked"));
+                        callback($(this).prop("checked"), true);
                         menu.close(); 
                     })
             )
             .append($("<span></span>").addClass("checkmark"));
         this._add(item, after);
         if (onByDefault) {
-            callback(true);
+            callback(true, false);
         }
     }
 
@@ -91,7 +92,6 @@ export class Menu {
                         .attr({ "name": name, "value": v})
                         .on("change", function () {
                             callback($(this).val())
-                            menu.close(); 
                         })
                 )
                 .append($("<span></span>").addClass("checkmark"))
@@ -102,4 +102,22 @@ export class Menu {
             }
         }
     }
+
+    addLabel(name) {
+        const item = $('<div></div>')
+                .addClass("label")
+                .text(name)
+        this._add(item);
+    }
+
+    addLink(label, href) {
+        const item = $("<a></a>")
+                .attr("href", href)
+                .attr("target", "_blank")
+                .attr("title", label)
+                .attr("aria-label", label)
+                .addClass("item")
+                .text(label);
+        this._add(item);
+    }
 }

iXBRLViewerPlugin/viewer/src/js/outline.js

@@ -171,9 +171,9 @@ export class DocumentOutline {
     sortedSections() {
         const sections = Object.keys(this.sections);
         const re = /\(parenthetical\)\s*$/i;
-        const filteredSections = sections.filter(s => !re.test(this.report.getRoleLabel(s)));
+        const filteredSections = sections.filter(s => !re.test(this.report.getRoleLabelOrURI(s)));
         return filteredSections
-            .sort((a, b) => this.report.getRoleLabel(a).localeCompare(this.report.getRoleLabel(b)))
+            .sort((a, b) => this.report.getRoleLabelOrURI(a).localeCompare(this.report.getRoleLabelOrURI(b)))
             .map(elr => ({ report: this.report, fact: this.sections[elr], elr: elr }));
     }
 }

iXBRLViewerPlugin/viewer/src/js/report.js

@@ -165,7 +165,39 @@ export class XBRLReport {
                 return label;
             }
         }
-        return this.reportSet.roleMap()[rolePrefix];
+        return undefined;
+    }
+
+    getRoleLabelOrURI(rolePrefix) {
+        return this.getRoleLabel(rolePrefix) ?? this.reportSet.roleMap()[rolePrefix];
+    }
+
+    getLabelRoleLabel(rolePrefix) {
+        const roleURI = this.reportSet.roleMap()[rolePrefix];
+        if (roleURI === undefined) {
+            return undefined;
+        }
+
+        // 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}`);
+        }
+
+        // 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());
     }
 
     localDocuments() {
@@ -180,7 +212,7 @@ export class XBRLReport {
     }
 
     getScaleLabel(scale, unit) {
-        let label = i18next.t(`scale.${scale}`, {defaultValue:"noName"});
+        let label = i18next.t(`scale:${scale}`, {defaultValue:"noName"});
         if (unit && unit.isMonetary() && scale === -2) {
             let measure = unit.value() ?? '';
             if (measure) {
@@ -199,35 +231,47 @@ export class XBRLReport {
     }
 
     getLabel(c, rolePrefix, showPrefix) {
+        return this.getLabelAndLang(c, rolePrefix, showPrefix).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 "<no label>";
+            return { label: "<no label>" };
         }
         const labels = concept.labels[rolePrefix]
         if (labels === undefined || Object.keys(labels).length == 0) {
-            return undefined;
+            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.
-                label = labels["en"] || labels["en-us"] || labels[Object.keys(labels).sort()[0]];
+                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 undefined;
+                return {label: undefined};
             }
             let s = '';
             if (showPrefix && this.reportSet.viewerOptions.showPrefixes) {
-                s = "(" + this.qname(c).prefix + ") ";
+                s = "(" + this.reportSet.taxonomyNamer.fromQName(this.qname(c)).prefix + ") ";
             }
             s += label;
-            return s;
+            return { label: s, lang: actualLang };
         }
     }
 
@@ -239,6 +283,14 @@ export class XBRLReport {
         return label;
     }
 
+    getLabelOrNameAndLang(c, rolePrefix, showPrefix) {
+        const labelLang = this.getLabelAndLang(c, rolePrefix, showPrefix);
+        if (labelLang.label === undefined) {
+            return { label: c };
+        }
+        return labelLang;
+    }
+
     isCalculationContributor(c) {
         if (this._calculationContributors === undefined) {
             if (this._reportData.rels?.calc) {