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

iXBRLViewerPlugin/iXBRLViewer.py

@@ -1,6 +1,7 @@
 # See COPYRIGHT.md for copyright information
 
 from __future__ import annotations
+
 import io
 import json
 import logging
@@ -12,21 +13,32 @@ import urllib.parse
 import zipfile
 from collections import defaultdict
 from copy import deepcopy
-from typing import Optional, Union
-
-import pycountry
-from arelle import ModelXbrl, XbrlConst
-from arelle.ModelDocument import Type
+from pathlib import Path
+from typing import Any, Literal, cast
+
+from arelle import XbrlConst
+from arelle.Cntlr import Cntlr
+from arelle.ModelDocument import ModelDocument, Type
+from arelle.ModelDtsObject import ModelConcept
+from arelle.ModelInstanceObject import ModelInlineFact, ModelUnit
 from arelle.ModelRelationshipSet import ModelRelationshipSet
-from arelle.ModelValue import QName, INVALIDixVALUE
+from arelle.ModelValue import INVALIDixVALUE, QName
+from arelle.ModelXbrl import ModelXbrl
 from arelle.UrlUtil import isHttpUrl
 from arelle.ValidateXbrlCalcs import inferredDecimals
 from lxml import etree
 
-from .constants import DEFAULT_OUTPUT_NAME, DEFAULT_VIEWER_PATH, FEATURE_CONFIGS
+from .constants import (
+    DEFAULT_JS_FILENAME,
+    DEFAULT_OUTPUT_NAME,
+    ERROR_MESSAGE_CODE,
+    FEATURE_CONFIGS,
+    INFO_MESSAGE_CODE,
+    MANDATORY_FACTS,
+)
 from .xhtmlserialize import XHTMLSerializer
 
-
+REPORT_TYPE_EXTENSIONS = ('.xbrl', '.xhtml', '.html', '.htm', '.json')
 UNRECOGNIZED_LINKBASE_LOCAL_DOCUMENTS_TYPE = 'unrecognizedLinkbase'
 LINK_QNAME_TO_LOCAL_DOCUMENTS_LINKBASE_TYPE = {
     XbrlConst.qnLinkCalculationLink: 'calcLinkbase',
@@ -45,11 +57,11 @@ class NamespaceMap:
     required.
     """
 
-    def __init__(self):
-        self.nsmap = dict()
-        self.prefixmap = dict()
+    def __init__(self) -> None:
+        self.nsmap: dict[str, str] = {}
+        self.prefixmap: dict[str, str] = {}
 
-    def getPrefix(self, ns, preferredPrefix = None):
+    def getPrefix(self, ns: str, preferredPrefix: str | None = None) -> str:
         """
         Get the prefix for the specified namespace.
 
@@ -65,58 +77,85 @@ class NamespaceMap:
             else:
                 p = preferredPrefix if preferredPrefix else "ns"
                 n = 0
-                while "%s%d" % (p,n) in self.prefixmap:
+                while f"{p}{n}" in self.prefixmap:
                     n += 1
 
-                prefix = "%s%d" % (p,n)
+                prefix = f"{p}{n}"
 
             self.prefixmap[prefix] = ns
             self.nsmap[ns] = prefix
         return prefix
 
-    def qname(self, qname):
-        return "%s:%s" % (self.getPrefix(qname.namespaceURI, qname.prefix), qname.localName)
+    def qname(self, qname: QName) -> str:
+        if qname.namespaceURI is None:
+            return qname.localName
+        return f"{self.getPrefix(qname.namespaceURI, qname.prefix)}:{qname.localName}"
 
 class IXBRLViewerBuilderError(Exception):
     pass
 
+def isInlineDoc(doc: ModelDocument | None) -> bool:
+    return doc is not None and doc.type in {Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET}
+
 class IXBRLViewerBuilder:
 
-    def __init__(self, dts: ModelXbrl, basenameSuffix: str = ''):
+    def __init__(
+        self,
+        cntlr: Cntlr,
+        basenameSuffix: str = "",
+        useStubViewer: bool = False,
+        features: dict[str, Any] | None = None,
+    ):
+        if features is None:
+            features = {}
+        featureNames = {c.key for c in FEATURE_CONFIGS}
+        for featureName in features:
+            assert featureName in featureNames, \
+                f'Given feature name `{featureName}` does not match any defined features: {featureNames}'
+        self.reportZip: str | None = None
         self.nsmap = NamespaceMap()
         self.roleMap = NamespaceMap()
-        self.dts = dts
-        self.taxonomyData = {
-            "concepts": {},
-            "languages": {},
-            "facts": {},
-            "features": [],
+        self.taxonomyData: dict[str, Any] = {
+            "sourceReports": [],
+            "features": features,
         }
-        self.footnoteRelationshipSet = ModelRelationshipSet(dts, "XBRL-footnotes")
         self.basenameSuffix = basenameSuffix
+        self.currentTargetReport: dict[str, Any] | None = None
+        self.useStubViewer = useStubViewer
+        self.cntlr = cntlr
 
-    def enableFeature(self, featureName: str):
-        if featureName in self.taxonomyData["features"]:
-            return
-        featureNames = [c.key for c in FEATURE_CONFIGS]
-        assert featureName in featureNames, \
-            f'Given feature name `{featureName}` does not match any defined features: {featureNames}'
-        self.taxonomyData["features"].append(featureName)
+        self.idGen = 0
+        self.roleMap.getPrefix(XbrlConst.standardLabel, "std")
+        self.roleMap.getPrefix(XbrlConst.documentationLabel, "doc")
+        self.roleMap.getPrefix(XbrlConst.summationItem, "calc")
+        self.roleMap.getPrefix(XbrlConst.summationItem11, "calc11")
+        self.roleMap.getPrefix(XbrlConst.parentChild, "pres")
+        self.roleMap.getPrefix(XbrlConst.dimensionDefault, "d-d")
+        self.roleMap.getPrefix(WIDER_NARROWER_ARCROLE, "w-n")
+
+        self.sourceReportsByFiles: dict[frozenset[str], dict[str, Any]] = {}
+        self.iv = iXBRLViewer(cntlr)
+        if self.useStubViewer:
+            self.iv.addFile(iXBRLViewerFile(DEFAULT_OUTPUT_NAME, self.getStubDocument()))
 
-    def outputFilename(self, filename):
+        self.fromSingleZIP: bool | None = None
+        self.reportCount = 0
+        self.assets: list[str] = []
+
+    def outputFilename(self, filename: str) -> str:
         (base, ext) = os.path.splitext(filename)
         return base + self.basenameSuffix + ext
 
-    def lineWrap(self, s, n = 80):
+    def lineWrap(self, s: str, n: int = 80) -> str:
         return "\n".join([s[i:i+n] for i in range(0, len(s), n)])
 
-    def dateFormat(self, d):
+    def dateFormat(self, d: str) -> str:
         """
         Strip the time component from an ISO date if it's zero
         """
         return re.sub("T00:00:00$", "", d)
 
-    def escapeJSONForScriptTag(self, s):
+    def escapeJSONForScriptTag(self, s: str) -> str:
         """
         JSON encodes XML special characters XML and HTML apply difference escaping rules to content
         within script tags and we need our output to be valid XML, but treated as HTML by browsers.
@@ -130,52 +169,38 @@ class IXBRLViewerBuilder:
         """
         return s.replace("<","\\u003C").replace(">","\\u003E").replace("&","\\u0026")
 
-    def makeLanguageName(self, langCode):
-        code = re.sub("-.*","",langCode)
-        try:
-            language = pycountry.languages.lookup(code)
-            match = re.match(r'^[^-]+-(.*)$',langCode)
-            name = language.name
-            if match is not None:
-                name = "%s (%s)" % (name, match.group(1).upper())
-        except LookupError:
-            name = langCode
-
-        return name
-
-    def addLanguage(self, langCode):
-        if langCode not in self.taxonomyData["languages"]:
-            self.taxonomyData["languages"][langCode] = self.makeLanguageName(langCode)
-            
-    def addELR(self, elr):
+    def addRoleDefinition(self, report: ModelXbrl, elr: str) -> None:
         prefix = self.roleMap.getPrefix(elr)
-        if self.taxonomyData.setdefault("roleDefs",{}).get(prefix, None) is None:
-            rts = self.dts.roleTypes.get(elr, [])
+        assert self.currentTargetReport is not None, "Current target report must be set to add role definition"
+        if self.currentTargetReport.setdefault("roleDefs",{}).get(prefix, None) is None:
+            rts = report.roleTypes.get(elr, [])
             label = next((rt.definition for rt in rts if rt.definition is not None), None)
             if label is not None:
-                self.taxonomyData["roleDefs"].setdefault(prefix,{})["en"] = label
+                self.currentTargetReport["roleDefs"].setdefault(prefix,{})["en"] = label
 
-    def addConcept(self, concept, dimensionType = None):
+    def addConcept(self, report: ModelXbrl, concept: ModelConcept | None, dimensionType: str | None = None) -> None:
         if concept is None:
             return
-        labelsRelationshipSet = self.dts.relationshipSet(XbrlConst.conceptLabel)
+        labelsRelationshipSet = report.relationshipSet(XbrlConst.conceptLabel)
         labels = labelsRelationshipSet.fromModelObject(concept)
         conceptName = self.nsmap.qname(concept.qname)
-        if conceptName not in self.taxonomyData["concepts"]:
-            conceptData = {
+        assert self.currentTargetReport is not None, "Current target report must be set to add concept"
+        if conceptName not in self.currentTargetReport["concepts"]:
+            conceptData: dict[str, Any] = {
                 "labels": {  }
             }
             for lr in labels:
                 l = lr.toModelObject
                 conceptData["labels"].setdefault(self.roleMap.getPrefix(l.role),{})[l.xmlLang.lower()] = l.text;
-                self.addLanguage(l.xmlLang.lower());
+                self.addRoleDefinition(report, l.role)
 
             refData = []
-            for _refRel in concept.modelXbrl.relationshipSet(XbrlConst.conceptReference).fromModelObject(concept):
-                ref = []
-                for _refPart in _refRel.toModelObject.iterchildren():
-                    ref.append([_refPart.localName, _refPart.stringValue.strip()])
-                refData.append(ref)
+            if concept.modelXbrl is not None:
+                for _refRel in concept.modelXbrl.relationshipSet(XbrlConst.conceptReference).fromModelObject(concept):
+                    ref = []
+                    for _refPart in _refRel.toModelObject.iterchildren():
+                        ref.append([_refPart.localName, _refPart.stringValue.strip()])
+                    refData.append(ref)
 
             if len(refData) > 0:
                 conceptData['r'] = refData
@@ -186,32 +211,45 @@ class IXBRLViewerBuilder:
             if concept.isEnumeration:
                 conceptData["e"] = True
 
-            if concept.type is not None and concept.type.isTextBlock:
+            if concept.isTextBlock:
                 conceptData['t'] = True
 
+            if concept.balance is not None:
+                conceptData['b'] = concept.balance
+
+            if concept.type is not None:
+                conceptData['dt'] = self.nsmap.qname(concept.type.qname)
+
             if concept.isTypedDimension:
                 typedDomainElement = concept.typedDomainElement
                 if typedDomainElement is not None:
                     typedDomainName = self.nsmap.qname(typedDomainElement.qname)
                     conceptData['td'] = typedDomainName
-                    self.addConcept(typedDomainElement)
+                    self.addConcept(report, typedDomainElement)
 
-            self.taxonomyData["concepts"][conceptName] = conceptData
+            self.currentTargetReport["concepts"][conceptName] = conceptData
 
-    def treeWalk(self, rels, item, indent = 0):
+    def treeWalk(self, rels: ModelRelationshipSet, item: Any, indent: int = 0) -> None:
         for r in rels.fromModelObject(item):
             if r.toModelObject is not None:
                 self.treeWalk(rels, r.toModelObject, indent + 1)
 
-    def getRelationships(self):
-        rels = {}
+    def getRelationships(self, report: ModelXbrl) -> dict[str, dict[str, dict[str, list[dict[str, str]]]]]:
+        rels: dict[str, dict[str, dict[str, list[dict[str, str]]]]] = {}
 
-        for baseSetKey, baseSetModelLinks  in self.dts.baseSets.items():
-            arcrole, ELR, linkqname, arcqname = baseSetKey
-            if arcrole in (XbrlConst.summationItem, WIDER_NARROWER_ARCROLE, XbrlConst.parentChild, XbrlConst.dimensionDefault) and ELR is not None:
-                self.addELR(ELR)
-                rr = dict()
-                relSet = self.dts.relationshipSet(arcrole, ELR)
+        arcroles = {
+            XbrlConst.summationItem,
+            XbrlConst.summationItem11,
+            WIDER_NARROWER_ARCROLE,
+            XbrlConst.parentChild,
+            XbrlConst.dimensionDefault,
+        }
+        for baseSetKey in report.baseSets:
+            arcrole, ELR, _linkqname, _arcqname = baseSetKey
+            if ELR is not None and arcrole in arcroles:
+                self.addRoleDefinition(report, ELR)
+                rr: dict[str, list[dict[str, str]]] = {}
+                relSet = report.relationshipSet(arcrole, ELR)
                 for r in relSet.modelRelationships:
                     if r.fromModelObject is not None and r.toModelObject is not None:
                         fromKey = self.nsmap.qname(r.fromModelObject.qname)
@@ -221,21 +259,19 @@ class IXBRLViewerBuilder:
                         if r.weight is not None:
                             rel['w'] = r.weight
                         rr.setdefault(fromKey, []).append(rel)
-                        self.addConcept(r.toModelObject)
-                        self.addConcept(r.fromModelObject)
+                        self.addConcept(report, r.toModelObject)
+                        self.addConcept(report, r.fromModelObject)
 
-                rels.setdefault(self.roleMap.getPrefix(arcrole),{})[self.roleMap.getPrefix(ELR)] = rr
+                rels.setdefault(self.roleMap.getPrefix(arcrole), {})[self.roleMap.getPrefix(ELR)] = rr
         return rels
 
-    def validationErrors(self):
-        dts = self.dts
-
-        logHandler = dts.modelManager.cntlr.logHandler
-        if getattr(logHandler, "logRecordBuffer") is None:
+    def validationErrors(self) -> list[dict[str, str]]:
+        logHandler = self.cntlr.logHandler
+        if getattr(logHandler, "logRecordBuffer", None) is None:
             raise IXBRLViewerBuilderError("Logging is not configured to use a buffer.  Unable to retrieve validation messages")
 
-        errors = []
-        for logRec in getattr(logHandler, "logRecordBuffer"):
+        errors: list[dict[str, str]] = []
+        for logRec in getattr(logHandler, "logRecordBuffer", []):
             if logRec.levelno > logging.INFO:
                 errors.append({
                     "sev": logRec.levelname.title().upper(),
@@ -245,20 +281,23 @@ class IXBRLViewerBuilder:
 
         return errors
 
-    def addFact(self, f):
+    def addFact(self, report: ModelXbrl, f: ModelInlineFact) -> None:
         if f.id is None:
-            f.set("id","ixv-%d" % (self.idGen))
+            f.set("id", f"ixv-{self.idGen}")
 
         self.idGen += 1
         conceptName = self.nsmap.qname(f.qname)
+        factList = MANDATORY_FACTS.get(self.taxonomyData["features"].get("mandatory_facts"), [])
+        isMandatory = f.qname.localName in factList
         scheme, ident = f.context.entityIdentifier
 
         aspects = {
             "c": conceptName,
             "e": self.nsmap.qname(QName(self.nsmap.getPrefix(scheme,"e"), scheme, ident)),
+            "m": isMandatory
         }
 
-        factData = {
+        factData: dict[str, Any] = {
             "a": aspects,
         }
 
@@ -266,11 +305,15 @@ class IXBRLViewerBuilder:
             factData["v"] = None
         elif f.concept is not None and f.concept.isEnumeration:
             qnEnums = f.xValue
-            if not isinstance(qnEnums, list):
-                qnEnums = (qnEnums,)
-            factData["v"] = " ".join(self.nsmap.qname(qn) for qn in qnEnums)
-            for qn in qnEnums:
-                self.addConcept(self.dts.qnameConcepts.get(qn))
+            if qnEnums is None:
+                factData["v"] = f.value
+                factData["err"] = 'INVALID_IX_VALUE'
+            else:
+                if not isinstance(qnEnums, list):
+                    qnEnums = (qnEnums,)
+                factData["v"] = " ".join(self.nsmap.qname(qn) for qn in qnEnums)
+                for qn in qnEnums:
+                    self.addConcept(report, report.qnameConcepts.get(qn))
         else:
             factData["v"] = f.value 
             if f.value == INVALIDixVALUE:
@@ -292,24 +335,21 @@ class IXBRLViewerBuilder:
             if d != float("INF") and not math.isnan(d):
                 factData["d"] = d
 
-        for d, v in f.context.qnameDims.items():
+        for v in f.context.qnameDims.values():
             if v.memberQname is not None:
                 aspects[self.nsmap.qname(v.dimensionQname)] = self.nsmap.qname(v.memberQname)
-                self.addConcept(v.member)
-                self.addConcept(v.dimension, dimensionType = "e")
+                self.addConcept(report, v.member)
+                self.addConcept(report, v.dimension, dimensionType = "e")
             elif v.typedMember is not None:
                 aspects[self.nsmap.qname(v.dimensionQname)] = v.typedMember.text
-                self.addConcept(v.dimension, dimensionType = "t")
+                self.addConcept(report, v.dimension, dimensionType = "t")
 
         if f.context.isForeverPeriod:
             aspects["p"] = "f"
         elif f.context.isInstantPeriod and f.context.instantDatetime is not None:
             aspects["p"] = self.dateFormat(f.context.instantDatetime.isoformat())
         elif f.context.isStartEndPeriod and f.context.startDatetime is not None and f.context.endDatetime is not None:
-            aspects["p"] = "%s/%s" % (
-                self.dateFormat(f.context.startDatetime.isoformat()),
-                self.dateFormat(f.context.endDatetime.isoformat())
-            )
+            aspects["p"] = f"{self.dateFormat(f.context.startDatetime.isoformat())}/{self.dateFormat(f.context.endDatetime.isoformat())}"
 
         frels = self.footnoteRelationshipSet.fromModelObject(f)
         if frels:
@@ -317,10 +357,11 @@ class IXBRLViewerBuilder:
                 if frel.toModelObject is not None:
                     factData.setdefault("fn", []).append(frel.toModelObject.id)
 
-        self.taxonomyData["facts"][f.id] = factData
-        self.addConcept(f.concept)
+        assert self.currentTargetReport is not None, "Current target report must be set to add fact"
+        self.currentTargetReport["facts"][f.id] = factData
+        self.addConcept(report, f.concept)
 
-    def oimUnitString(self, unit):
+    def oimUnitString(self, unit: ModelUnit) -> str:
         """
         Returns an OIM-format string representation of the given ModelUnit.
         See https://www.xbrl.org/Specification/oim-common/REC-2021-10-13/oim-common-REC-2021-10-13.html#term-unit-string-representation
@@ -333,22 +374,22 @@ class IXBRLViewerBuilder:
             denominatorsString = '*'.join(self.nsmap.qname(x) for x in sorted(denominators))
             if len(denominators) > 1:
                 if len(numerators) > 1:
-                    return "({})/({})".format(numeratorsString, denominatorsString)
-                return "{}/({})".format(numeratorsString, denominatorsString)
+                    return f"({numeratorsString})/({denominatorsString})"
+                return f"{numeratorsString}/({denominatorsString})"
             else:
                 if len(numerators) > 1:
-                    return "({})/{}".format(numeratorsString, denominatorsString)
-                return "{}/{}".format(numeratorsString, denominatorsString)
+                    return f"({numeratorsString})/{denominatorsString}"
+                return f"{numeratorsString}/{denominatorsString}"
         return numeratorsString
 
-    def addViewerToXMLDocument(self, xmlDocument, scriptUrl):
+    def addViewerData(self, viewerFile: 'iXBRLViewerFile', scriptUrl: str) -> bool:
         taxonomyDataJSON = self.escapeJSONForScriptTag(json.dumps(self.taxonomyData, indent=1, allow_nan=False))
 
-        for child in xmlDocument.getroot():
+        for child in viewerFile.xmlDocument.getroot():
             if child.tag == '{http://www.w3.org/1999/xhtml}body':
                 for body_child in child:
-                    if body_child.tag == '{http://www.w3.org/1999/xhtml}script' and body_child.get('type','') == 'application/x.ixbrl-viewer+json':
-                        self.dts.error("viewer:error", "File already contains iXBRL viewer")
+                    if body_child.tag == '{http://www.w3.org/1999/xhtml}script' and body_child.get('type', '') == 'application/x.ixbrl-viewer+json':
+                        self.cntlr.addToLog("File already contains iXBRL viewer", messageCode="error")
                         return False
 
                 child.append(etree.Comment("BEGIN IXBRL VIEWER EXTENSIONS"))
@@ -372,82 +413,85 @@ class IXBRLViewerBuilder:
                 return True
         return False
 
-    def getStubDocument(self):
+    def getStubDocument(self) -> etree._ElementTree[etree._Element]:
         with open(os.path.join(os.path.dirname(__file__),"stubviewer.html")) as fin:
             return etree.parse(fin)
 
-    def createViewer(self, scriptUrl: str = DEFAULT_VIEWER_PATH, useStubViewer: bool = False, showValidations: bool = True, packageDownloadURL: str = None) -> Optional[iXBRLViewer]:
-        """
-        Create an iXBRL file with XBRL data as a JSON blob, and script tags added.
-        :param scriptUrl: The `src` value of the script tag that loads the viewer script.
-        :param useStubViewer: True if stub document should be included in output.
-        :param showValidations: True if validation errors should be included in output taxonomy data.
-        :return: An iXBRLViewer instance that is ready to be saved.
-        """
-        dts = self.dts
-        iv = iXBRLViewer(dts)
-        self.idGen = 0
-        self.roleMap.getPrefix(XbrlConst.standardLabel, "std")
-        self.roleMap.getPrefix(XbrlConst.documentationLabel, "doc")
-        self.roleMap.getPrefix(XbrlConst.summationItem, "calc")
-        self.roleMap.getPrefix(XbrlConst.parentChild, "pres")
-        self.roleMap.getPrefix(XbrlConst.dimensionDefault, "d-d")
-        self.roleMap.getPrefix(WIDER_NARROWER_ARCROLE, "w-n")
-
-        docSetFiles = None
-
-        for f in dts.facts:
-            self.addFact(f)
-
-        self.taxonomyData["prefixes"] = self.nsmap.prefixmap
-        self.taxonomyData["roles"] = self.roleMap.prefixmap
-        self.taxonomyData["rels"] = self.getRelationships()
+    def newTargetReport(self, target: str | None) -> dict[str, Any]:
+        return {
+            "concepts": {},
+            "facts": {},
+            "target": target,
+        }
 
-        if showValidations:
-            self.taxonomyData["validation"] = self.validationErrors()
+    def addSourceReport(self) -> dict[str, list[Any]]:
+        sourceReport: dict[str, list[Any]] = {
+            "targetReports": []
+        }
+        self.taxonomyData["sourceReports"].append(sourceReport)
+        return sourceReport
+
+    def processModel(self, report: ModelXbrl) -> None:
+        self.footnoteRelationshipSet = ModelRelationshipSet(report, "XBRL-footnotes")  # type: ignore[no-untyped-call]
+        self.currentTargetReport = self.newTargetReport(getattr(report, "ixdsTarget", None))
+        softwareCredits = set()
+        for document in report.urlDocs.values():
+            if isInlineDoc(document):
+                matches = document.creationSoftwareMatches(document.creationSoftwareComment)
+                softwareCredits.update(matches)
+        if softwareCredits:
+            self.currentTargetReport["softwareCredits"] = list(softwareCredits)
+        for f in report.facts:
+            if f.isTuple:
+                for nestedTupleFact in f.ixIter():  # type: ignore[attr-defined]
+                    self.addFact(report, nestedTupleFact)
+            else:
+                self.addFact(report, cast(ModelInlineFact, f))
+        self.currentTargetReport["rels"] = self.getRelationships(report)
 
-        dts.info("viewer:info", "Creating iXBRL viewer")
-        if dts.modelDocument.type == Type.INLINEXBRLDOCUMENTSET:
+        docSetFiles = None
+        self.reportCount += 1
+        report.info(
+            INFO_MESSAGE_CODE,
+            f"Creating iXBRL viewer ({self.reportCount}) [{self.currentTargetReport['target']}]",
+        )
+        assert report.modelDocument is not None
+        if report.modelDocument.type == Type.INLINEXBRLDOCUMENTSET:
             # Sort by object index to preserve order in which files were specified.
             xmlDocsByFilename = {
-                os.path.basename(self.outputFilename(doc.filepath)): deepcopy(doc.xmlDocument)
-                for doc in sorted(dts.modelDocument.referencesDocument.keys(), key=lambda x: x.objectIndex)
+                os.path.basename(self.outputFilename(doc.filepath)): doc.xmlDocument
+                for doc in sorted(report.modelDocument.referencesDocument.keys(), key=lambda x: x.objectIndex)
+                if doc.type == Type.INLINEXBRL
             }
             docSetFiles = list(xmlDocsByFilename.keys())
 
-            if useStubViewer:
-                xmlDocument = self.getStubDocument()
-                iv.addFile(iXBRLViewerFile(DEFAULT_OUTPUT_NAME, xmlDocument))
-            else:
-                xmlDocument = next(iter(xmlDocsByFilename.values()))
-
             for filename, docSetXMLDoc in xmlDocsByFilename.items():
-                iv.addFile(iXBRLViewerFile(filename, docSetXMLDoc))
+                self.iv.addFile(iXBRLViewerFile(filename, docSetXMLDoc))
 
-        elif useStubViewer:
-            xmlDocument = self.getStubDocument()
-            filename = self.outputFilename(os.path.basename(dts.modelDocument.filepath))
+        elif self.useStubViewer:
+            filename = self.outputFilename(os.path.basename(report.modelDocument.filepath))
             docSetFiles = [ filename ]
-            iv.addFile(iXBRLViewerFile(DEFAULT_OUTPUT_NAME, xmlDocument))
-            iv.addFile(iXBRLViewerFile(filename, dts.modelDocument.xmlDocument))
+            self.iv.addFile(iXBRLViewerFile(filename, report.modelDocument.xmlDocument))
 
         else:
-            xmlDocument = deepcopy(dts.modelDocument.xmlDocument)
-            iv.addFile(iXBRLViewerFile('xbrlviewer.html', xmlDocument))
-
-        if packageDownloadURL is not None:
-            self.taxonomyData["filingDocuments"] = packageDownloadURL
-        elif os.path.dirname(self.dts.modelDocument.filepath).endswith('.zip'):
-            filingDocZipPath = os.path.dirname(self.dts.modelDocument.filepath)
-            filingDocZipName = os.path.basename(filingDocZipPath)
-            iv.addFilingDoc(filingDocZipPath)
-            self.taxonomyData["filingDocuments"] = filingDocZipName
+            srcFilename = self.outputFilename(os.path.basename(report.modelDocument.filepath))
+            docSetFiles = [ srcFilename ]
+            filename = srcFilename
+            self.iv.addFile(iXBRLViewerFile(filename, report.modelDocument.xmlDocument))
+        docSetKey = frozenset(docSetFiles)
+        sourceReport = self.sourceReportsByFiles.get(docSetKey)
+        if sourceReport is None:
+            sourceReport = self.addSourceReport()
+            self.sourceReportsByFiles[docSetKey] = sourceReport
+            sourceReport["docSetFiles"] = list(urllib.parse.quote(f) for f in docSetFiles)
+
+        sourceReport["targetReports"].append(self.currentTargetReport)
 
         localDocs = defaultdict(set)
-        for path, doc in dts.urlDocs.items():
-            if isHttpUrl(path):
+        for path, doc in report.urlDocs.items():
+            if isHttpUrl(path) or doc.type == Type.INLINEXBRLDOCUMENTSET:
                 continue
-            if doc.type in (Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET):
+            if doc.type == Type.INLINEXBRL:
                 localDocs[doc.basename].add('inline')
             elif doc.type == Type.SCHEMA:
                 localDocs[doc.basename].add('schema')
@@ -460,40 +504,107 @@ class IXBRLViewerBuilder:
                         linkbaseIdentifed = True
                 if not linkbaseIdentifed:
                     localDocs[doc.basename].add(UNRECOGNIZED_LINKBASE_LOCAL_DOCUMENTS_TYPE)
-        self.taxonomyData["localDocs"] = {
+        self.currentTargetReport["localDocs"] = {
             localDoc: sorted(docTypes)
             for localDoc, docTypes in localDocs.items()
         }
 
-        if docSetFiles is not None:
-            self.taxonomyData["docSetFiles"] = list(urllib.parse.quote(f) for f in docSetFiles)
+        # If we only process a single ZIP, add a download link to it as the
+        # "filing documents" on the viewer menu.
+        if self.fromSingleZIP is None:
+            self.fromSingleZIP = report.modelDocument.filepath.endswith(".zip")
+            if self.fromSingleZIP:
+                self.filingDocZipPath = os.path.dirname(report.modelDocument.filepath)
+        else:
+            self.fromSingleZIP = False
+        if report.fileSource.isArchive and isinstance(report.fileSource.fs, zipfile.ZipFile):
+            filelist = report.fileSource.fs.filelist
+            for file in filelist:
+                directory, asset = os.path.split(file.filename)
+                if "reports" in directory and asset != '' and not asset.lower().endswith(REPORT_TYPE_EXTENSIONS):
+                    self.assets.append(file.filename)
+            if self.assets:
+                self.reportZip = report.fileSource.fs.filename
+
+    def createViewer(
+            self,
+            scriptUrl: str = DEFAULT_JS_FILENAME,
+            showValidations: bool = True,
+            packageDownloadURL: str | None = None,
+    ) -> 'iXBRLViewer' | None:
+        """
+        Create an iXBRL file with XBRL data as a JSON blob, and script tags added.
+        :param scriptUrl: The `src` value of the script tag that loads the viewer script.
+        :param showValidations: True if validation errors should be included in output taxonomy data.
+        :return: An iXBRLViewer instance that is ready to be saved.
+        """
+
+        self.taxonomyData["prefixes"] = self.nsmap.prefixmap
+        self.taxonomyData["roles"] = self.roleMap.prefixmap
+        if showValidations:
+            self.taxonomyData["validation"] = self.validationErrors()
+
+        if packageDownloadURL is not None:
+            self.taxonomyData["filingDocuments"] = packageDownloadURL
+        elif self.fromSingleZIP:
+            filingDocZipName = os.path.basename(self.filingDocZipPath)
+            self.iv.addFilingDoc(self.filingDocZipPath)
+            self.taxonomyData["filingDocuments"] = filingDocZipName
 
-        if not self.addViewerToXMLDocument(xmlDocument, scriptUrl):
+        if not self.addViewerData(self.iv.files[0], scriptUrl):
             return None
 
-        return iv
+        if len(self.iv.files) == 1:
+            # If there is only a single report, call the output file "xbrlviewer.html"
+            # We should probably preserve the source file extension here.
+            self.iv.files[0].filename = 'xbrlviewer.html'
+        if self.assets:
+            self.iv.addReportAssets(self.assets)
+        if self.reportZip:
+            self.iv.reportZip = self.reportZip
+        return self.iv
 
 
 class iXBRLViewerFile:
 
-    def __init__(self, filename, xmlDocument):
+    def __init__(self, filename: str, xmlDocument: etree._ElementTree[etree._Element]) -> None:
         self.filename = filename
-        self.xmlDocument = xmlDocument
+        self.xmlDocument: etree._ElementTree[etree._Element] = deepcopy(xmlDocument)
+        # deepcopy does not retain the Python proxies, so iterating the node
+        # tree during serialization will create new ones. However, the original
+        # ModelObjectFactory is still referenced, and that references a
+        # ModelXbrl that will potentially be closed by the time we serialize.
+        # Serialization only requires standard XML features, so the default
+        # lxml.etree classes (and thus lookup) are fine.
+        if self.xmlDocument.parser is not None:
+            self.xmlDocument.parser.set_element_class_lookup(etree.ElementDefaultClassLookup())
 
 
 class iXBRLViewer:
 
-    def __init__(self, dts):
-        self.files = []
-        self.filingDocuments = None
-        self.dts = dts
-    def addFile(self, ivf):
-        self.files.append(ivf)
+    def __init__(self, cntlr: Cntlr) -> None:
+        self.reportZip: str | None = None
+        self.filesByFilename: dict[str, iXBRLViewerFile] = {}
+        self.filingDocuments: str | None = None
+        self.cntlr = cntlr
+        self.assets: list[str] = []
 
-    def addFilingDoc(self, filingDocuments):
+    def addReportAssets(self, assets: list[str]) -> None:
+        self.assets.extend(assets)
+
+    def addFile(self, ivf: iXBRLViewerFile) -> None:
+        # Overwrite previous occurrences of the same document, because it may
+        # have had more IDs added to it by subsequent target documents.
+        self.filesByFilename[ivf.filename] = ivf
+
+    @property
+    def files(self) -> list[iXBRLViewerFile]:
+        return list(self.filesByFilename.values())
+
+    def addFilingDoc(self, filingDocuments: str) -> None:
         self.filingDocuments = filingDocuments
 
-    def save(self, destination: Union[io.BytesIO, str], zipOutput: bool = False, copyScriptPath: Optional[str] = None):
+    def save(self, destination: io.BytesIO | str, zipOutput: bool = False, copyScriptPath: Path | None = None) -> None:
         """
         Save the iXBRL viewer.
         :param destination: The target that viewer data/files will be written to (path to file/directory, or a file object itself).
@@ -502,82 +613,113 @@ class iXBRLViewer:
         """
         if isinstance(destination, io.BytesIO) or zipOutput: # zip output stream
             # zipfile may be cumulatively added to by inline extraction, EdgarRenderer etc
+            filepath: io.BytesIO | str
+            fileMode: Literal['a', 'w']
             if isinstance(destination, io.BytesIO):
-                file = destination
+                filepath = destination
                 fileMode = 'a'
                 destination = os.sep
             elif os.path.isdir(destination):
-                file = os.path.join(destination, f'{os.path.splitext(os.path.basename(self.files[0].filename))[0]}.zip')
+                filepath = os.path.join(
+                    destination,
+                    f'{os.path.splitext(os.path.basename(self.files[0].filename))[0]}.zip',
+                )
                 fileMode = 'w'
             elif destination.endswith(os.sep):
                 # Looks like a directory, but isn't one
-                self.dts.error("viewer:error", "Directory %s does not exist" % destination)
+                self.cntlr.addToLog(
+                    f"Directory {destination} does not exist",
+                    messageCode=ERROR_MESSAGE_CODE,
+                )
                 return
             elif not os.path.isdir(os.path.dirname(os.path.abspath(destination))):
                 # Directory part of filename doesn't exist
-                self.dts.error("viewer:error", "Directory %s does not exist" % os.path.dirname(os.path.abspath(destination)))
+                self.cntlr.addToLog(
+                    f"Directory {os.path.dirname(os.path.abspath(destination))} does not exist",
+                    messageCode=ERROR_MESSAGE_CODE,
+                )
                 return
             elif not destination.endswith('.zip'):
                 # File extension isn't a zip
-                self.dts.error("viewer:error", "File extension %s is not a zip" % os.path.splitext(destination)[0])
+                self.cntlr.addToLog(
+                    f"File extension {os.path.splitext(destination)[0]} is not a zip",
+                    messageCode=ERROR_MESSAGE_CODE,
+                )
                 return
             else:
-                file = destination
+                filepath = destination
                 fileMode = 'w'
 
-            with zipfile.ZipFile(file, fileMode, zipfile.ZIP_DEFLATED, True) as zout:
+            with zipfile.ZipFile(filepath, fileMode, zipfile.ZIP_DEFLATED, allowZip64=True) as zout:
                 for f in self.files:
-                    self.dts.info("viewer:info", "Saving in output zip %s" % f.filename)
+                    self.cntlr.addToLog(f"Saving in output zip {f.filename}", messageCode=INFO_MESSAGE_CODE)
                     with zout.open(f.filename, "w") as fout:
                         writer = XHTMLSerializer(fout)
                         writer.serialize(f.xmlDocument)
                 if self.filingDocuments:
                     filename = os.path.basename(self.filingDocuments)
-                    self.dts.info("viewer:info", "Writing %s" % filename)
+                    self.cntlr.addToLog(f"Writing {filename}", messageCode=INFO_MESSAGE_CODE)
                     zout.write(self.filingDocuments, filename)
                 if copyScriptPath is not None:
-                    scriptSrc = os.path.join(destination, copyScriptPath)
-                    self.dts.info("viewer:info", "Writing script from %s" % scriptSrc)
-                    zout.write(scriptSrc, os.path.basename(copyScriptPath))
+                    self.cntlr.addToLog(f"Writing script from {copyScriptPath}", messageCode=INFO_MESSAGE_CODE)
+                    zout.write(copyScriptPath, copyScriptPath.name)
         elif os.path.isdir(destination):
             # If output is a directory, write each file in the doc set to that
             # directory using its existing filename
             for f in self.files:
                 filename = os.path.join(destination, f.filename)
-                self.dts.info("viewer:info", "Writing %s" % filename)
+                self.cntlr.addToLog(f"Writing {filename}", messageCode=INFO_MESSAGE_CODE)
                 with open(filename, "wb") as fout:
                     writer = XHTMLSerializer(fout)
                     writer.serialize(f.xmlDocument)
             if self.filingDocuments:
                 filename = os.path.basename(self.filingDocuments)
-                self.dts.info("viewer:info", "Writing %s" % filename)
+                self.cntlr.addToLog(f"Writing {filename}", messageCode=INFO_MESSAGE_CODE)
                 shutil.copy2(self.filingDocuments, os.path.join(destination, filename))
+            if self.assets and self.reportZip is not None:
+                with zipfile.ZipFile(self.reportZip) as z:
+                    for asset in self.assets:
+                        fileName = os.path.basename(asset)
+                        path = os.path.join(destination, fileName)
+                        self.cntlr.addToLog(f"Writing {asset}", messageCode=INFO_MESSAGE_CODE)
+                        with z.open(asset) as zf, open(path, 'wb') as assetFile:
+                            shutil.copyfileobj(zf, assetFile)
+
             if copyScriptPath is not None:
-                self._copyScript(destination, copyScriptPath)
+                self._copyScript(Path(destination), copyScriptPath)
         else:
             if len(self.files) > 1:
-                self.dts.error("viewer:error", "More than one file in input, but output is not a directory")
+                self.cntlr.addToLog(
+                    "More than one file in input, but output is not a directory",
+                    messageCode=ERROR_MESSAGE_CODE,
+                )
             elif destination.endswith(os.sep):
                 # Looks like a directory, but isn't one
-                self.dts.error("viewer:error", "Directory %s does not exist" % destination)
+                self.cntlr.addToLog(
+                    f"Directory {destination} does not exist",
+                    messageCode=ERROR_MESSAGE_CODE,
+                )
             elif not os.path.isdir(os.path.dirname(os.path.abspath(destination))):
                 # Directory part of filename doesn't exist
-                self.dts.error("viewer:error", "Directory %s does not exist" % os.path.dirname(os.path.abspath(destination)))
+                self.cntlr.addToLog(
+                    f"Directory {os.path.dirname(os.path.abspath(destination))} does not exist",
+                    messageCode=ERROR_MESSAGE_CODE,
+                )
             else:
-                self.dts.info("viewer:info", "Writing %s" % destination)
+                self.cntlr.addToLog(f"Writing {destination}", messageCode=INFO_MESSAGE_CODE)
                 with open(destination, "wb") as fout:
                     writer = XHTMLSerializer(fout)
                     writer.serialize(self.files[0].xmlDocument)
                 if self.filingDocuments:
                     filename = os.path.basename(self.filingDocuments)
-                    self.dts.info("viewer:info", "Writing %s" % filename)
+                    self.cntlr.addToLog(f"Writing {filename}", messageCode=INFO_MESSAGE_CODE)
                     shutil.copy2(self.filingDocuments, os.path.join(os.path.dirname(destination), filename))
                 if copyScriptPath is not None:
-                    outDirectory = os.path.dirname(os.path.join(os.getcwd(), destination))
+                    outDirectory = Path(destination).parent
                     self._copyScript(outDirectory, copyScriptPath)
 
-    def _copyScript(self, directory: str, scriptPath: str):
-        scriptSrc = os.path.join(directory, scriptPath)
-        scriptDest = os.path.join(directory, os.path.basename(scriptPath))
-        self.dts.info("viewer:info", "Copying script from %s to %s" % (scriptSrc, scriptDest))
-        shutil.copy2(scriptSrc, scriptDest)
+    def _copyScript(self, destDirectory: Path, scriptPath: Path) -> None:
+        scriptDest = destDirectory / scriptPath.name
+        if scriptPath != scriptDest:
+            self.cntlr.addToLog(f"Copying script from {scriptPath} to {scriptDest}.", messageCode=INFO_MESSAGE_CODE)
+            shutil.copy2(scriptPath, scriptDest)