node-opcua-address-space 2.180.0 → 2.181.0

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -1,375 +0,0 @@
-import type { IAddressSpace, INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
-import assert from "node-opcua-assert";
-import { DataType } from "node-opcua-basic-types";
-import { NodeClass } from "node-opcua-data-model";
-import { make_debugLog, make_warningLog } from "node-opcua-debug";
-import type { ExtensionObject } from "node-opcua-extension-object";
-import type { StructureField } from "node-opcua-types";
-import { Variant } from "node-opcua-variant";
-import type { TranslationTable } from "../../source/xml_writer";
-import { type BaseNodeImpl, getReferenceType } from "../base_node_impl";
-import type { NamespacePrivate } from "../namespace_private";
-import type { UAVariableImpl } from "../ua_variable_impl";
-
-const warningLog = make_warningLog(__filename);
-const _debugLog = make_debugLog(__filename);
-
-interface RequiredModel {
-    requiredNamespaceIndexes: number[];
-    nbTypes: number;
-}
-export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?: Map<number, RequiredModel>): RequiredModel {
-    if (namespace.index === 0) {
-        return { requiredNamespaceIndexes: [], nbTypes: 1 };
-    }
-    if (cache) {
-        if (cache.has(namespace.index)) {
-            return cache.get(namespace.index) as RequiredModel;
-        }
-    }
-    const requiredNamespaceIndexes = [0];
-    const requiredModelsSet = new Set<number>();
-    requiredModelsSet.add(0);
-    const namespace_ = namespace as NamespacePrivate;
-    let nbTypes = 0;
-    const addressSpace = namespace.addressSpace;
-    const types = [NodeClass.VariableType, NodeClass.ObjectType, NodeClass.ReferenceType, NodeClass.DataType];
-    const instances = [NodeClass.Variable, NodeClass.Object, NodeClass.Method];
-
-    const consider = (requiredModel: number) => {
-        if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
-            requiredModelsSet.add(requiredModel);
-            requiredNamespaceIndexes.push(requiredModel);
-        }
-    };
-
-    const _visitedDataType: Set<string> = new Set<string>();
-
-    function exploreDataTypeField(field: StructureField) {
-        const dataType = field.dataType;
-        const namespaceIndex = dataType.namespace;
-        consider(namespaceIndex);
-        const dataTypeNode = addressSpace.findDataType(field.dataType);
-        if (dataTypeNode) {
-            exploreDataTypes(dataTypeNode);
-        }
-    }
-    function exploreDataTypes(dataTypeNode: UADataType): void {
-        if (!dataTypeNode) {
-            return;
-        }
-        const dataType = dataTypeNode.nodeId;
-        if (_visitedDataType.has(dataType.toString())) {
-            return;
-        }
-        // c8 ignore next
-        if (dataTypeNode.nodeClass !== NodeClass.DataType) {
-            warningLog("exploreDataTypes! ignoring ", dataTypeNode.toString());
-            return;
-        }
-
-        const namespaceIndex = dataType.namespace;
-        consider(namespaceIndex);
-        // mark the dataType as visited *before* exploring its fields: a structure may refer to
-        // itself (directly or through a cycle), and marking it afterwards would recurse forever
-        _visitedDataType.add(dataType.toString());
-        if (dataTypeNode.isStructure()) {
-            const definition = dataTypeNode.getStructureDefinition();
-            for (const field of definition.fields || []) {
-                exploreDataTypeField(field);
-            }
-        }
-    }
-
-    function exploreExtensionObject(e: ExtensionObject) {
-        assert(!(e instanceof Variant));
-        const nodeId = e.schema.encodingDefaultXml || e.schema.dataTypeNodeId || e.schema.dataTypeNodeId;
-        consider(nodeId.namespace);
-        // c8 ignore next
-        if (e.schema.dataTypeNodeId.isEmpty()) {
-            warningLog("Cannot find dataTypeNodeId for ", e.schema.name);
-        }
-        const d = addressSpace.findNode(e.schema.dataTypeNodeId) as UADataType | null;
-        // c8 ignore next
-        if (!d) return;
-        exploreDataTypes(d);
-    }
-
-    function exploreDataValue(uaVariable: UAVariableImpl) {
-        if (uaVariable.getBasicDataType() !== DataType.ExtensionObject) {
-            return;
-        }
-        if (!uaVariable.$dataValue) return;
-        const variant = uaVariable.$dataValue.value;
-        if (!variant) return;
-        const value: unknown = variant.value;
-        if (!value) return;
-        if (Array.isArray(value)) {
-            (value as ExtensionObject[]).forEach(exploreExtensionObject);
-        } else {
-            exploreExtensionObject(value as ExtensionObject);
-        }
-    }
-    for (const node of namespace_.nodeIterator()) {
-        const isType = types.indexOf(node.nodeClass);
-        const isInstance = instances.indexOf(node.nodeClass);
-        if (isType !== -1) {
-            nbTypes++;
-            const superTypes = node.findReferencesAsObject("HasSubtype", false);
-            if (superTypes.length === 0) {
-                continue;
-            }
-            if (superTypes.length !== 1) {
-                continue;
-            }
-            const superType = superTypes[0];
-            if (superType.nodeId.namespace === 0) {
-                continue;
-            }
-            const requiredModel = superType.nodeId.namespace;
-            consider(requiredModel);
-        } else if (isInstance !== -1) {
-            if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
-                const dataTypeNodeId = (node as UAVariable | UAVariableType).dataType;
-                const dataTypeNode = addressSpace.findDataType(dataTypeNodeId);
-                if (dataTypeNode) {
-                    consider(dataTypeNode.nodeId.namespace);
-                } else {
-                    // c8 ignore next
-                    if (dataTypeNodeId.value !== 0) {
-                        warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
-                    }
-                }
-                const nodeV = node as UAVariableImpl;
-                exploreDataValue(nodeV);
-            }
-
-            const typeDefinitions = node.findReferencesAsObject("HasTypeDefinition", true);
-            if (typeDefinitions.length === 0) {
-                continue;
-            }
-            if (typeDefinitions.length !== 1) {
-                continue;
-            }
-            const typeDefinition = typeDefinitions[0];
-            const requiredModel = typeDefinition.nodeId.namespace;
-            consider(requiredModel);
-        }
-    }
-
-    const result: RequiredModel = { requiredNamespaceIndexes: requiredNamespaceIndexes, nbTypes: nbTypes };
-    if (cache) {
-        cache.set(namespace.index, result);
-    }
-    return result;
-}
-
-export function _recomputeRequiredModelsFromTypes2(namespace: INamespace, cache?: Map<number, RequiredModel>): RequiredModel {
-    const addressSpace = namespace.addressSpace;
-
-    const { requiredNamespaceIndexes } = _recomputeRequiredModelsFromTypes(namespace, cache);
-
-    const set = new Set<number>(requiredNamespaceIndexes);
-    const pass2: number[] = [];
-    for (const r of requiredNamespaceIndexes) {
-        if (r === 0) {
-            pass2.push(0);
-            continue;
-        }
-        const namespaces = _recomputeRequiredModelsFromTypes(addressSpace.getNamespace(r), cache);
-        for (const nIndex of namespaces.requiredNamespaceIndexes) {
-            if (!set.has(nIndex)) {
-                set.add(nIndex);
-                pass2.push(nIndex);
-            }
-        }
-        pass2.push(r);
-    }
-
-    return { requiredNamespaceIndexes: pass2, nbTypes: 0 };
-}
-
-export function _getCompleteRequiredModelsFromValuesAndReferences(
-    namespace: INamespace,
-    priorityList: number[],
-    cache?: Map<number, RequiredModel>
-): number[] {
-    const namespace_ = namespace as NamespacePrivate;
-
-    const thisPriority = priorityList[namespace.index];
-
-    const requiredNamespaceIndexes = _recomputeRequiredModelsFromTypes2(namespace, cache).requiredNamespaceIndexes;
-    const requiredModelsSet: Set<number> = new Set<number>([...requiredNamespaceIndexes]);
-
-    const consider = (requiredModel: number) => {
-        if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
-            requiredModelsSet.add(requiredModel);
-            requiredNamespaceIndexes.push(requiredModel);
-        }
-    };
-
-    const addressSpace = namespace.addressSpace;
-    const nonHierarchicalReferencesType = addressSpace.findReferenceType("NonHierarchicalReferences");
-
-    //const maxIndex = Math.max(...requiredNamespaceIndexes);
-    for (const node of namespace_.nodeIterator()) {
-        const references = (<BaseNodeImpl>node).allReferences();
-        for (const reference of references) {
-            // check referenceId
-            const namespaceIndexOfReferenceType = getReferenceType(reference)?.nodeId.namespace;
-            if (namespaceIndexOfReferenceType !== 0 && namespaceIndexOfReferenceType !== namespace.index) {
-                const refPriority = priorityList[namespaceIndexOfReferenceType];
-                if (refPriority <= thisPriority) {
-                    consider(namespaceIndexOfReferenceType);
-                }
-            }
-            const namespaceIndexOfTargetNode = reference.nodeId.namespace;
-            if (namespaceIndexOfTargetNode !== 0 && namespaceIndexOfTargetNode !== namespace.index) {
-                const refPriority = priorityList[namespaceIndexOfTargetNode];
-                if (refPriority <= thisPriority) {
-                    consider(namespaceIndexOfTargetNode);
-                } else {
-                    const referenceType = getReferenceType(reference);
-                    if (referenceType) {
-                        // For forward NonHierarchicalReferences (e.g. HasInterface),
-                        // always include the target namespace as a dependency
-                        // regardless of priority, since the current node owns
-                        // this relationship.
-                        if (
-                            reference.isForward &&
-                            nonHierarchicalReferencesType &&
-                            referenceType.isSubtypeOf(nonHierarchicalReferencesType)
-                        ) {
-                            consider(namespaceIndexOfTargetNode);
-                        }
-                        // For inverse HierarchicalReferences (e.g. Organizes),
-                        // always include the target namespace as a dependency
-                        // regardless of priority, since the reference is
-                        // stored on this node (organizedBy pattern).
-                        const hierarchicalReferencesType = addressSpace.findReferenceType("HierarchicalReferences");
-                        if (
-                            !reference.isForward &&
-                            hierarchicalReferencesType &&
-                            referenceType.isSubtypeOf(hierarchicalReferencesType)
-                        ) {
-                            consider(namespaceIndexOfTargetNode);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return requiredNamespaceIndexes;
-}
-
-/**
- *
- * @param namespace
- * @returns the order
- *
- *      ---
- *  ua, own , di  => 0 , 2,  1
- *
- *      ---
- *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3, 1
- *
- *                           ---
- *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3,  5, 1
- */
-export function constructNamespacePriorityTable(addressSpace: IAddressSpace): { loadingOrder: number[]; priorityTable: number[] } {
-    // - Namespace 0 will always be 0
-    // - Namespace with requiredModels are considered to be companion specification,
-    //   so RequireModel will be used to determine the order
-    // - Namespaces with no requiredModel are more complicated:
-    //
-    //   we study ObjectType,ReferenceType, DataType and VariableType
-    //   to find strong dependencies between namespace.
-    //
-    //   if the namespace doesn't define ObjectType,ReferenceType, DataType and VariableType
-    //   it will be considered as instance namespaces and will added at the end
-    //   in the same order as they appear,
-    const namespaces = addressSpace.getNamespaceArray();
-
-    const loadingOrder: number[] = [0];
-
-    const map = new Map<number, { nbTypes: number; requiredNamespaceIndexes: number[]; namespace: INamespace }>();
-    for (let i = 0; i < namespaces.length; i++) {
-        const { nbTypes, requiredNamespaceIndexes } = _recomputeRequiredModelsFromTypes(namespaces[i], map);
-        map.set(namespaces[i].index, { nbTypes, requiredNamespaceIndexes, namespace: namespaces[i] });
-    }
-
-    const visited = new Set<number>();
-    visited.add(0);
-
-    const h = (n: INamespace) => {
-        if (visited.has(n.index)) {
-            return;
-        }
-        visited.add(n.index);
-        const data = map.get(n.index);
-        if (!data) return;
-        const { requiredNamespaceIndexes } = data;
-        for (const r of requiredNamespaceIndexes || []) {
-            h(namespaces[r]);
-        }
-        loadingOrder.push(n.index);
-    };
-
-    for (let i = 0; i < namespaces.length; i++) {
-        const entry = map.get(i);
-        if (entry?.nbTypes) {
-            h(namespaces[i]);
-        }
-    }
-    for (let i = 0; i < namespaces.length; i++) {
-        const entry = map.get(i);
-        if (!entry?.nbTypes) {
-            h(namespaces[i]);
-        }
-    }
-
-    const priorityTable: number[] = [];
-    for (let i = 0; i < loadingOrder.length; i++) {
-        const namespaceIndex = loadingOrder[i];
-        assert(namespaceIndex !== -1);
-        priorityTable[namespaceIndex] = i;
-    }
-
-    return { loadingOrder, priorityTable };
-}
-
-const _doDebug = false;
-export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
-    const addressSpace = namespace.addressSpace;
-    priorityTable = priorityTable || constructNamespacePriorityTable(addressSpace).priorityTable;
-    const requiredNamespaceIndexes = _getCompleteRequiredModelsFromValuesAndReferences(namespace, priorityTable);
-    return [...requiredNamespaceIndexes.map((r) => addressSpace.getNamespace(r)), namespace];
-}
-
-/**
- * @private
- */
-export function _constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): TranslationTable {
-    const translationTable: TranslationTable = new Map();
-    if (!dependency || dependency.length === 0) {
-        translationTable.set(0, 0);
-        return translationTable;
-        // throw new Error("Cannot constructNamespaceTranslationTable on empty dependency");
-    }
-    assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
-
-    let counter = 0;
-    translationTable.set(dependency[0].index, counter++);
-    //
-    if (exportedNamespace) {
-        translationTable.set(exportedNamespace.index, counter++);
-    }
-    for (let i = 1; i < dependency.length; i++) {
-        const dep = dependency[i];
-        if (exportedNamespace && exportedNamespace === dep) {
-            continue;
-        }
-        translationTable.set(dep.index, counter++);
-    }
-    return translationTable;
-}

package/src/nodeset_tools/dump_to_bsd.ts

@@ -1,201 +0,0 @@
-import type { IAddressSpace, INamespace, UADataType } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import { type INodeId, NodeId, NodeIdType } from "node-opcua-nodeid";
-import { EnumDefinition, StructureDefinition } from "node-opcua-types";
-import type { XmlWriter } from "../../source/xml_writer";
-import type { AddressSpacePrivate } from "../address_space_private";
-import type { NamespacePrivate } from "../namespace_private";
-import { constructNamespaceDependency } from "./construct_namespace_dependency";
-
-const XMLWriter = require("xml-writer");
-
-function dumpEnumeratedType(xw: XmlWriter, e: EnumDefinition, name: string): void {
-    xw.startElement("opc:EnumeratedType");
-    xw.writeAttribute("Name", name);
-    xw.writeAttribute("LengthInBits", "32");
-    for (const f of e.fields || []) {
-        xw.startElement("opc:EnumeratedValue");
-        xw.writeAttribute("Name", f.name || "");
-        assert(f.value[0] === 0, "unsupported 64 bit value !");
-        xw.writeAttribute("Value", f.value[1].toString());
-        xw.endElement();
-    }
-    xw.endElement();
-}
-function buildXmlName(addressSpace: AddressSpacePrivate, map: Map<number, string>, nodeId: NodeId): string {
-    if (NodeId.sameNodeId(nodeId, NodeId.nullNodeId)) {
-        return "ua:ExtensionObject";
-    }
-    const node = addressSpace.findNode(nodeId);
-    // c8 ignore next
-    if (!node) {
-        throw new Error(`Cannot find Node for${nodeId?.toString()}`);
-    }
-    const typeName = node.browseName.name || "";
-
-    const n = node.nodeId as INodeId;
-    const prefix =
-        n.identifierType === NodeIdType.NUMERIC && n.namespace === 0
-            ? n.value <= 15
-                ? "opc"
-                : "ua"
-            : map.get(node.nodeId.namespace);
-    return `${prefix}:${typeName === "Structure" && prefix === "ua" ? "ExtensionObject" : typeName}`;
-}
-
-function dumpDataTypeStructure(
-    xw: XmlWriter,
-    addressSpace: IAddressSpace,
-    map: Map<number, string>,
-    structureDefinition: StructureDefinition,
-    structureDefinitionBase: StructureDefinition | undefined | null,
-    name: string,
-    doc?: string
-): void {
-    xw.startElement("opc:StructuredType");
-    xw.writeAttribute("Name", name);
-    xw.writeAttribute("BaseType", buildXmlName(addressSpace as AddressSpacePrivate, map, structureDefinition.baseDataType));
-
-    if (doc) {
-        xw.startElement("opc:Documentation");
-        xw.text(doc);
-        xw.endElement();
-    }
-
-    const fields = structureDefinition.fields || [];
-    // get base class
-    const nbFieldsInBase = structureDefinitionBase ? structureDefinitionBase.fields?.length || 0 : 0;
-
-    let optionalsCount = 0;
-    for (let index = nbFieldsInBase; index < fields.length; index++) {
-        const f = fields[index];
-        if (f.isOptional) {
-            xw.startElement("opc:Field");
-            xw.writeAttribute("Name", `${f.name}Specified`);
-            xw.writeAttribute("TypeName", "opc:Bit");
-            xw.endElement();
-            optionalsCount++;
-        }
-    }
-
-    // c8 ignore next
-    if (optionalsCount >= 32) {
-        throw new Error("Too many optionals fields");
-    }
-
-    if (optionalsCount) {
-        /*
-                const padding = optionalsCount <= 8
-                    ? (8 - optionalsCount)
-                    : (optionalsCount <= 16)
-                        ? (16 - optionalsCount)
-                        : (32 - optionalsCount)
-                    ;
-        */
-        const padding = 32 - optionalsCount;
-        if (padding !== 0) {
-            xw.startElement("opc:Field");
-            xw.writeAttribute("Name", "Reserved1");
-            xw.writeAttribute("TypeName", "opc:Bit");
-            xw.writeAttribute("Length", padding.toString());
-            xw.endElement();
-        }
-    }
-    for (let index = nbFieldsInBase; index < fields.length; index++) {
-        const f = fields[index];
-
-        const isArray = f.valueRank > 0 && f.arrayDimensions?.length;
-
-        if (isArray) {
-            xw.startElement("opc:Field");
-            xw.writeAttribute("Name", `NoOf${f.name || ""}`);
-            xw.writeAttribute("TypeName", "opc:Int32");
-            if (f.isOptional) {
-                xw.writeAttribute("SwitchField", `${f.name}Specified`);
-            }
-            xw.endElement();
-        }
-
-        xw.startElement("opc:Field");
-        xw.writeAttribute("Name", f.name || "");
-
-        const typeName = buildXmlName(addressSpace as AddressSpacePrivate, map, f.dataType);
-        xw.writeAttribute("TypeName", typeName);
-        if (isArray) {
-            xw.writeAttribute("LengthField", `NoOf${f.name || ""}`);
-        }
-        if (f.isOptional) {
-            xw.writeAttribute("SwitchField", `${f.name || ""}Specified`);
-        }
-        xw.endElement();
-    }
-    xw.endElement();
-}
-
-function dumpDataTypeToBSD(xw: XmlWriter, dataType: UADataType, map: Map<number, string>) {
-    const addressSpace = dataType.addressSpace;
-
-    const name: string = dataType.browseName.name || "";
-
-    const definition = dataType.getDefinition();
-    if (definition instanceof StructureDefinition) {
-        const structureDefinitionBase = dataType.subtypeOfObj?.getStructureDefinition();
-        dumpDataTypeStructure(xw, addressSpace, map, definition, structureDefinitionBase, name);
-    }
-    if (definition instanceof EnumDefinition) {
-        dumpEnumeratedType(xw, definition, name);
-    }
-}
-
-function shortcut(namespace: INamespace) {
-    return `n${namespace.index}`;
-}
-export function dumpToBSD(namespace: NamespacePrivate): string {
-    const dependency: INamespace[] = constructNamespaceDependency(namespace);
-
-    const _addressSpace = namespace.addressSpace;
-
-    const xw: XmlWriter = new XMLWriter(true);
-
-    //xx xw.startDocument():// { encoding: "utf-8", version: "1.0" });
-
-    xw.startElement("opc:TypeDictionary");
-
-    xw.writeAttribute("xmlns:opc", "http://opcfoundation.org/BinarySchema/");
-    xw.writeAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
-    xw.writeAttribute("xmlns:ua", "http://opcfoundation.org/UA/");
-    xw.writeAttribute("xmlns:tns", namespace.namespaceUri);
-
-    const map: Map<number, string> = new Map();
-
-    map.set(namespace.index, "tns");
-
-    for (const dependantNamespace of dependency) {
-        const namespaceIndex = dependantNamespace.index;
-        if (namespaceIndex === 0 || namespaceIndex === namespace.index) {
-            continue;
-        }
-        const ns = shortcut(dependantNamespace);
-        map.set(namespaceIndex, ns);
-        xw.writeAttribute(`xmlns:${ns}`, dependantNamespace.namespaceUri);
-    }
-
-    xw.writeAttribute("DefaultByteOrder", "LittleEndian");
-    xw.writeAttribute("TargetNamespace", namespace.namespaceUri);
-
-    // <opc:Import Namespace="http://opcfoundation.org/UA/"/>
-    for (const dependantNamespace of dependency) {
-        if (dependantNamespace.index === namespace.index) {
-            continue;
-        }
-        xw.startElement("opc:Import").writeAttribute("Namespace", dependantNamespace.namespaceUri).endElement();
-    }
-    //
-    for (const dataType of namespace._dataTypeIterator()) {
-        dumpDataTypeToBSD(xw, dataType, map);
-    }
-    xw.endElement();
-    //    xw.endDocument();
-
-    return xw.toString();
-}