node-opcua-address-space 2.179.0 → 2.181.0

package/api/ua_interface.ts

@@ -0,0 +1,38 @@
+import type { UAObject, UAObjectType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
+import { NodeClass } from "node-opcua-types";
+import { initialize_properties_and_components } from "../impl/_instantiate_helpers.js";
+
+export function implementInterface(
+    uaNode: UAObject | UAObjectType | UAVariable | UAVariableType,
+    interfaceType: UAObjectType,
+    optionals?: string[],
+    isModellingType?: boolean
+) {
+    optionals = optionals || [];
+
+    const addressSpace = uaNode.addressSpace;
+    const topMost = addressSpace.findObjectType("BaseInterfaceType");
+    if (!topMost) {
+        throw new Error("cannot find BaseInterfaceType");
+    }
+
+    isModellingType =
+        isModellingType === undefined
+            ? uaNode.nodeClass === NodeClass.ObjectType || uaNode.nodeClass === NodeClass.VariableType
+            : isModellingType;
+
+    const copyAlsoModellingRules = isModellingType;
+    const copyAlsoAllOptionals = isModellingType;
+    initialize_properties_and_components(
+        uaNode as UAObject | UAVariable,
+        topMost,
+        interfaceType,
+        copyAlsoModellingRules,
+        copyAlsoAllOptionals,
+        optionals
+    );
+    uaNode.addReference({
+        nodeId: interfaceType,
+        referenceType: "HasInterface"
+    });
+}

package/api/ua_two_state_variable_ex.ts

@@ -0,0 +1,36 @@
+/**
+ * @module node-opcua-address-space
+ */
+import type { UAVariableT } from "node-opcua-address-space-base";
+import type { LocalizedText } from "node-opcua-data-model";
+import type { UAStateVariable, UATwoStateVariable_Base } from "node-opcua-nodeset-ua";
+import type { DataType } from "node-opcua-variant";
+import type { ISetStateOptions } from "./interfaces/i_set_state_options.js";
+
+/**
+ * @see https://reference.opcfoundation.org/v104/Core/docs/Part9/5.2/
+ * @see https://reference.opcfoundation.org/v104/Core/VariableTypes/TwoStateVariableType/
+ * @see https://reference.opcfoundation.org/v104/Core/ReferenceTypes/HasFalseSubState/
+ */
+
+export interface UATwoStateVariableHelper {
+    // references
+    readonly isFalseSubStateOf: UAStateVariable<LocalizedText> | null;
+    readonly isTrueSubStateOf: UAStateVariable<LocalizedText> | null;
+
+    // --- helpers ---
+    setValue(boolValue: boolean, options?: ISetStateOptions): void;
+
+    getValue(): boolean;
+
+    getValueAsString(): string;
+
+    getFalseSubStates(): UAStateVariable<LocalizedText>[];
+
+    getTrueSubStates(): UAStateVariable<LocalizedText>[];
+}
+
+export interface UATwoStateVariableEx
+    extends UAVariableT<LocalizedText, DataType.LocalizedText>,
+        UATwoStateVariableHelper,
+        UATwoStateVariable_Base<LocalizedText> {}

package/bin/opcua-nodeset-image.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+/**
+ * opcua-nodeset-image: precompiled images of NodeSet2 files, without writing code.
+ *
+ *   opcua-nodeset-image build <file.xml>... [--out <dir>]
+ *       writes <name>.ndjson.gz next to each source, or into --out; prints source size,
+ *       image size, node count and elapsed time; exit code 1 when a file fails, the others
+ *       are still processed
+ *   opcua-nodeset-image verify <file.xml>... [--require <file.xml>]...
+ *       loads each file from XML and from its image into two address spaces and compares
+ *       them; dependencies come from the node-opcua-nodesets catalog, or from --require
+ *   opcua-nodeset-image info <image>
+ *       prints the header and the trailer of an image
+ *   opcua-nodeset-image export <file.xml>... [--out <image>]
+ *       loads the files (dependencies resolved as for verify) and exports the last one's
+ *       namespace, from the live address space, to an image: the round-trip fixture
+ */
+const fs = require("node:fs");
+const path = require("node:path");
+const { performance } = require("node:perf_hooks");
+const { AddressSpace, generateAddressSpaceRaw, namespaceToImage, preLoad, readNodesetImageInfo } = require("../dist/api/index.js");
+const { addressSpacePackageVersion, digestAddressSpace, nodesetFileToImage, readNodeSet2XmlFile } = require("../distNodeJS/index.js");
+
+const usage = () => {
+    console.error("usage: opcua-nodeset-image build <file.xml>... [--out <dir>]");
+    console.error("       opcua-nodeset-image verify <file.xml>... [--require <file.xml>]...");
+    console.error("       opcua-nodeset-image info <image>");
+    console.error("       opcua-nodeset-image export <file.xml>... [--out <image>] [--require <file.xml>]...");
+    process.exit(2);
+};
+
+function parseArgs(argv) {
+    const files = [];
+    const options = { out: undefined, require: [] };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--out") options.out = argv[++i];
+        else if (arg === "--require") options.require.push(argv[++i]);
+        else if (arg.startsWith("--")) usage();
+        else files.push(arg);
+    }
+    return { files, options };
+}
+
+const imageFileOf = (file, outDir) => {
+    const base = path.basename(file).replace(/\.xml$/i, "");
+    return path.join(outDir ?? path.dirname(file), `${base}.ndjson.gz`);
+};
+const kb = (n) => `${(n / 1024).toFixed(0)} KB`;
+
+async function build(files, options) {
+    let failed = 0;
+    for (const file of files) {
+        const t0 = performance.now();
+        try {
+            const image = await nodesetFileToImage(file);
+            const target = imageFileOf(file, options.out);
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.writeFileSync(target, image);
+            const info = await readNodesetImageInfo(image);
+            const source = fs.statSync(file).size;
+            console.log(
+                `${path.basename(file)}: ${kb(source)} -> ${path.basename(target)} ${kb(image.length)}, ${info.trailer.nodes} nodes, ${(performance.now() - t0).toFixed(0)} ms`
+            );
+        } catch (err) {
+            failed += 1;
+            console.error(`${file}: ${err.message}`);
+        }
+    }
+    return failed > 0 ? 1 : 0;
+}
+
+/** the files a document requires, in load order, from the catalog and the --require files */
+async function dependencyChain(file, requireFiles) {
+    let catalog = [];
+    let nodesets = {};
+    try {
+        ({ nodesetCatalog: catalog, nodesets } = require("node-opcua-nodesets"));
+    } catch {
+        /* the catalog is optional */
+    }
+    const known = new Map(); // model uri -> file
+    for (const meta of catalog) {
+        if (nodesets[meta.name] && fs.existsSync(nodesets[meta.name])) known.set(meta.uri, nodesets[meta.name]);
+    }
+    for (const required of requireFiles) {
+        const [desc] = await preLoad([required], readNodeSet2XmlFile);
+        for (const model of desc.namespaceModel.models) known.set(model.modelUri, required);
+    }
+    const order = [];
+    const visit = async (f) => {
+        const [desc] = await preLoad([f], readNodeSet2XmlFile);
+        for (const model of desc.namespaceModel.models) {
+            for (const required of model.requiredModel) {
+                const dependency = known.get(required.modelUri);
+                if (!dependency) throw new Error(`${path.basename(f)} requires ${required.modelUri}: not in the catalog, pass it with --require`);
+                if (!order.includes(dependency) && dependency !== f) await visit(dependency);
+            }
+        }
+        if (!order.includes(f)) order.push(f);
+    };
+    await visit(file);
+    return order;
+}
+
+async function verify(files, options) {
+    let failed = 0;
+    for (const file of files) {
+        try {
+            const chain = await dependencyChain(file, options.require);
+            const image = await nodesetFileToImage(file);
+            const load = async (sources) => {
+                const addressSpace = AddressSpace.create();
+                try {
+                    await generateAddressSpaceRaw(addressSpace, sources, {});
+                    return digestAddressSpace(addressSpace);
+                } finally {
+                    addressSpace.dispose();
+                }
+            };
+            const asFile = (f) => ({ name: f, source: () => [new Uint8Array(fs.readFileSync(f))] });
+            const fromXml = await load(chain.map(asFile));
+            const fromImage = await load(chain.map((f) => (f === file ? { name: `${f} (image)`, source: image } : asFile(f))));
+            const same = fromXml.hash === fromImage.hash && fromXml.nodes === fromImage.nodes && fromXml.references === fromImage.references;
+            console.log(`${path.basename(file)}: ${fromXml.nodes} nodes, ${fromXml.references} references, image ${same ? "identical" : "DIFFERS"}`);
+            if (!same) failed += 1;
+        } catch (err) {
+            failed += 1;
+            console.error(`${file}: ${err.message}`);
+        }
+    }
+    return failed > 0 ? 1 : 0;
+}
+
+async function exportNamespace(files, options) {
+    const last = files[files.length - 1];
+    const chain = await dependencyChain(last, [...options.require, ...files.slice(0, -1)]);
+    const addressSpace = AddressSpace.create();
+    try {
+        const asFile = (f) => ({ name: f, source: () => [new Uint8Array(fs.readFileSync(f))] });
+        await generateAddressSpaceRaw(addressSpace, chain.map(asFile), {});
+        const [desc] = await preLoad([last], readNodeSet2XmlFile);
+        const modelUri = desc.namespaceModel.models[0]?.modelUri;
+        const namespace = addressSpace.getNamespaceArray().find((n) => n.namespaceUri === modelUri);
+        if (!namespace) throw new Error(`${path.basename(last)}: namespace ${modelUri} not found after loading`);
+        const t0 = performance.now();
+        const image = await namespaceToImage(namespace, { addressSpaceVersion: addressSpacePackageVersion() });
+        const target = options.out ?? imageFileOf(last, undefined).replace(/\.ndjson\.gz$/, ".export.ndjson.gz");
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, image);
+        const info = await readNodesetImageInfo(image);
+        console.log(`${path.basename(last)}: namespace ${modelUri} -> ${path.basename(target)} ${kb(image.length)}, ${info.trailer.nodes} nodes, ${(performance.now() - t0).toFixed(0)} ms`);
+        return 0;
+    } finally {
+        addressSpace.dispose();
+    }
+}
+
+async function info(files) {
+    for (const file of files) {
+        const bytes = new Uint8Array(fs.readFileSync(file));
+        const { header, trailer, lines } = await readNodesetImageInfo(bytes);
+        console.log(JSON.stringify({ file, size: bytes.length, header, trailer, lines }, null, 2));
+    }
+    return 0;
+}
+
+async function main() {
+    const [command, ...rest] = process.argv.slice(2);
+    const { files, options } = parseArgs(rest);
+    if (!command || files.length === 0) usage();
+    switch (command) {
+        case "build":
+            return build(files, options);
+        case "verify":
+            return verify(files, options);
+        case "info":
+            return info(files);
+        case "export":
+            return exportNamespace(files, options);
+        default:
+            usage();
+    }
+}
+
+main().then(
+    (code) => process.exit(code),
+    (err) => {
+        console.error(err.message);
+        process.exit(1);
+    }
+);

package/dist/api/address_space_public.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module node-opcua-address-space
+ */
+import type { IAddressSpace } from "node-opcua-address-space-base";
+import type { IHistorizerFactory } from "./address_space_ts.js";
+import type { Namespace } from "./namespace.js";
+import type { UARootFolder } from "./ua_root_folder.js";
+/**
+ * The address space: the set of nodes a server exposes, and the namespaces they live in.
+ *
+ * Obtain one with {@link AddressSpace.create}. This is the published shape of it; the class
+ * behind it carries a great deal more, none of which is API.
+ */
+export interface AddressSpace extends IAddressSpace {
+    getOwnNamespace(): Namespace;
+    registerNamespace(namespaceUri: string): Namespace;
+    rootFolder: UARootFolder;
+    /**
+     * Give browse names created at runtime the treatment of the names a nodeset declares:
+     * `parent.<name>` then resolves through one getter shared by every node instead of an accessor
+     * installed on each parent. Nodes created before the call are covered too.
+     *
+     * Only worth it when many nodes carry the same browse name; a name used once costs the same
+     * either way.
+     */
+    registerChildAccessorNames(browseNames: string[]): void;
+}
+/**
+ * The static side of {@link AddressSpace}.
+ *
+ * Naming it separately is what keeps the implementation out of the published API: the value
+ * exported below is the real class, but it is seen through this, so only `create` and
+ * `historizerFactory` are reachable.
+ */
+export interface AddressSpaceConstructor {
+    /** build an empty address space */
+    create(): AddressSpace;
+    /**
+     * How historized variables get their historian. Assigning here replaces the default that
+     * the historical-access code installs on first use.
+     */
+    historizerFactory?: IHistorizerFactory;
+}
+/**
+ * An interface and a variable may share a name, so `AddressSpace` is both the type you
+ * annotate with and the value you call `create()` on, while the implementation class stays
+ * unexported and undocumented.
+ *
+ * This was a conversion for a while, and it no longer needs to be: the compiler now agrees
+ * that AddressSpaceImpl provides the published shape. It could not before, because
+ * `getOwnNamespace()` returned a `NamespacePrivate` that extended `INamespace` rather than
+ * the published `Namespace`, hiding the alarm-and-condition, data-access and machine-state
+ * methods NamespaceImpl really has; and correcting that ran into the data-access classes not
+ * statically satisfying their own `Ex` interfaces. Both are fixed, so the annotation is
+ * checked rather than asserted.
+ */
+export declare const AddressSpace: AddressSpaceConstructor;

package/dist/api/address_space_public.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressSpace = void 0;
+const address_space_js_1 = require("../impl/address_space.js");
+/**
+ * An interface and a variable may share a name, so `AddressSpace` is both the type you
+ * annotate with and the value you call `create()` on, while the implementation class stays
+ * unexported and undocumented.
+ *
+ * This was a conversion for a while, and it no longer needs to be: the compiler now agrees
+ * that AddressSpaceImpl provides the published shape. It could not before, because
+ * `getOwnNamespace()` returned a `NamespacePrivate` that extended `INamespace` rather than
+ * the published `Namespace`, hiding the alarm-and-condition, data-access and machine-state
+ * methods NamespaceImpl really has; and correcting that ran into the data-access classes not
+ * statically satisfying their own `Ex` interfaces. Both are fixed, so the annotation is
+ * checked rather than asserted.
+ */
+exports.AddressSpace = address_space_js_1.AddressSpaceImpl;
+//# sourceMappingURL=address_space_public.js.map

package/dist/api/address_space_public.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address_space_public.js","sourceRoot":"","sources":["../../api/address_space_public.ts"],"names":[],"mappings":";;;AAIA,+DAA4D;AA6C5D;;;;;;;;;;;;GAYG;AACU,QAAA,YAAY,GAA4B,mCAAgB,CAAC"}

package/dist/api/address_space_ts.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @module node-opcua-address-space
+ */
+import type { AddBaseNodeOptions, AddVariableOptionsWithoutValue, BaseNode, BindVariableOptions, IVariableHistorian, IVariableHistorianOptions, UAVariable, UAVariableT, UAVariableType, VariableStuff } from "node-opcua-address-space-base";
+import type { Int64, UAString, UInt32 } from "node-opcua-basic-types";
+import type { LocalizedText, LocalizedTextLike, QualifiedNameLike } from "node-opcua-data-model";
+import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import type { UAFolder } from "node-opcua-nodeset-ua";
+import type { DataType } from "node-opcua-variant";
+export interface EnumValueTypeOptionsLike {
+    value?: Int64 | UInt32;
+    displayName?: LocalizedTextLike | null;
+    description?: LocalizedTextLike | null;
+}
+export interface AddMultiStateValueDiscreteOptions extends AddVariableOptionsWithoutValue {
+    enumValues: EnumValueTypeOptionsLike[] | {
+        [key: string]: number;
+    };
+    value?: UInt32 | Int64 | BindVariableOptions;
+}
+export declare enum EUEngineeringUnit {
+    degree_celsius = 0
+}
+export interface AddMultiStateDiscreteOptions extends AddBaseNodeOptions, VariableStuff {
+    enumStrings: string[];
+    typeDefinition?: string | NodeId | UAVariableType;
+    postInstantiateFunc?: (node: UAVariable) => void;
+    value?: number | BindVariableOptions;
+}
+export type AddStateVariableOptionals = "EffectiveDisplayName" | "Name" | "Number" | string;
+export interface AddStateVariableOptions extends AddVariableOptionsWithoutValue {
+    id?: NodeIdLike;
+    optionals?: AddStateVariableOptionals[];
+}
+export type AddTwoStateVariableOptionals = AddStateVariableOptionals | "TransitionTime" | "EffectiveTransitionTime" | "TrueState" | "FalseState";
+export interface AddTwoStateVariableOptions extends AddStateVariableOptions {
+    falseState?: LocalizedTextLike;
+    trueState?: LocalizedTextLike;
+    optionals?: AddTwoStateVariableOptionals[];
+    isFalseSubStateOf?: NodeId | string | BaseNode;
+    isTrueSubStateOf?: NodeId | string | BaseNode;
+    value?: boolean | BindVariableOptions;
+}
+export interface AddTwoStateDiscreteOptions extends AddVariableOptionsWithoutValue {
+    falseState?: LocalizedTextLike;
+    trueState?: LocalizedTextLike;
+    optionals?: string[];
+    isFalseSubStateOf?: NodeIdLike | BaseNode;
+    isTrueSubStateOf?: NodeIdLike | BaseNode;
+    value?: boolean | BindVariableOptions;
+    /** @example  "" */
+    definition?: string;
+}
+export interface RangeVariable extends UAVariable {
+    low: UAVariableT<number, DataType.Double>;
+    high: UAVariableT<number, DataType.Double>;
+}
+export interface XAxisDefinitionVariable extends UAVariable {
+    engineeringUnits: UAVariableT<UAString, DataType.String>;
+    title: UAVariableT<LocalizedText, DataType.LocalizedText>;
+    euRange: RangeVariable;
+}
+export interface UATypesFolder extends UAFolder {
+    dataTypes: UAFolder;
+    eventTypes: UAFolder;
+    objectTypes: UAFolder;
+    referenceTypes: UAFolder;
+    variableTypes: UAFolder;
+}
+export interface IHistorizerFactory {
+    create(node: UAVariable, options: IVariableHistorianOptions): IVariableHistorian;
+}
+export interface CreateExtObjArrayNodeOptions {
+    browseName: QualifiedNameLike;
+    complexVariableType: string | NodeId;
+    variableType: string | NodeId;
+    indexPropertyName: string;
+    minimumSamplingInterval?: number;
+}

package/dist/api/address_space_ts.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * @module node-opcua-address-space
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EUEngineeringUnit = void 0;
+var EUEngineeringUnit;
+(function (EUEngineeringUnit) {
+    EUEngineeringUnit[EUEngineeringUnit["degree_celsius"] = 0] = "degree_celsius";
+    // to be continued
+})(EUEngineeringUnit || (exports.EUEngineeringUnit = EUEngineeringUnit = {}));
+// }}
+//# sourceMappingURL=address_space_ts.js.map

package/dist/api/address_space_ts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address_space_ts.js","sourceRoot":"","sources":["../../api/address_space_ts.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AA+BH,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IACzB,6EAAc,CAAA;IACd,kBAAkB;AACtB,CAAC,EAHW,iBAAiB,iCAAjB,iBAAiB,QAG5B;AA4FD,KAAK"}

package/dist/api/continuation_points/continuation_point_manager.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * @module node-opcua-server
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContinuationPointManager = void 0;
+const node_opcua_debug_1 = require("node-opcua-debug");
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const _warningLog = (0, node_opcua_debug_1.make_warningLog)("continuation_point_manager");
+let counter = 0;
+function make_key() {
+    // return crypto.randomBytes(32);
+    counter += 1;
+    return Buffer.from(counter.toString(), "utf-8");
+}
+/**
+ * from https://reference.opcfoundation.org/v104/Core/docs/Part4/7.6/
+ *
+ * A ContinuationPoint is used to pause a Browse, QueryFirst or HistoryRead operation and allow it to be restarted later by calling BrowseNext,
+ * QueryNext or HistoryRead.
+ * - Operations are paused when the number of results found exceeds the limits set by either the Client or the Server.
+ * - The Client specifies the maximum number of results per operation in the request message.
+ * - A Server shall not return more than this number of results but it may return fewer results.
+ * - The Server allocates a  ContinuationPoint if there are more results to return.
+ * - Servers shall support at least one ContinuationPoint per Session.
+ * - Servers specify a maximum number of ContinuationPoints per Session in the ServerCapabilities Object defined in OPC 10000-5.
+ * - ContinuationPoints remain active until
+ *     a/ the Client retrieves the remaining results,
+ *     b/ or, the Client releases the ContinuationPoint
+ *     c/ or the Session is closed.
+ * - A Server shall automatically free ContinuationPoints from prior requests from a Session if they are needed to process a new request
+ *   from this Session.
+ * - The Server returns a Bad_ContinuationPointInvalid error if a Client tries to use a ContinuationPoint that has been released.
+ * - A Client can avoid this situation by completing paused operations before starting new operations.
+ *   For Session-less Service invocations, the ContinuationPoints are shared across all Session-less Service invocations from all Clients.
+ *   The Server shall support at least the maximum number of ContinuationPoints it would allow for one Session.
+ *
+ * - Requests will often specify multiple operations that may or may not require a ContinuationPoint.
+ * - A Server shall process the operations until it uses the maximum number of continuation points in this response.
+ *   Once that happens the Server shall return a Bad_NoContinuationPoints error for any remaining operations. A Client can avoid
+ *   this situation by sending requests with a number of operations that do not exceed the maximum number  of ContinuationPoints
+ *   per Session defined for the Service in the ServerCapabilities Object defined in OPC 10000-5.
+ *   A Client restarts an operation by passing the ContinuationPoint back to the Server. Server should always be able to reuse the ContinuationPoint
+ *   provided so Servers shall never return Bad_NoContinuationPoints error when continuing a previously halted operation.
+ *   A ContinuationPoint is a subtype of the ByteString data type.
+ *
+ *
+ * for historical access: https://reference.opcfoundation.org/v104/Core/docs/Part11/6.3/
+ *
+ * The continuationPoint parameter in the HistoryRead Service is used to mark a point from which to continue
+ * the read if not all values could be returned in one response. The value is opaque for the Client and is
+ * only used to maintain the state information for the Server to continue from. *
+ *
+ * For HistoricalDataNode requests, a Server may use the timestamp of the last returned data item if the timestamp
+ * is unique. This can reduce the need in the Server to store state information for the continuation point.
+ * The Client specifies the maximum number of results per operation in the request Message. A Server shall
+ * not return more than this number of results but it may return fewer results. The Server allocates a
+ * ContinuationPoint if there are more results to return. The Server may return fewer results due to buffer issues
+ * or other internal constraints. It may also be required to return a continuationPoint due to HistoryRead
+ * parameter constraints. If a request is taking a long time to calculate and is approaching the timeout time, the
+ * Server may return partial results with a continuation point. This may be done if the calculation is going to
+ * take more time than the Client timeout. In some cases it may take longer than the Client timeout to calculate
+ * even one result. Then the Server may return zero results with a continuation point that allows the Server to
+ * resume the calculation on the next Client read call. For additional discussions regarding ContinuationPoints
+ * and HistoryRead please see the individual extensible HistoryReadDetails parameter in 6.4.
+ * If the Client specifies a ContinuationPoint, then the HistoryReadDetails parameter and the TimestampsToReturn
+ * parameter are ignored, because it does not make sense to request different parameters when continuing from a
+ * previous call. It is permissible to change the dataEncoding parameter with each request.
+ * If the Client specifies a ContinuationPoint that is no longer valid, then the Server shall return a
+ * Bad_ContinuationPointInvalid error.
+ * If the releaseContinuationPoints parameter is set in the request the Server shall not return any data and shall
+ * release all ContinuationPoints passed in the request. If the ContinuationPoint for an operation is missing or
+ * invalid then the StatusCode for the operation shall be Bad_ContinuationPointInvalid.
+ */
+class ContinuationPointManager {
+    _map;
+    constructor() {
+        this._map = new Map();
+    }
+    /**
+     * returns true if the current number of active continuation point has reached the limit
+     * specified in maxContinuationPoint
+     * @param maxBrowseContinuationPoint
+     */
+    hasReachedMaximum(maxContinuationPoint) {
+        if (maxContinuationPoint === 0) {
+            return false;
+        }
+        const nbContinuationPoints = this._map.size;
+        return nbContinuationPoints >= maxContinuationPoint;
+    }
+    registerHistoryReadRaw(numValuesPerNode, dataValues, continuationData) {
+        return this._register(numValuesPerNode, dataValues, continuationData);
+    }
+    getNextHistoryReadRaw(numValues, continuationData) {
+        return this._getNext(numValues, continuationData);
+    }
+    registerReferences(maxElements, values, continuationData) {
+        return this._register(maxElements, values, continuationData);
+    }
+    /**
+     * - releaseContinuationPoints = TRUE
+     *
+     *  passed continuationPoints shall be reset to free resources in
+     *  the Server. The continuation points are released and the results
+     *  and diagnosticInfos arrays are empty.
+     *
+     * - releaseContinuationPoints = FALSE
+     *
+     *   passed continuationPoints shall be used to get the next set of
+     *   browse information
+     */
+    getNextReferences(numValues, continuationData) {
+        return this._getNext(numValues, continuationData);
+    }
+    clearContinuationPoint(continuationPoint) {
+        const keyHash = continuationPoint.toString("utf-8");
+        if (this._map.has(keyHash)) {
+            this._map.delete(keyHash);
+        }
+    }
+    clearContinuationPoints(continuationPoints) {
+        for (const continuationPoint of continuationPoints) {
+            this.clearContinuationPoint(continuationPoint);
+        }
+        return {
+            continuationPoint: undefined,
+            values: [],
+            statusCode: node_opcua_status_code_1.StatusCodes.Good
+        };
+    }
+    clear() {
+        this._map.clear();
+    }
+    dispose() {
+        this.clear();
+    }
+    _register(maxValues, values, continuationData) {
+        // A Server shall automatically free ContinuationPoints from prior requests from a Session
+        // if they are needed to process a new request from this Session.
+        // if (!continuationData.continuationPoint && !continuationData.index) {
+        //     if (this._map.size > 0) {
+        //         warningLog("flushing pending continuationPoints", this._map.size);
+        //         this.clearContinuationPoints();
+        //     }
+        // }
+        if (continuationData.releaseContinuationPoints && !continuationData.continuationPoint) {
+            return {
+                continuationPoint: undefined,
+                values: [],
+                statusCode: node_opcua_status_code_1.StatusCodes.BadContinuationPointInvalid
+            };
+        }
+        if (maxValues >= 1) {
+            // now make sure that only the requested number of value is returned
+            if (values.length === 0) {
+                return {
+                    continuationPoint: undefined,
+                    values: null,
+                    statusCode: node_opcua_status_code_1.StatusCodes.GoodNoData
+                };
+            }
+        }
+        maxValues = maxValues || values.length;
+        if (maxValues >= values.length) {
+            return {
+                continuationPoint: undefined,
+                values,
+                statusCode: node_opcua_status_code_1.StatusCodes.Good
+            };
+        }
+        // split the array in two ( values)
+        const current_block = values.splice(0, maxValues);
+        const key = make_key();
+        const keyHash = key.toString("utf-8");
+        const result = {
+            continuationPoint: key,
+            values: current_block,
+            statusCode: node_opcua_status_code_1.StatusCodes.Good
+        };
+        // create
+        const data = {
+            maxElements: maxValues,
+            values: values
+        };
+        this._map.set(keyHash, data);
+        return result;
+    }
+    _getNext(numValues, continuationData) {
+        if (!continuationData.continuationPoint) {
+            return {
+                continuationPoint: undefined,
+                values: null,
+                statusCode: node_opcua_status_code_1.StatusCodes.BadContinuationPointInvalid
+            };
+        }
+        const keyHash = continuationData.continuationPoint.toString("utf-8");
+        const data = this._map.get(keyHash);
+        if (!data) {
+            return {
+                continuationPoint: undefined,
+                values: null,
+                statusCode: node_opcua_status_code_1.StatusCodes.BadContinuationPointInvalid
+            };
+        }
+        if (continuationData.releaseContinuationPoints) {
+            // releaseContinuationPoints expect immediate release of all continuation points
+            this._map.delete(keyHash);
+            return {
+                continuationPoint: undefined,
+                values: [],
+                statusCode: node_opcua_status_code_1.StatusCodes.Good
+            };
+        }
+        const values = data.values.splice(0, numValues || data.maxElements);
+        let continuationPoint = continuationData.continuationPoint;
+        if (data.values.length === 0) {
+            // no more data available for next call
+            this._map.delete(keyHash);
+            continuationPoint = undefined;
+        }
+        return {
+            continuationPoint,
+            values,
+            statusCode: node_opcua_status_code_1.StatusCodes.Good
+        };
+    }
+}
+exports.ContinuationPointManager = ContinuationPointManager;
+//# sourceMappingURL=continuation_point_manager.js.map