node-opcua-address-space 2.180.0 → 2.181.0

package/dist/impl/nodeset_tools/nodeset_to_records.js

@@ -0,0 +1,773 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeIdType = exports.makeTypeXsd = exports.DataTypeIds = exports.NodesetExportError = exports.sortByNodeId = void 0;
+exports.namespaceToWalkEvents = namespaceToWalkEvents;
+exports.nodeToWalkEvents = nodeToWalkEvents;
+exports.namespaceToRecords = namespaceToRecords;
+exports.namespaceToImage = namespaceToImage;
+const node_opcua_basic_types_1 = require("node-opcua-basic-types");
+const node_opcua_constants_1 = require("node-opcua-constants");
+Object.defineProperty(exports, "DataTypeIds", { enumerable: true, get: function () { return node_opcua_constants_1.DataTypeIds; } });
+const node_opcua_data_access_1 = require("node-opcua-data-access");
+const node_opcua_data_model_1 = require("node-opcua-data-model");
+const node_opcua_debug_1 = require("node-opcua-debug");
+const node_opcua_nodeid_1 = require("node-opcua-nodeid");
+Object.defineProperty(exports, "NodeIdType", { enumerable: true, get: function () { return node_opcua_nodeid_1.NodeIdType; } });
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const node_opcua_types_1 = require("node-opcua-types");
+const node_opcua_utils_1 = require("node-opcua-utils");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const xml_writer_1 = __importDefault(require("xml-writer"));
+const decode_xml_extension_object_js_1 = require("../../api/loader/decode_xml_extension_object.js");
+const nodeset_image_js_1 = require("../../api/loader/nodeset_image.js");
+const nodeset_record_js_1 = require("../../api/loader/nodeset_record.js");
+const nodeset_source_js_1 = require("../../api/loader/nodeset_source.js");
+const base_node_impl_js_1 = require("../base_node_impl.js");
+const namespace_impl_js_1 = require("../namespace_impl.js");
+const reference_impl_js_1 = require("../reference_impl.js");
+const ua_method_impl_js_1 = require("../ua_method_impl.js");
+const ua_object_impl_js_1 = require("../ua_object_impl.js");
+const ua_variable_impl_js_1 = require("../ua_variable_impl.js");
+const construct_namespace_dependency_js_1 = require("./construct_namespace_dependency.js");
+const nodeset_to_xml_js_1 = require("./nodeset_to_xml.js");
+Object.defineProperty(exports, "makeTypeXsd", { enumerable: true, get: function () { return nodeset_to_xml_js_1.makeTypeXsd; } });
+const warningLog = (0, node_opcua_debug_1.make_warningLog)("nodeset_to_records");
+/** the order the exporters list nodes in: by NodeId string, what the XML writer sorted by all along */
+const sortByNodeId = (a, b) => a.nodeId.toString() < b.nodeId.toString() ? -1 : 1;
+exports.sortByNodeId = sortByNodeId;
+const currentReadFlag = (0, node_opcua_data_model_1.makeAccessLevelFlag)("CurrentRead");
+/** what the exporter cannot turn into a record: named by the node so that the caller can act */
+class NodesetExportError extends Error {
+}
+exports.NodesetExportError = NodesetExportError;
+class RecordExporter {
+    namespace;
+    addressSpace;
+    priorityTable;
+    dependency;
+    sortedDependencies;
+    translationTable;
+    namespaceArray;
+    namespacesMap;
+    definitionMap;
+    visited = new Set();
+    records = [];
+    section(text) {
+        this.records.push({ kind: "section", text });
+    }
+    constructor(namespace) {
+        this.namespace = namespace;
+        const addressSpace = namespace.addressSpace;
+        this.addressSpace = addressSpace;
+        this.priorityTable = (0, construct_namespace_dependency_js_1.constructNamespacePriorityTable)(addressSpace).priorityTable;
+        this.dependency = (0, construct_namespace_dependency_js_1.constructNamespaceDependency)(namespace, this.priorityTable);
+        this.translationTable = (0, construct_namespace_dependency_js_1._constructNamespaceTranslationTable)(this.dependency, namespace);
+        this.sortedDependencies = [...this.dependency].sort((a, b) => (this.translationTable.get(a.index) ?? 0) > (this.translationTable.get(b.index) ?? 0) ? 1 : -1);
+        const namespaceArrayNode = addressSpace.findNode(node_opcua_constants_1.VariableIds.Server_NamespaceArray);
+        this.namespaceArray = namespaceArrayNode ? namespaceArrayNode.readAttribute(null, node_opcua_basic_types_1.AttributeIds.Value).value.value : [];
+        this.namespacesMap = {
+            "http://opcfoundation.org/UA/2011/03/UANodeSet.xsd": "",
+            "http://opcfoundation.org/UA/2008/02/Types.xsd": "uax",
+            "http://www.w3.org/2001/XMLSchema-instance": "xsi"
+        };
+        for (const dependency of this.dependency) {
+            if (dependency.index === 0)
+                continue;
+            this.namespacesMap[dependency.namespaceUri] = `ns${this.translationTable.get(dependency.index)}`;
+        }
+        this.definitionMap = (0, decode_xml_extension_object_js_1.makeDefinitionMap)(addressSpace);
+    }
+    // #region ids
+    t(nodeId) {
+        const namespace = this.translationTable.get(nodeId.namespace);
+        if (namespace === undefined) {
+            throw new NodesetExportError(`namespace ${nodeId.namespace} of ${nodeId.toString()} is not in the dependency set of ${this.namespace.namespaceUri}`);
+        }
+        if (nodeId instanceof node_opcua_nodeid_1.ExpandedNodeId) {
+            return new node_opcua_nodeid_1.ExpandedNodeId(nodeId.identifierType, nodeId.value, namespace, nodeId.namespaceUri, nodeId.serverIndex);
+        }
+        return new node_opcua_nodeid_1.NodeId(nodeId.identifierType, nodeId.value, namespace);
+    }
+    tq(browseName) {
+        return new node_opcua_data_model_1.QualifiedName({ namespaceIndex: this.translationTable.get(browseName.namespaceIndex), name: browseName.name });
+    }
+    /** the browse name as the XML writes it: `ns=0;` dropped */
+    b(browseName) {
+        return this.tq(browseName).toString().replace("ns=0;", "");
+    }
+    hash(node) {
+        return node.nodeId.toString();
+    }
+    hasHigherPriorityThan(namespaceIndex1, namespaceIndex2) {
+        return this.priorityTable[namespaceIndex1] > this.priorityTable[namespaceIndex2];
+    }
+    // #endregion
+    /** the events of one node and what the walk brings with it (type, supertype, children); no header */
+    walkFrom(node) {
+        this.dumpNode(node);
+        return this.records;
+    }
+    /** the exported file's namespace table, address-space index to file index */
+    get translation() {
+        return this.translationTable;
+    }
+    run() {
+        const namespace = this.namespace;
+        this.records.push(this.header());
+        this.section("ReferenceTypes");
+        const referenceTypes = [...namespace._referenceTypeIterator()].sort(nodeset_to_xml_js_1.sortByBrowseName);
+        for (const referenceType of referenceTypes) {
+            this.dumpReferenceType(referenceType);
+        }
+        const dataTypes = [...namespace._dataTypeIterator()].sort(nodeset_to_xml_js_1.sortByBrowseName);
+        if (dataTypes.length) {
+            this.section("DataTypes");
+            for (const dataType of dataTypes.sort(exports.sortByNodeId)) {
+                if (!this.visited.has(this.hash(dataType))) {
+                    this.dumpNode(dataType);
+                }
+            }
+            this.dumpDictionaries();
+        }
+        this.section("ObjectTypes");
+        const objectTypes = [...namespace._objectTypeIterator()].sort(nodeset_to_xml_js_1.sortByBrowseName);
+        for (const objectType of objectTypes.sort(exports.sortByNodeId)) {
+            if (!this.visited.has(this.hash(objectType))) {
+                this.dumpNode(objectType);
+            }
+        }
+        this.section("VariableTypes");
+        const variableTypes = [...namespace._variableTypeIterator()].sort(nodeset_to_xml_js_1.sortByBrowseName);
+        for (const variableType of variableTypes.sort(exports.sortByNodeId)) {
+            if (!this.visited.has(this.hash(variableType))) {
+                this.dumpNode(variableType);
+            }
+        }
+        this.section("Other Nodes");
+        const nodes = [...namespace.nodeIterator()].sort(nodeset_to_xml_js_1.sortByBrowseName);
+        for (const node of nodes.sort(exports.sortByNodeId)) {
+            if (!this.visited.has(this.hash(node))) {
+                this.dumpNode(node);
+            }
+        }
+        return this.records;
+    }
+    // #region header
+    header() {
+        const namespace = this.namespace;
+        const namespaceUris = this.sortedDependencies.filter((d) => d.index !== 0).map((d) => d.namespaceUri);
+        const requiredModels = this.sortedDependencies
+            .filter((d) => d.index !== namespace.index)
+            .map((d) => ({ modelUri: d.namespaceUri, version: d.version, publicationDate: d.publicationDate }));
+        const aliases = {};
+        const aliasesVisited = new Set();
+        for (const node of namespace.nodeIterator()) {
+            this.buildUpAliases(node, aliases, aliasesVisited);
+        }
+        // sorted by name, as the XML writes them: two exports of one namespace are diffable line by line
+        const sortedAliases = {};
+        for (const key of Object.keys(aliases).sort())
+            sortedAliases[key] = aliases[key];
+        return {
+            kind: "header",
+            namespaceUris,
+            models: [
+                {
+                    modelUri: namespace.namespaceUri,
+                    version: namespace.version,
+                    publicationDate: namespace.publicationDate,
+                    requiredModels
+                }
+            ],
+            aliases: sortedAliases
+        };
+    }
+    buildUpAliases(node, aliases, aliasesVisited) {
+        const k = this.hash(node);
+        if (aliasesVisited.has(k))
+            return;
+        aliasesVisited.add(k);
+        if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable || node.nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+            const nodeV = node;
+            if (nodeV.dataType && nodeV.dataType.value !== 0) {
+                const dataTypeName = this.b(this.resolveDataTypeName(nodeV.dataType));
+                if (dataTypeName && !aliases[dataTypeName]) {
+                    aliases[dataTypeName] = this.t(nodeV.dataType);
+                }
+            }
+        }
+        for (const reference of node.allReferences()) {
+            const key = this.b((0, base_node_impl_js_1.getReferenceType)(reference).browseName);
+            // the XML export overwrites a reference-type alias each time it meets it; same value every time
+            aliases[key] = this.t(reference.referenceType);
+        }
+    }
+    resolveDataTypeName(dataType) {
+        const dataTypeNode = this.addressSpace.findNode(dataType);
+        if (!dataTypeNode) {
+            warningLog(`resolveDataTypeName: cannot find DataType ${dataType.toString()}`);
+            return new node_opcua_data_model_1.QualifiedName({ name: "", namespaceIndex: 0 });
+        }
+        return dataTypeNode.browseName;
+    }
+    // #endregion
+    // #region references and common fields
+    referencesOf(node) {
+        const addressSpace = this.addressSpace;
+        const must = (name) => {
+            const referenceType = addressSpace.findReferenceType(name);
+            if (!referenceType)
+                throw new NodesetExportError(`Cannot find standard reference type ${name}: please check your nodeset file`);
+            return referenceType;
+        };
+        const aggregates = must("Aggregates");
+        const hasSubtype = must("HasSubtype");
+        const hasTypeDefinition = must("HasTypeDefinition");
+        const nonHierarchical = must("NonHierarchicalReferences");
+        const organizes = must("Organizes");
+        const connectsTo = addressSpace.findReferenceType("ConnectsTo");
+        const hasEventSource = must("HasEventSource");
+        const keep = (reference) => {
+            // resolved here: a reference nobody has looked at since the load carries only the NodeId of its type
+            const referenceType = reference_impl_js_1.ReferenceImpl.resolveReferenceType(addressSpace, reference);
+            if (!referenceType)
+                return false;
+            if (referenceType.isSubtypeOf(aggregates) &&
+                !reference.isForward &&
+                reference.nodeId.namespace !== node.nodeId.namespace)
+                return true;
+            if (referenceType.isSubtypeOf(aggregates) && reference.isForward) {
+                return !this.hasHigherPriorityThan(reference.nodeId.namespace, node.nodeId.namespace);
+            }
+            if (referenceType.isSubtypeOf(hasSubtype) && !reference.isForward)
+                return true;
+            if (referenceType.isSubtypeOf(hasTypeDefinition) && reference.isForward)
+                return true;
+            if (referenceType.isSubtypeOf(nonHierarchical) && reference.isForward)
+                return true;
+            if (referenceType.isSubtypeOf(organizes) && !reference.isForward)
+                return true;
+            if (connectsTo && referenceType.isSubtypeOf(connectsTo) && reference.isForward)
+                return true;
+            if (referenceType.isSubtypeOf(hasEventSource) && reference.isForward)
+                return true;
+            return false;
+        };
+        // the node's own order: the XML writer sorts them when it writes, a reload keeps them as they were
+        const references = node.allReferences().filter(keep);
+        const out = [];
+        for (const reference of references) {
+            if ((0, base_node_impl_js_1.getReferenceType)(reference).browseName.toString() === "HasSubtype" && reference.isForward)
+                continue;
+            out.push({
+                isForward: reference.isForward,
+                referenceType: this.t(reference.referenceType),
+                nodeId: this.t(reference.nodeId)
+            });
+        }
+        return out;
+    }
+    parentOf(node) {
+        if (node instanceof ua_variable_impl_js_1.UAVariableImpl || node instanceof ua_method_impl_js_1.UAMethodImpl || node instanceof ua_object_impl_js_1.UAObjectImpl) {
+            return node.parent;
+        }
+        return null;
+    }
+    /** what `dumpCommonAttributes` and `dumpCommonElements` write, for every class */
+    common(node) {
+        const record = {
+            kind: "node",
+            nodeClass: node.nodeClass,
+            nodeId: this.t(node.nodeId),
+            browseName: this.tq(node.browseName),
+            references: this.referencesOf(node)
+        };
+        const parentNode = this.parentOf(node);
+        if (parentNode && parentNode.nodeId.namespace <= node.nodeId.namespace) {
+            record.parentNodeId = this.t(parentNode.nodeId);
+        }
+        if (Object.hasOwn(node, "symbolicName")) {
+            const symbolicName = node.symbolicName;
+            if (symbolicName)
+                record.symbolicName = symbolicName;
+        }
+        if (Object.hasOwn(node, "isAbstract") && node.isAbstract) {
+            record.isAbstract = true;
+        }
+        if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
+            const variable = node;
+            if (variable.accessLevel !== currentReadFlag)
+                record.accessLevel = variable.accessLevel.toString();
+            if (variable.userAccessLevel !== undefined && variable.userAccessLevel !== variable.accessLevel) {
+                record.userAccessLevel = variable.userAccessLevel.toString();
+            }
+        }
+        if (node.accessRestrictions !== undefined)
+            record.accessRestrictions = node.accessRestrictions.toString();
+        if (node.rolePermissions !== undefined && node.rolePermissions.length === 0)
+            record.hasNoPermissions = true;
+        if (Object.hasOwn(node, "minimumSamplingInterval")) {
+            const minimumSamplingInterval = node.minimumSamplingInterval;
+            if (minimumSamplingInterval > 0)
+                record.minimumSamplingInterval = minimumSamplingInterval;
+        }
+        if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable && node.historizing)
+            record.historizing = true;
+        if (node.displayName?.[0])
+            record.displayName = node.displayName[0].text || "";
+        if (node.description?.text?.length)
+            record.description = node.description.text;
+        if (node.rolePermissions && node.rolePermissions.length > 0) {
+            record.rolePermissions = node.rolePermissions.map((p) => ({ roleId: this.t(p.roleId), permissions: p.permissions }));
+        }
+        return record;
+    }
+    // #endregion
+    // #region the walk
+    markVisited(node) {
+        const k = this.hash(node);
+        if (this.visited.has(k))
+            throw new NodesetExportError(`${node.nodeId.toString()} exported twice`);
+        this.visited.add(k);
+    }
+    dumpNode(node) {
+        switch (node.nodeClass) {
+            case node_opcua_data_model_1.NodeClass.Object:
+                this.dumpObject(node);
+                break;
+            case node_opcua_data_model_1.NodeClass.Variable:
+                this.dumpVariable(node);
+                break;
+            case node_opcua_data_model_1.NodeClass.Method:
+                this.dumpMethod(node);
+                break;
+            case node_opcua_data_model_1.NodeClass.ObjectType:
+                this.dumpObjectType(node);
+                break;
+            case node_opcua_data_model_1.NodeClass.VariableType:
+                this.dumpVariableType(node);
+                break;
+            case node_opcua_data_model_1.NodeClass.DataType:
+                this.dumpDataType(node);
+                break;
+            case node_opcua_data_model_1.NodeClass.ReferenceType:
+                this.dumpReferenceType(node);
+                break;
+            case node_opcua_data_model_1.NodeClass.View:
+                this.dumpView(node);
+                break;
+            default:
+                throw new NodesetExportError(`${node.nodeId.toString()}: unexpected node class ${node.nodeClass}`);
+        }
+    }
+    /** the type definition and the supertype of a node, when they belong to the same namespace and are not out yet */
+    dumpReferencedNodes(node) {
+        const addressSpace = this.addressSpace;
+        const typeDefinitions = node.findReferencesEx("HasTypeDefinition");
+        if (typeDefinitions?.length) {
+            const typeDefinition = reference_impl_js_1.ReferenceImpl.resolveReferenceNode(addressSpace, typeDefinitions[0]);
+            if (!typeDefinition) {
+                warningLog(`dumpReferencedNodes: ${node.browseName.toString()} unknown typeDefinition ${typeDefinitions[0].toString()}`);
+            }
+            else if (typeDefinition.nodeId.namespace === node.nodeId.namespace && !this.visited.has(this.hash(typeDefinition))) {
+                this.dumpNode(typeDefinition);
+            }
+        }
+        const supertypes = node.findReferencesEx("HasSubtype", node_opcua_data_model_1.BrowseDirection.Inverse);
+        if (supertypes?.length) {
+            const supertype = reference_impl_js_1.ReferenceImpl.resolveReferenceNode(addressSpace, supertypes[0]);
+            if (supertype && supertype.nodeId.namespace === node.nodeId.namespace && !this.visited.has(this.hash(supertype))) {
+                this.dumpNode(supertype);
+            }
+        }
+    }
+    dumpAggregates(node) {
+        const aggregates = node.getAggregates().sort(nodeset_to_xml_js_1.sortByBrowseName);
+        for (const aggregate of aggregates.sort(exports.sortByNodeId)) {
+            if (node.nodeId.namespace !== aggregate.nodeId.namespace)
+                continue;
+            if (this.hasHigherPriorityThan(aggregate.nodeId.namespace, node.nodeId.namespace))
+                continue;
+            if (!this.visited.has(this.hash(aggregate)))
+                this.dumpNode(aggregate);
+        }
+    }
+    dumpElementsInFolder(node) {
+        const elements = node
+            .getFolderElements()
+            .sort((x, y) => (x?.browseName.name?.toString() || 0) > (y?.browseName.name?.toString() || 0) ? 1 : -1);
+        for (const element of elements.sort(exports.sortByNodeId)) {
+            // the XML export stops at the first element of another namespace; kept, so that both agree
+            if (node.nodeId.namespace !== element.nodeId.namespace)
+                return;
+            if (!this.visited.has(this.hash(element)))
+                this.dumpNode(element);
+        }
+    }
+    dumpReferenceType(node) {
+        this.markVisited(node);
+        const record = this.common(node);
+        const isSymmetric = !node.inverseName || node.inverseName?.text === node.browseName?.name;
+        if (isSymmetric) {
+            record.symmetric = true;
+        }
+        else {
+            record.inverseName = node.inverseName?.text || "";
+        }
+        this.records.push(record);
+    }
+    dumpDataType(node) {
+        this.markVisited(node);
+        const record = this.common(node);
+        // as the XML: the symbolic name only when it differs from the browse name
+        if (node.symbolicName !== node.browseName.name)
+            record.symbolicName = node.symbolicName;
+        else
+            delete record.symbolicName;
+        if (node.isAbstract)
+            record.isAbstract = true;
+        const definition = this.definitionOf(node);
+        if (definition)
+            record.definition = definition;
+        this.records.push(record);
+        // the encodings, then the aggregates
+        // in the order the references were added, as the XML export always walked them; a record
+        // stream keeps that order in its references, so a reload reproduces it
+        for (const encoding of node.findReferencesExAsObject("HasEncoding", node_opcua_data_model_1.BrowseDirection.Forward)) {
+            if (encoding.nodeClass !== node_opcua_data_model_1.NodeClass.Object)
+                continue;
+            const description = encoding.findReferencesAsObject("HasDescription")[0];
+            if (description)
+                this.dumpVariable(description);
+            this.dumpObjectInner(encoding);
+        }
+        this.dumpAggregates(node);
+    }
+    /** the fields as the XML loader's definition parser shapes them: an absent rank is -1, an absent type BaseDataType */
+    definitionOf(node) {
+        const baseDataType = this.t((0, node_opcua_nodeid_1.resolveNodeId)(node_opcua_constants_1.DataTypeIds.BaseDataType));
+        if (node.isEnumeration()) {
+            const enumDefinition = node.getEnumDefinition();
+            const fields = (enumDefinition.fields || []).map((f) => {
+                const field = { name: f.name, allowSubTypes: false };
+                if (f.description?.text?.length)
+                    field.description = { text: f.description.text };
+                if (!(0, node_opcua_utils_1.isNullOrUndefined)(f.value))
+                    field.value = (0, nodeset_to_xml_js_1.coerceInt64ToInt32)(f.value);
+                field.valueRank = -1;
+                field.dataType = baseDataType;
+                return field;
+            });
+            return { name: this.b(node.browseName), fields };
+        }
+        if (node.isStructure()) {
+            const definition = node.getStructureDefinition();
+            const base = node.subtypeOfObj ? node.subtypeOfObj.getStructureDefinition() : null;
+            const nbFieldsInBase = base ? base.fields?.length || 0 : 0;
+            const fields = [];
+            const all = definition.fields || [];
+            for (let index = nbFieldsInBase; index < all.length; index++) {
+                const f = all[index];
+                const field = {
+                    name: f.name,
+                    allowSubTypes: !!f.allowSubTypes
+                };
+                if (f.description?.text?.length)
+                    field.description = { text: f.description.text };
+                field.valueRank = f.valueRank === undefined || f.valueRank === -1 ? -1 : f.valueRank;
+                if (f.arrayDimensions && f.arrayDimensions.length > 0)
+                    field.arrayDimensions = f.arrayDimensions;
+                if (f.isOptional)
+                    field.isOptional = f.isOptional;
+                if (f.maxStringLength !== undefined && f.maxStringLength !== 0)
+                    field.maxStringLength = f.maxStringLength;
+                field.dataType = f.dataType && !f.dataType.isEmpty() ? this.t(f.dataType) : baseDataType;
+                fields.push(field);
+            }
+            const record = { name: this.b(node.browseName), fields };
+            if (definition.structureType === node_opcua_types_1.StructureType.Union)
+                record.isUnion = true;
+            return record;
+        }
+        return undefined;
+    }
+    dumpVariable(node) {
+        if (this.visited.has(this.hash(node)))
+            return;
+        this.markVisited(node);
+        this.dumpReferencedNodes(node);
+        const record = this.common(node);
+        if (node.valueRank !== -1)
+            record.valueRank = node.valueRank;
+        this.arrayDimensionsOf(node, record);
+        if (this.addressSpace.findNode(node.dataType))
+            record.dataType = this.t(node.dataType);
+        const dataValue = node.$dataValue;
+        if (dataValue?.value && !dataValue.statusCode.equals(node_opcua_status_code_1.StatusCodes.BadWaitingForInitialData)) {
+            const value = this.valueOf(node, dataValue.value);
+            if (value)
+                record.value = value;
+        }
+        this.records.push(record);
+        this.dumpAggregates(node);
+    }
+    dumpVariableType(node) {
+        this.markVisited(node);
+        this.dumpReferencedNodes(node);
+        const record = this.common(node);
+        if (node.valueRank !== -1)
+            record.valueRank = node.valueRank;
+        if (this.addressSpace.findNode(node.dataType))
+            record.dataType = this.t(node.dataType);
+        this.arrayDimensionsOf(node, record);
+        const value = node.value;
+        if (value) {
+            const exported = this.valueOf(node, value);
+            if (exported)
+                record.value = exported;
+        }
+        this.records.push(record);
+        this.dumpAggregates(node);
+    }
+    arrayDimensionsOf(node, record) {
+        if (!node.arrayDimensions)
+            return;
+        if (node.valueRank === -1 || (node.arrayDimensions.length === 1 && node.arrayDimensions[0] === 0))
+            return;
+        record.arrayDimensions = node.arrayDimensions;
+    }
+    dumpObject(node) {
+        this.section(`Object - ${this.b(node.browseName)} {{{{ `);
+        this.dumpObjectInner(node);
+        this.dumpElementsInFolder(node);
+        this.section(`Object - ${this.b(node.browseName)} }}}} `);
+    }
+    dumpObjectInner(node) {
+        this.markVisited(node);
+        this.dumpReferencedNodes(node);
+        const record = this.common(node);
+        if (node.eventNotifier)
+            record.eventNotifier = node.eventNotifier;
+        this.records.push(record);
+        this.dumpAggregates(node);
+    }
+    dumpObjectType(node) {
+        this.section(`ObjectType - ${this.b(node.browseName)} {{{{ `);
+        this.markVisited(node);
+        this.dumpReferencedNodes(node);
+        const record = this.common(node);
+        const eventNotifier = node.eventNotifier;
+        if (eventNotifier)
+            record.eventNotifier = eventNotifier;
+        this.records.push(record);
+        this.dumpAggregates(node);
+        this.section(`ObjectType - ${this.b(node.browseName)} }}}}`);
+    }
+    dumpMethod(node) {
+        this.markVisited(node);
+        this.dumpReferencedNodes(node);
+        const record = this.common(node);
+        if (node.methodDeclarationId)
+            record.methodDeclarationId = this.t(node.methodDeclarationId);
+        this.records.push(record);
+        this.dumpAggregates(node);
+    }
+    dumpView(node) {
+        this.markVisited(node);
+        const record = this.common(node);
+        const view = node;
+        if (view.containsNoLoops)
+            record.containsNoLoops = true;
+        if (view.eventNotifier)
+            record.eventNotifier = view.eventNotifier;
+        this.records.push(record);
+        this.dumpAggregates(node);
+    }
+    /** the data type dictionaries of the namespace, after its data types, as the XML export */
+    dumpDictionaries() {
+        const addressSpace = this.addressSpace;
+        const describe = (typeSystem) => {
+            const nodeToBrowse = new node_opcua_types_1.BrowseDescription({
+                browseDirection: node_opcua_data_model_1.BrowseDirection.Forward,
+                includeSubtypes: false,
+                nodeClassMask: (0, node_opcua_data_model_1.makeNodeClassMask)("Variable"),
+                nodeId: typeSystem.nodeId,
+                referenceTypeId: (0, node_opcua_nodeid_1.resolveNodeId)("HasComponent"),
+                resultMask: (0, node_opcua_data_model_1.makeResultMask)("ReferenceType | IsForward | BrowseName | NodeClass | TypeDefinition")
+            });
+            return typeSystem.browseNode(nodeToBrowse).filter((r) => r.nodeId.namespace === this.namespace.index);
+        };
+        for (const typeSystemId of [node_opcua_constants_1.ObjectIds.OPCBinarySchema_TypeSystem, node_opcua_constants_1.ObjectIds.XmlSchema_TypeSystem]) {
+            const typeSystem = addressSpace.findNode(typeSystemId);
+            if (!typeSystem)
+                continue;
+            const result = describe(typeSystem);
+            if (result.length !== 1)
+                continue;
+            const dictionary = addressSpace.findNode(result[0].nodeId);
+            if (!dictionary)
+                continue;
+            this.section(typeSystemId === node_opcua_constants_1.ObjectIds.OPCBinarySchema_TypeSystem ? "DataSystem - Binary" : "DataSystem - Xml");
+            for (const component of dictionary.getComponents()) {
+                if (!this.visited.has(this.hash(component)))
+                    this.dumpNode(component);
+            }
+            if (!this.visited.has(this.hash(dictionary)))
+                this.dumpNode(dictionary);
+        }
+    }
+    // #endregion
+    // #region values
+    valueOf(node, variant) {
+        if (!(variant instanceof node_opcua_variant_1.Variant))
+            return undefined;
+        if (variant.dataType === node_opcua_variant_1.DataType.Null)
+            return undefined;
+        if (!this.addressSpace.findDataType(node.dataType))
+            return undefined;
+        if ((0, nodeset_to_xml_js_1._isDefaultValue)(variant))
+            return undefined;
+        const element = (v) => this.elementOf(node, variant.dataType, v);
+        const out = { dataType: variant.dataType, arrayType: variant.arrayType };
+        if (variant.arrayType === node_opcua_variant_1.VariantArrayType.Scalar) {
+            out.value = element(variant.value);
+        }
+        else {
+            out.value = Array.from(variant.value, element);
+            if (variant.arrayType === node_opcua_variant_1.VariantArrayType.Matrix)
+                out.dimensions = variant.dimensions;
+        }
+        return out;
+    }
+    elementOf(node, dataType, value) {
+        if (value === null || value === undefined)
+            return null;
+        switch (dataType) {
+            case node_opcua_variant_1.DataType.NodeId:
+            case node_opcua_variant_1.DataType.ExpandedNodeId:
+                return value instanceof node_opcua_nodeid_1.NodeId ? this.t(value) : value;
+            case node_opcua_variant_1.DataType.QualifiedName:
+                return value instanceof node_opcua_data_model_1.QualifiedName ? this.tq(value) : value;
+            case node_opcua_variant_1.DataType.LocalizedText: {
+                const text = value;
+                return new node_opcua_data_model_1.LocalizedText({ locale: text.locale ?? undefined, text: text.text ?? undefined });
+            }
+            case node_opcua_variant_1.DataType.ExtensionObject:
+                return this.extensionObjectOf(node, value);
+            case node_opcua_variant_1.DataType.Variant: {
+                const inner = value;
+                return new node_opcua_variant_1.Variant(this.valueOf(node, inner) ?? { dataType: node_opcua_variant_1.DataType.Null });
+            }
+            default:
+                return value;
+        }
+    }
+    /** the four types the XML reader decodes itself travel as instances; every other one as the XML body the reader would capture */
+    extensionObjectOf(node, value) {
+        if (value instanceof node_opcua_types_1.Argument) {
+            const argument = new node_opcua_types_1.Argument({});
+            argument.name = value.name;
+            argument.dataType = this.t(value.dataType);
+            argument.valueRank = value.valueRank;
+            // an empty list and null say the same thing; a stored value comes back as null
+            argument.arrayDimensions =
+                value.arrayDimensions && value.arrayDimensions.length > 0 ? [...value.arrayDimensions] : null;
+            argument.description = new node_opcua_data_model_1.LocalizedText({
+                locale: value.description?.locale ?? undefined,
+                text: value.description?.text ?? undefined
+            });
+            return argument;
+        }
+        if (value instanceof node_opcua_types_1.EUInformation) {
+            return new node_opcua_types_1.EUInformation({
+                namespaceUri: value.namespaceUri,
+                unitId: value.unitId,
+                displayName: new node_opcua_data_model_1.LocalizedText({
+                    locale: value.displayName?.locale ?? undefined,
+                    text: value.displayName?.text ?? undefined
+                }),
+                description: new node_opcua_data_model_1.LocalizedText({
+                    locale: value.description?.locale ?? undefined,
+                    text: value.description?.text ?? undefined
+                })
+            });
+        }
+        if (value instanceof node_opcua_data_access_1.Range) {
+            const range = new node_opcua_data_access_1.Range({});
+            range.low = value.low;
+            range.high = value.high;
+            return range;
+        }
+        if (value instanceof node_opcua_types_1.EnumValueType) {
+            return new node_opcua_types_1.EnumValueType({
+                value: (0, node_opcua_basic_types_1.coerceInt64)(value.value),
+                displayName: new node_opcua_data_model_1.LocalizedText({
+                    locale: value.displayName?.locale ?? undefined,
+                    text: value.displayName?.text ?? undefined
+                }),
+                description: new node_opcua_data_model_1.LocalizedText({
+                    locale: value.description?.locale ?? undefined,
+                    text: value.description?.text ?? undefined
+                })
+            });
+        }
+        const schema = value.schema;
+        const dataTypeNode = schema?.dataTypeNodeId ? this.addressSpace.findDataType(schema.dataTypeNodeId) : null;
+        if (!dataTypeNode) {
+            throw new NodesetExportError(`${node.nodeId.toString()}: the value holds a ${schema?.name ?? value.constructor.name} whose data type is not in the address space`);
+        }
+        const encodingDefaultXml = schema.encodingDefaultXml;
+        if (!encodingDefaultXml || encodingDefaultXml.isEmpty()) {
+            throw new NodesetExportError(`${node.nodeId.toString()}: ${schema.name} has no XML encoding`);
+        }
+        const xw = new xml_writer_1.default(false);
+        xw.translationTable = this.translationTable;
+        xw.priorityTable = this.priorityTable;
+        xw.visitedNode = new Set();
+        (0, nodeset_to_xml_js_1.initXmlWriterEx)(xw, { ...this.namespacesMap }, this.namespaceArray);
+        const { name, definition } = this.definitionMap.findDefinition(dataTypeNode.nodeId);
+        (0, nodeset_to_xml_js_1._dumpVariantExtensionObjectValue_Body)(xw, this.definitionMap, name, definition, this.addressSpace, value);
+        return new nodeset_record_js_1.XmlExtensionObjectFragment(this.t(encodingDefaultXml), xw.toString());
+    }
+}
+/** the records of a namespace with the comment markers the XML export places between them */
+function namespaceToWalkEvents(namespace) {
+    return new RecordExporter(namespace).run();
+}
+/**
+ * the walk from one node: the node, its type definition and supertype when they belong to the
+ * same namespace and are not out yet, its aggregates after it; with the namespace table the
+ * events' ids are in
+ */
+function nodeToWalkEvents(node) {
+    const exporter = new RecordExporter(node.namespace);
+    return { events: exporter.walkFrom(node), translationTable: exporter.translation };
+}
+/** the records of a namespace; see {@link ToNodesetRecordsOptions} */
+function namespaceToRecords(namespace, _options = {}) {
+    return namespaceToWalkEvents(namespace).filter((event) => event.kind !== "section");
+}
+/** the sha256 of the lines the digest covers, hex */
+const sha256 = (text) => (0, nodeset_source_js_1.sha256Hex)(new TextEncoder().encode(text));
+/**
+ * the precompiled image of a namespace: the records, JSON Lines, gzip; the trailer digest is the
+ * SHA-256 of the node lines, so that a re-import keys on the content and not on a file that does
+ * not exist
+ */
+async function namespaceToImage(namespace, options = {}) {
+    const writer = new nodeset_image_js_1.NodesetImageWriter({ ...options });
+    for (const record of namespaceToRecords(namespace)) {
+        writer.apply(record);
+    }
+    return writer.finish(await sha256(writer.bodyText()));
+}
+namespace_impl_js_1.NamespaceImpl.prototype.toNodesetRecords = function (options) {
+    return namespaceToRecords(this, options);
+};
+namespace_impl_js_1.NamespaceImpl.prototype.toNodesetImage = function (options) {
+    return namespaceToImage(this, options);
+};
+//# sourceMappingURL=nodeset_to_records.js.map