node-opcua-address-space 2.76.2 → 2.78.0

package/source/loader/generateAddressSpaceRaw.ts

@@ -3,7 +3,7 @@ import { CallbackT } from "node-opcua-status-code";
 import { IAddressSpace } from "node-opcua-address-space-base";
 
 import { adjustNamespaceArray } from "../../src/nodeset_tools/adjust_namespace_array";
-import { NodeSetLoader } from "./load_nodeset2";
+import { NodeSetLoader, NodeSetLoaderOptions } from "./load_nodeset2";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
@@ -17,9 +17,10 @@ const errorLog = make_errorLog(__filename);
 export async function generateAddressSpaceRaw(
     addressSpace: IAddressSpace,
     xmlFiles: string | string[],
-    xmlLoader: (nodeset2xmlUri: string) => Promise<string>
+    xmlLoader: (nodeset2xmlUri: string) => Promise<string>,
+    options: NodeSetLoaderOptions
 ): Promise<void> {
-    const nodesetLoader = new NodeSetLoader(addressSpace);
+    const nodesetLoader = new NodeSetLoader(addressSpace, options);
 
     if (!Array.isArray(xmlFiles)) {
         xmlFiles = [xmlFiles];

package/source/loader/load_nodeset2.ts

@@ -110,7 +110,7 @@ function makeDefaultVariant(addressSpace: IAddressSpace, dataTypeNode: NodeId, v
         }
         const dv = builtInType.defaultValue;
         const value = typeof dv === "function" ? dv() : dv;
- 
+
         let arrayType: VariantArrayType;
         /*
          *  * n > 1                     : the Value is an array with the specified number of dimensions.
@@ -145,11 +145,15 @@ export interface NodeSet2ParserEngine {
     terminate: (callback: SimpleCallback) => void;
 }
 
-export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2ParserEngine {
+function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLoaderOptions): NodeSet2ParserEngine {
     const addressSpace1 = addressSpace as AddressSpacePrivate;
     addressSpace1.suspendBackReference = true;
 
+    options.loadDeprecatedNodes = options.loadDeprecatedNodes === undefined ? true:  options.loadDeprecatedNodes;
+    options.loadDraftNodes = options.loadDraftNodes || false;
+    
     const postTasks: Task[] = [];
+    const postTasks0_InitializeVariable: Task[] = [];
     const postTasks0_DecodePojoString: Task[] = [];
     const postTasks1_InitializeVariable: Task[] = [];
     const postTasks2_AssignedExtensionObjectToDataValue: Task[] = [];
@@ -171,6 +175,7 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
     let namespaceCounter = 0;
     let found_namespace_in_uri: { [key: string]: NamespacePrivate } = {};
     let models: Model[] = [];
+    let performedCalled = false;
 
     function _reset_namespace_translation() {
         debugLog("_reset_namespace_translation");
@@ -179,6 +184,7 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
         namespaceCounter = 0;
         alias_map = {};
         models = [];
+        performedCalled = false;
     }
 
     function _translateNamespaceIndex(innerIndex: number) {
@@ -186,9 +192,9 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
 
         // istanbul ignore next
         if (namespaceIndex === undefined) {
-            // tslint:disable-next-line: no-console
             debugLog("Warning: namespace_uri_translation = ", namespace_uri_translation);
-            throw new Error("_translateNamespaceIndex! Cannot find namespace definition for index " + innerIndex);
+            errorLog("namespace_uri_translation", namespace_uri_translation);
+            throw new Error("_translateNamespaceIndex() ! Cannot find namespace definition for index " + innerIndex);
         }
         return namespaceIndex;
     }
@@ -213,9 +219,9 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
         return namespace.internalCreateNode(params) as BaseNode;
     }
 
-    function _register_namespace_uri_in_translation_table(namespaceUri: string): NamespacePrivate {
+    function _register_namespace_uri_in_translation_table(namespaceUri: string): void {
         if (found_namespace_in_uri[namespaceUri]) {
-            return found_namespace_in_uri[namespaceUri];
+            return;
         }
         const namespace = addressSpace1.getNamespace(namespaceUri);
         if (!namespace) {
@@ -240,7 +246,6 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
                 " index in addressSpace",
                 namespace.index
             );
-        return namespace;
     }
 
     function _add_namespace(model: Model) {
@@ -384,6 +389,8 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
 
     const state_UAObject = {
         init(this: any, name: string, attrs: XmlAttributes) {
+            _perform();
+
             this.obj = {};
             this.obj.nodeClass = NodeClass.Object;
             this.obj.isAbstract = ec.coerceBoolean(attrs.IsAbstract);
@@ -393,12 +400,10 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
             this.obj.symbolicName = attrs.SymbolicName || null;
 
             this.isDraft = attrs.ReleaseStatus === "Draft";
-            this.obj.isDeprecated = attrs.ReleaseStatus === "Deprecated";
+            this.isDeprecated = attrs.ReleaseStatus === "Deprecated";
         },
         finish(this: any) {
-            if (this.isDraft || this.isDeprecated) {
-                // ignore Draft or Deprecated element
-                debugLog("Ignoring Draft/Deprecated UAObject =", this.obj.browseName.toString());
+            if (canIngore({ isDraft: this.isDraft, isDeprecated: this.isDeprecated }, this.obj)) {
                 return;
             }
             _internal_createNode(this.obj);
@@ -422,6 +427,8 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
 
     const state_UAObjectType = {
         init(this: any, name: string, attrs: XmlAttributes) {
+            _perform();
+
             this.obj = {};
             this.obj.nodeClass = NodeClass.ObjectType;
             this.obj.isAbstract = ec.coerceBoolean(attrs.IsAbstract);
@@ -451,6 +458,8 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
 
     const state_UAReferenceType = {
         init(this: any, name: string, attrs: XmlAttributes) {
+            _perform();
+
             this.obj = {};
             this.obj.nodeClass = NodeClass.ReferenceType;
             this.obj.isAbstract = ec.coerceBoolean(attrs.IsAbstract);
@@ -486,6 +495,8 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
 
     const state_UADataType = {
         init(this: any, name: string, attrs: XmlAttributes) {
+            _perform();
+
             this.obj = {};
             this.obj.nodeClass = NodeClass.DataType;
             this.obj.isAbstract = ec.coerceBoolean(attrs.IsAbstract) || false;
@@ -501,9 +512,7 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
             this.definitionFields = [];
         },
         finish(this: any) {
-            if (this.isDraft || this.isDeprecated) {
-                // ignore Draft or Deprecated element
-                debugLog("Ignoring Draft/Deprecated dataType =", this.obj.browseName.toString());
+            if (canIngore({ isDraft: this.isDraft, isDeprecated: this.isDeprecated }, this.obj)) {
                 return;
             }
             /*
@@ -861,6 +870,14 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
                         assert(self.extensionObject instanceof ExtensionObject);
                         break;
                     default: {
+                        // istanbul ignore next
+                        if (! this._cloneFragment) {
+                            // the XML file is probably not exposing standard UA extension object correctly.
+                            // this has been seen in some generated xml files using the dataType nodeId instead of the default encoding
+                            // nodeid 
+                            errorLog("[NODE-OPCUA-E12] standard OPCUA Extension object from (namespace=0) has a invalid TypeId", self.typeDefinitionId.toString());
+                            break;
+                        }
                         this.bodyXML = this._cloneFragment!.value;
                         this._cloneFragment!.value = null;
 
@@ -1329,8 +1346,22 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
         };
         postTasks2_AssignedExtensionObjectToDataValue.push(task);
     }
+
+    const canIngore = ({ isDraft, isDeprecated }: { isDraft: boolean; isDeprecated: boolean }, node: BaseNode) => {
+        if (isDraft && !options.loadDraftNodes) {
+            debugLog("Ignoring Draft            =", NodeClass[node.nodeClass], node.browseName.toString());
+            return true;
+        }
+        if (isDeprecated && !options.loadDeprecatedNodes) {
+            debugLog("Ignoring Deprecate        =", NodeClass[node.nodeClass], node.browseName.toString());
+            return true;
+        }
+        return false;
+    };
     const state_UAVariable = {
         init(this: any, name: string, attrs: XmlAttributes) {
+            _perform();
+
             this.obj = {};
 
             this.obj.nodeClass = NodeClass.Variable;
@@ -1354,10 +1385,10 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
             this.isDeprecated = attrs.ReleaseStatus === "Deprecated";
         },
         finish(this: any) {
-            if (this.isDraft || this.isDeprecated) {
-                debugLog("Ignoring Draft/Deprecated UAVariable =", this.obj.browseName.toString());
+            if (canIngore({ isDraft: this.isDraft, isDeprecated: this.isDeprecated }, this.obj)) {
                 return;
             }
+
             /*
             // set default value based on obj data Type
             if (this.obj.value === undefined) {
@@ -1378,7 +1409,14 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
                     capturedValue = undefined;
                     (capturedVariable as any) = undefined;
                 };
-                postTasks1_InitializeVariable.push(task);
+                if (capturedValue.dataType !== DataType.ExtensionObject) {
+                    postTasks0_InitializeVariable.push(task);
+                } else {
+                    // do them later
+                    postTasks1_InitializeVariable.push(task);
+                }
+
+               
             } else {
                 const task = async (addressSpace2: IAddressSpace) => {
                     const dataTypeNode = capturedVariable.dataType;
@@ -1396,7 +1434,7 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
                     }
                     (capturedVariable as any) = undefined;
                 };
-                postTasks1_InitializeVariable.push(task);
+                postTasks0_InitializeVariable.push(task);
             }
             this.obj.value = undefined;
             capturedVariable = _internal_createNode(this.obj) as UAVariable;
@@ -1421,6 +1459,8 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
 
     const state_UAVariableType = {
         init(this: any, name: string, attrs: XmlAttributes) {
+            _perform();
+
             this.obj = {};
             this.obj.isAbstract = ec.coerceBoolean(attrs.IsAbstract);
 
@@ -1441,8 +1481,7 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
             this.isDeprecated = attrs.ReleaseStatus === "Deprecated";
         },
         finish(this: any) {
-            if (this.isDraft || this.isDeprecated) {
-                debugLog("Ignoring Draft/Deprecated UAVariableType =", this.obj.browseName.toString());
+            if (canIngore({ isDraft: this.isDraft, isDeprecated: this.isDeprecated }, this.obj)) {
                 return;
             }
             try {
@@ -1473,6 +1512,8 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
 
     const state_UAMethod = {
         init(this: any, name: string, attrs: XmlAttributes) {
+            _perform();
+
             this.obj = {};
             this.obj.nodeClass = NodeClass.Method;
             // MethodDeclarationId
@@ -1486,8 +1527,7 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
             this.isDeprecated = attrs.ReleaseStatus === "Deprecated";
         },
         finish(this: any) {
-            if (this.isDraft || this.isDeprecated) {
-                debugLog("Ignoring Draft/Deprecated UAMethod =", this.obj.browseName.toString());
+            if (canIngore({ isDraft: this.isDraft, isDeprecated: this.isDeprecated }, this.obj)) {
                 return;
             }
             _internal_createNode(this.obj);
@@ -1557,7 +1597,17 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
         }
     });
 
+    function _updateTranslationTable() {
+        _register_namespace_uri_in_translation_table("http://opcfoundation.org/UA/");
+        for (const namespaceUri of _namespaceUris) {
+            _register_namespace_uri_in_translation_table(namespaceUri);
+        }
+    }
+
     function _perform() {
+        if (performedCalled) return;
+        performedCalled = true;
+
         /**special case for old nodeset file version 1.02 where no models exists */
         if (models.length === 0) {
             for (const namespaceuri of _namespaceUris) {
@@ -1573,13 +1623,7 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
                 });
             }
         }
-
-        doDebug && debugLog("xxx models =", JSON.stringify(models, null, " "));
-        doDebug && debugLog("xxx _namespaceUris =", _namespaceUris);
-        _register_namespace_uri_in_translation_table("http://opcfoundation.org/UA/");
-        for (const namespaceUri of _namespaceUris) {
-            _register_namespace_uri_in_translation_table(namespaceUri);
-        }
+        _updateTranslationTable();
     }
     // state_ModelTableEntry.parser["RequiredModel"] = state_ModelTableEntry;
     let _namespaceUris: string[] = [];
@@ -1681,6 +1725,9 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
             doDebug && debugLog(chalk.bgGreenBright("Performing post loading tasks -------------------------------------------"));
             await performPostLoadingTasks(postTasks);
 
+            doDebug && debugLog(chalk.bgGreenBright("Performing post loading task: Initializing Simple Variables ---------------------"));
+            await performPostLoadingTasks(postTasks0_InitializeVariable);
+
             doDebug && debugLog(chalk.bgGreenBright("Performing DataType extraction -------------------------------------------"));
             assert(!addressSpace1.suspendBackReference);
             await ensureDatatypeExtracted(addressSpace);
@@ -1700,7 +1747,7 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
             doDebug && debugLog(chalk.bgGreenBright("Performing post loading task: Decoding Pojo String (parsing XML objects) -"));
             await performPostLoadingTasks(postTasks0_DecodePojoString);
 
-            doDebug && debugLog(chalk.bgGreenBright("Performing post loading task: Initializing Variables ---------------------"));
+            doDebug && debugLog(chalk.bgGreenBright("Performing post loading task: Initializing Complex Variables ---------------------"));
             await performPostLoadingTasks(postTasks1_InitializeVariable);
 
             doDebug && debugLog(chalk.bgGreenBright("Performing post loading tasks: (assigning Extension Object to Variables) -"));
@@ -1726,10 +1773,16 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
         terminate
     };
 }
+
+export interface NodeSetLoaderOptions {
+    loadDraftNodes?: boolean;
+    loadDeprecatedNodes?: boolean;
+}
+
 export class NodeSetLoader {
-    _s: any;
-    constructor(addressSpace: IAddressSpace) {
-        this._s = makeNodeSetParserEngine(addressSpace);
+    _s: NodeSet2ParserEngine;
+    constructor(addressSpace: IAddressSpace, private options?: NodeSetLoaderOptions) {
+        this._s = makeNodeSetParserEngine(addressSpace, options || {});
     }
 
     addNodeSet(xmlData: string, callback: ErrorCallback): void {

package/source/xml_writer.ts

@@ -2,6 +2,7 @@ export interface XmlWriter {
     translationTable: any;
     visitedNode: any;
 
+    startDocument(options: { encoding: string; version: string }): void;
     startElement(elementName: string): this;
 
     endElement(): this;
@@ -11,4 +12,6 @@ export interface XmlWriter {
     writeComment(comment: string): this;
 
     text(str: string): this;
+
+    endDocument(): void;
 }

package/source_nodejs/generate_address_space.ts

@@ -1,11 +1,11 @@
 import * as fs from "fs";
-import { callbackify, promisify } from "util";
+import { callbackify } from "util";
 
 import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
-import { ErrorCallback } from "node-opcua-status-code";
 import { IAddressSpace } from "node-opcua-address-space-base";
 
 import { generateAddressSpaceRaw } from "..";
+import { NodeSetLoaderOptions } from "../source/loader/load_nodeset2";
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
@@ -26,9 +26,31 @@ export function generateAddressSpace(
     xmlFiles: string | string[],
     callback: (err?: Error) => void
 ): void;
-export function generateAddressSpace(addressSpace: IAddressSpace, xmlFiles: string | string[]): Promise<void>;
-export function generateAddressSpace(addressSpace: IAddressSpace, xmlFiles: string | string[], callback?: ErrorCallback): any {
-    callbackify(generateAddressSpaceRaw)(addressSpace, xmlFiles, readNodeSet2XmlFile, callback!);
+export function generateAddressSpace(
+    addressSpace: IAddressSpace,
+    xmlFiles: string | string[],
+    options: NodeSetLoaderOptions | undefined,
+    callback: (err?: Error) => void
+): void;
+export function generateAddressSpace(
+    addressSpace: IAddressSpace,
+    xmlFiles: string | string[],
+    options?: NodeSetLoaderOptions
+): Promise<void>;
+export function generateAddressSpace(
+    ... args: any[]
+): any {
+    const addressSpace = args[0] as IAddressSpace;
+    const xmlFiles = args[1] as string | string[];
+    if (args.length === 4) {
+        const options = args[2] as NodeSetLoaderOptions | undefined;
+        const callback = args[3]  as (err?: Error) => void;
+        callbackify(generateAddressSpaceRaw)(addressSpace, xmlFiles, readNodeSet2XmlFile, options ||{}, callback!);
+    } else {
+        const options = {};
+        const callback = args[2]  as (err?: Error) => void;
+        callbackify(generateAddressSpaceRaw)(addressSpace, xmlFiles, readNodeSet2XmlFile, options, callback!);
+    }
 }
 
 // tslint:disable:no-var-requires

package/src/base_node_private.ts

@@ -538,6 +538,12 @@ function _extractInterfaces2(typeDefinitionNode: UAObjectType | UAVariableType,
     }
 
     const addressSpace = typeDefinitionNode.addressSpace;
+
+    const hasInterfaceReference = addressSpace.findReferenceType("HasInterface");
+    if (!hasInterfaceReference) {
+        // this version of the standard UA namespace doesn't support Interface yet 
+        return [];
+    }
     // example:
     // FolderType
     //   FunctionalGroupType

package/src/index_current.ts

@@ -13,6 +13,8 @@ export * from "../source/helpers/ensure_secure_access";
 export * from "../source/helpers/resolve_opaque_on_address_space";
 export * from "../source/interfaces/alarms_and_conditions/condition_info_i";
 
+export * from "../src/nodeset_tools/construct_namespace_dependency";
+
 
 export * from "../source/set_namespace_meta_data";
 export * from "../source/namespace";
@@ -34,7 +36,7 @@ export * from "./event_data";
 
 export { NamespaceOptions } from "./nodeid_manager";
 export { dumpXml } from "./nodeset_tools/nodeset_to_xml";
-export { dumpToBSD } from "./nodeset_tools/typedictionary_to_xml";
+export { dumpToBSD } from "./nodeset_tools/dump_to_bsd";
 export { adjustNamespaceArray } from "./nodeset_tools/adjust_namespace_array";
 export { makeAttributeEventName } from "./base_node_impl";
 export { resolveReferenceNode, resolveReferenceType } from "./reference_impl";

package/src/namespace_impl.ts

@@ -219,9 +219,13 @@ export class NamespaceImpl implements NamespacePrivate {
     public addressSpace: AddressSpacePrivate;
     public readonly index: number;
 
+    public emulateVersion103 = false;
+
     public version = "0.0.0";
     public publicationDate: Date = new Date(Date.UTC(1900, 0, 1));
 
+    public registerSymbolicNames = false;
+
     private _objectTypeMap: Map<string, UAObjectType>;
     private _variableTypeMap: Map<string, UAVariableType>;
     private _referenceTypeMap: Map<string, UAReferenceType>;
@@ -289,27 +293,35 @@ export class NamespaceImpl implements NamespacePrivate {
     public _objectTypeIterator(): IterableIterator<UAObjectType> {
         return this._objectTypeMap.values();
     }
+
     public _objectTypeCount(): number {
         return this._objectTypeMap.size;
     }
+
     public _variableTypeIterator(): IterableIterator<UAVariableType> {
         return this._variableTypeMap.values();
     }
+
     public _variableTypeCount(): number {
         return this._variableTypeMap.size;
     }
+
     public _dataTypeIterator(): IterableIterator<UADataType> {
         return this._dataTypeMap.values();
     }
+
     public _dataTypeCount(): number {
         return this._dataTypeMap.size;
     }
+
     public _referenceTypeIterator(): IterableIterator<UAReferenceType> {
         return this._referenceTypeMap.values();
     }
+
     public _referenceTypeCount(): number {
         return this._referenceTypeMap.size;
     }
+
     public _aliasCount(): number {
         return this._aliases.size;
     }
@@ -1627,7 +1639,10 @@ export class NamespaceImpl implements NamespacePrivate {
 
     // --- internal stuff
     public constructNodeId(options: ConstructNodeIdOptions): NodeId {
-        return this._nodeIdManager.constructNodeId(options);
+        return this._nodeIdManager.constructNodeId({
+            registerSymbolicNames: this.registerSymbolicNames,
+            ...options
+        });
     }
 
     public _register(node: BaseNode): void {
@@ -1943,6 +1958,14 @@ export class NamespaceImpl implements NamespacePrivate {
         }
         // ------------------------------------------ TypeDefinition
         let typeDefinition = options.typeDefinition || baseDataVariableTypeId;
+        if (typeDefinition instanceof BaseNodeImpl) {
+            // istanbul ignore next
+            if (typeDefinition.nodeClass !== NodeClass.VariableType) {
+                const message = `invalid typeDefinition expecting a VariableType got ${NodeClass[typeDefinition.nodeClass]}`;
+                errorLog(message);
+                throw new Error(message);
+            }
+        }
         typeDefinition = addressSpace._coerce_VariableTypeIds(typeDefinition);
         assert(typeDefinition instanceof NodeId);
 

package/src/namespace_private.ts

@@ -33,6 +33,8 @@ export interface NamespacePrivate extends INamespace {
     internalCreateNode(options: CreateNodeOptions): BaseNode;
 
     _dataTypeIterator(): IterableIterator<UADataType>;
+
+    registerSymbolicNames: boolean;
 }
 
 export declare const NamespacePrivate: new (options: any) => NamespacePrivate;

package/src/nodeid_manager.ts

@@ -1,3 +1,5 @@
+/* eslint-disable max-depth */
+/* eslint-disable max-statements */
 import { assert } from "node-opcua-assert";
 import { NodeClass, QualifiedName } from "node-opcua-data-model";
 import { makeNodeId, NodeId, NodeIdLike, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
@@ -50,6 +52,7 @@ export interface ConstructNodeIdOptions {
     browseName: QualifiedName;
     nodeClass: NodeClass;
     references?: UAReference[];
+    registerSymbolicNames?: boolean;
 }
 export type NodeEntry = [string, number, NodeClass];
 export type NodeEntry1 = [string, number, string /*"Object" | "Variable" etc...*/];
@@ -116,7 +119,6 @@ export class NodeIdManager {
 
     public constructNodeId(options: ConstructNodeIdOptions): NodeId {
         function prepareName(browseName: QualifiedName): string {
-            assert(browseName instanceof QualifiedName);
             const m = browseName.name!.toString().replace(/[ ]/g, "").replace(/(<|>)/g, "");
             return m;
         }
@@ -124,10 +126,7 @@ export class NodeIdManager {
         const nodeClass = options.nodeClass;
 
         if (!nodeId) {
-            //    console.log("xx constructNodeId", options.browseName.toString());
-
             const parentInfo = this.findParentNodeId(options);
-
             if (parentInfo) {
                 const [parentNodeId, linkName] = parentInfo;
                 const name = prepareName(options.browseName);
@@ -148,6 +147,16 @@ export class NodeIdManager {
                         } else {
                             return this._getOrCreateFromName(newName, nodeClass);
                         }
+                    } else {
+                        if (options.registerSymbolicNames) {
+                            const newName = name;
+                            const nodeIdValueInCache = this._cache[newName];
+                            if (nodeIdValueInCache) {
+                                return new NodeId(NodeIdType.NUMERIC, nodeIdValueInCache, this.namespaceIndex);
+                            } else {
+                                return this._getOrCreateFromName(newName, nodeClass);
+                            }
+                        }
                     }
                 }
                 // }} has parent ...
@@ -228,4 +237,4 @@ export class NodeIdManager {
             return nodeIdResult;
         }
     }
-}
+}

package/src/nodeset_tools/{typedictionary_to_xml.ts → dump_to_bsd.ts}

@@ -33,7 +33,7 @@ function buildXmlName(addressSpace: AddressSpacePrivate, map: { [key: number]: s
         throw new Error("Cannot find Node for" + nodeId?.toString());
     }
     const typeName = node.browseName.name!;
-    const prefix = node.nodeId.namespace === 0 ? (node.nodeId.value <= 15 ? "opc" : "ua") : map[node.nodeId.namespace];
+    const prefix = node.nodeId.namespace === 0 ? (node.nodeId.value<= 15 ? "opc" : "ua") : map[node.nodeId.namespace];
     return prefix + ":" + (typeName === "Structure" && prefix === "ua" ? "ExtensionObject" : typeName);
 }
 
@@ -43,7 +43,7 @@ function dumpDataTypeStructure(
     addressSpace: IAddressSpace,
     map: { [key: number]: string },
     structureDefinition: StructureDefinition,
-    structureDefinitionBase: StructureDefinition | undefined| null,
+    structureDefinitionBase: StructureDefinition | undefined | null,
     name: string,
     doc?: string
 ): void {
@@ -59,11 +59,11 @@ function dumpDataTypeStructure(
 
     const fields = structureDefinition.fields || [];
     // get base class
-    const nbFieldsInBase = structureDefinitionBase? structureDefinitionBase.fields?.length || 0 : 0;
+    const nbFieldsInBase = structureDefinitionBase ? structureDefinitionBase.fields?.length || 0 : 0;
 
     let optionalsCount = 0;
-    for (let index = nbFieldsInBase; index < fields.length; index ++) {
-        const f=  fields [index];
+    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");
@@ -96,9 +96,9 @@ function dumpDataTypeStructure(
             xw.endElement();
         }
     }
-    for (let index = nbFieldsInBase; index < fields.length; index ++) {
-        const f=  fields [index];
-   
+    for (let index = nbFieldsInBase; index < fields.length; index++) {
+        const f = fields[index];
+
         const isArray = f.valueRank > 0 && f.arrayDimensions?.length;
 
         if (isArray) {
@@ -145,27 +145,29 @@ function dumpDataTypeToBSD(xw: XmlWriter, dataType: UADataType, map: { [key: num
 function shortcut(namespace: INamespace) {
     return "n" + namespace.index;
 }
-export function dumpToBSD(namespace: NamespacePrivate): void {
+export function dumpToBSD(namespace: NamespacePrivate): string {
     const dependency: INamespace[] = constructNamespaceDependency(namespace);
 
     const addressSpace = namespace.addressSpace;
 
-    const xw = new XMLWriter(true);
+    const xw: XmlWriter = new XMLWriter(true);
 
-    xw.startDocument({ encoding: "utf-8", version: "1.0" });
+    //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: { [key: number]: string } = {};
+    
+    map[namespace.index] = "tns";
 
     for (const dependantNamespace of dependency) {
         const namespaceIndex = dependantNamespace.index;
-        if (namespaceIndex === 0) {
-            //|| namespaceIndex === namespace.index) {
+        if (namespaceIndex === 0 || namespaceIndex === namespace.index) {
             continue;
         }
         const ns = shortcut(dependantNamespace);
@@ -176,11 +178,19 @@ export function dumpToBSD(namespace: NamespacePrivate): void {
     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();
+//    xw.endDocument();
 
     return xw.toString();
 }