node-opcua-utils 2.90.1 → 2.98.1

package/dist/object_classname.js

@@ -1,16 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getObjectClassName = void 0;
-/**
- * @module node-opcua-utils
- */
-/**
- * @method getObjectClassName
- * @param obj
- * @return {string}
- */
-function getObjectClassName(obj) {
-    return Object.prototype.toString.call(obj).slice(8, -1);
-}
-exports.getObjectClassName = getObjectClassName;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObjectClassName = void 0;
+/**
+ * @module node-opcua-utils
+ */
+/**
+ * @method getObjectClassName
+ * @param obj
+ * @return {string}
+ */
+function getObjectClassName(obj) {
+    return Object.prototype.toString.call(obj).slice(8, -1);
+}
+exports.getObjectClassName = getObjectClassName;
 //# sourceMappingURL=object_classname.js.map

package/dist/replace_buffer_with_hex_dump.d.ts

@@ -1,6 +1,6 @@
-/**
- * @module node-opcua-utils
- */
-export declare function replaceBufferWithHexDump(obj: Record<string, {
-    toString(format: string): void;
-}>): any;
+/**
+ * @module node-opcua-utils
+ */
+export declare function replaceBufferWithHexDump(obj: Record<string, {
+    toString(format: string): void;
+}>): any;

package/dist/replace_buffer_with_hex_dump.js

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceBufferWithHexDump = void 0;
-/**
- * @module node-opcua-utils
- */
-function replaceBufferWithHexDump(obj) {
-    for (const p in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, p)) {
-            if (obj[p] instanceof Buffer) {
-                obj[p] = "<BUFFER>" + obj[p].toString("hex") + "</BUFFER>";
-            }
-            else if (typeof obj[p] === "object") {
-                replaceBufferWithHexDump(obj[p]);
-            }
-        }
-    }
-    return obj;
-}
-exports.replaceBufferWithHexDump = replaceBufferWithHexDump;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceBufferWithHexDump = void 0;
+/**
+ * @module node-opcua-utils
+ */
+function replaceBufferWithHexDump(obj) {
+    for (const p in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, p)) {
+            if (obj[p] instanceof Buffer) {
+                obj[p] = "<BUFFER>" + obj[p].toString("hex") + "</BUFFER>";
+            }
+            else if (typeof obj[p] === "object") {
+                replaceBufferWithHexDump(obj[p]);
+            }
+        }
+    }
+    return obj;
+}
+exports.replaceBufferWithHexDump = replaceBufferWithHexDump;
 //# sourceMappingURL=replace_buffer_with_hex_dump.js.map

package/dist/set_deprecated.d.ts

@@ -1,2 +1,2 @@
-import { FunctionVariadic } from "./function_variadic";
-export declare function setDeprecated(constructor: FunctionVariadic, methodName: string, helpString: string): void;
+import { FunctionVariadic } from "./function_variadic";
+export declare function setDeprecated(constructor: FunctionVariadic, methodName: string, helpString: string): void;

package/dist/set_deprecated.js

@@ -1,26 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setDeprecated = void 0;
-/**
- * @module node-opcua-utils
- */
-// tslint:disable:ban-types
-const chalk = require("chalk");
-const node_opcua_assert_1 = require("node-opcua-assert");
-/* istanbul ignore next */
-function setDeprecated(constructor, methodName, helpString) {
-    const oldMethod = constructor.prototype[methodName];
-    (0, node_opcua_assert_1.assert)(oldMethod instanceof Function, "expecting a valid " + methodName + "method on class " + constructor.constructor.name);
-    let counter = 0;
-    constructor.prototype[methodName] = function (...args) {
-        if (counter % 1000 === 0) {
-            // tslint:disable:no-console
-            console.log(chalk.green("Warning !"), chalk.green(chalk.bold(constructor.name + "#" + methodName), " is now deprecated"));
-            console.log("         ", helpString);
-        }
-        counter++;
-        return oldMethod.call(this, ...args);
-    };
-}
-exports.setDeprecated = setDeprecated;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDeprecated = void 0;
+/**
+ * @module node-opcua-utils
+ */
+// tslint:disable:ban-types
+const chalk = require("chalk");
+const node_opcua_assert_1 = require("node-opcua-assert");
+/* istanbul ignore next */
+function setDeprecated(constructor, methodName, helpString) {
+    const oldMethod = constructor.prototype[methodName];
+    (0, node_opcua_assert_1.assert)(oldMethod instanceof Function, "expecting a valid " + methodName + "method on class " + constructor.constructor.name);
+    let counter = 0;
+    constructor.prototype[methodName] = function (...args) {
+        if (counter % 1000 === 0) {
+            // tslint:disable:no-console
+            console.log(chalk.green("Warning !"), chalk.green(chalk.bold(constructor.name + "#" + methodName), " is now deprecated"));
+            console.log("         ", helpString);
+        }
+        counter++;
+        return oldMethod.call(this, ...args);
+    };
+}
+exports.setDeprecated = setDeprecated;
 //# sourceMappingURL=set_deprecated.js.map

package/dist/string_utils.d.ts

@@ -1,66 +1,66 @@
-/**
- * @module node-opcua-utils
- */
-export declare function capitalizeFirstLetter(str: string): string;
-export declare function isUpperCaseChar(c: string): boolean;
-export declare function isAlpha(c: string): boolean;
-export declare function countUpperCaseSlow(str: string): number;
-export declare function countAlphaSlow(str: string): number;
-export declare function countUpperCase(str: string): number;
-export declare function countAlpha(str: string): number;
-/**
- *
- * lowerFirstLetter convert a OPCUA Identifier to a javascript Identifier
- *
- * @summary
- *
- *  OPCUA and Javascript use two different rules to build identifiers.
- *
- *  OPCUA Identifier usually starts with a upper case letter and word are join together, this is known as
- *  the Pascal case, or CapitalizedWords convention.  (for instance HelloWorld)
- *  But sometime, OPCUA identifiers do not follow this convention strictly and we can find various
- *  other convention being applied such as underscore between word, or addition of ACRONYMIC prefixes.
- *  On it's own, this causes great confusion and inconsistency in programming style.
- *
- *  Javascript uses a slightly different convention called camelCase where word are joined together
- *  and inner words starts with a capital letter whereas first word starts with a lower case letter.
- *  (for instance helloWorld)
- *
- *  In node-opcua we have taken the opinionated decision to consistently use camelCase convention for
- *  object properties so that all the code look nice and consistent.
- *  the lowerFirstLetter method can be used to easily convert from the OPCUA  naming convention
- *  to javascript naming convention by applying the following rules.
- *
- *   * each ascii sequence in a identifier will be converted to lower camel case.
- *   * when an identifier only contains upper case letter then it will be untouched. ( i.e CQDF => CQFD)
- *     (this rules helps to preserve acronyms)
- *   * when a identifier starts with more than one UpperCase letter but still contain lowercase letter
- *     then the first Uppercase letter excluding the last one will be converted to lower case
- *     ( ie:  EURange = > euRange)
- *   * when a identifier contains several sequences delimited with underscores (_) the above rules
- *     will be applied to each of the element of the sequence
- *     ( ie: ALM_FlowOutOfTolerance => ALM_flowOutOfTolerance ( ALM=>ALM , FlowOutOfTolerance=>flowOutOfTolerance)
- *
- * @reference
- *    * https://en.wikipedia.org/wiki/Camel_case
- *    * https://en.wikipedia.org/wiki/Hungarian_notation
- *    * http://wiki.c2.com/?UnderscoreVersusCapitalAndLowerCaseVariableNaming
- *
- *
- *
- * @example
- *  HelloWorld => helloWorld
- *  XAxis      => xAxis
- *  EURange    => euRange
- *  DATE       => DATE
- *  XYZ        => XYZ
- *  AB         => AB
- *  Ab         => ab
- *  A          => a
- *  T1ABC8     => T1ABC8
- *  F_ABC_D    => F_ABC_D
- *  ALM_Timeout    => ALM_timeout
- *  SV_GasOn       => SV_gasOn
- *  DI_VAL_FlowImp => DI_VAL_flowImp
- */
-export declare function lowerFirstLetter(str: string): string;
+/**
+ * @module node-opcua-utils
+ */
+export declare function capitalizeFirstLetter(str: string): string;
+export declare function isUpperCaseChar(c: string): boolean;
+export declare function isAlpha(c: string): boolean;
+export declare function countUpperCaseSlow(str: string): number;
+export declare function countAlphaSlow(str: string): number;
+export declare function countUpperCase(str: string): number;
+export declare function countAlpha(str: string): number;
+/**
+ *
+ * lowerFirstLetter convert a OPCUA Identifier to a javascript Identifier
+ *
+ * @summary
+ *
+ *  OPCUA and Javascript use two different rules to build identifiers.
+ *
+ *  OPCUA Identifier usually starts with a upper case letter and word are join together, this is known as
+ *  the Pascal case, or CapitalizedWords convention.  (for instance HelloWorld)
+ *  But sometime, OPCUA identifiers do not follow this convention strictly and we can find various
+ *  other convention being applied such as underscore between word, or addition of ACRONYMIC prefixes.
+ *  On it's own, this causes great confusion and inconsistency in programming style.
+ *
+ *  Javascript uses a slightly different convention called camelCase where word are joined together
+ *  and inner words starts with a capital letter whereas first word starts with a lower case letter.
+ *  (for instance helloWorld)
+ *
+ *  In node-opcua we have taken the opinionated decision to consistently use camelCase convention for
+ *  object properties so that all the code look nice and consistent.
+ *  the lowerFirstLetter method can be used to easily convert from the OPCUA  naming convention
+ *  to javascript naming convention by applying the following rules.
+ *
+ *   * each ascii sequence in a identifier will be converted to lower camel case.
+ *   * when an identifier only contains upper case letter then it will be untouched. ( i.e CQDF => CQFD)
+ *     (this rules helps to preserve acronyms)
+ *   * when a identifier starts with more than one UpperCase letter but still contain lowercase letter
+ *     then the first Uppercase letter excluding the last one will be converted to lower case
+ *     ( ie:  EURange = > euRange)
+ *   * when a identifier contains several sequences delimited with underscores (_) the above rules
+ *     will be applied to each of the element of the sequence
+ *     ( ie: ALM_FlowOutOfTolerance => ALM_flowOutOfTolerance ( ALM=>ALM , FlowOutOfTolerance=>flowOutOfTolerance)
+ *
+ * @reference
+ *    * https://en.wikipedia.org/wiki/Camel_case
+ *    * https://en.wikipedia.org/wiki/Hungarian_notation
+ *    * http://wiki.c2.com/?UnderscoreVersusCapitalAndLowerCaseVariableNaming
+ *
+ *
+ *
+ * @example
+ *  HelloWorld => helloWorld
+ *  XAxis      => xAxis
+ *  EURange    => euRange
+ *  DATE       => DATE
+ *  XYZ        => XYZ
+ *  AB         => AB
+ *  Ab         => ab
+ *  A          => a
+ *  T1ABC8     => T1ABC8
+ *  F_ABC_D    => F_ABC_D
+ *  ALM_Timeout    => ALM_timeout
+ *  SV_GasOn       => SV_gasOn
+ *  DI_VAL_FlowImp => DI_VAL_flowImp
+ */
+export declare function lowerFirstLetter(str: string): string;

package/dist/string_utils.js

@@ -1,128 +1,128 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lowerFirstLetter = exports.countAlpha = exports.countUpperCase = exports.countAlphaSlow = exports.countUpperCaseSlow = exports.isAlpha = exports.isUpperCaseChar = exports.capitalizeFirstLetter = void 0;
-/**
- * @module node-opcua-utils
- */
-// tslint:disable:variable-name
-function capitalizeFirstLetter(str) {
-    if (str == null) {
-        return str;
-    }
-    return str.substring(0, 1).toUpperCase() + str.substring(1);
-}
-exports.capitalizeFirstLetter = capitalizeFirstLetter;
-const ACode = "A".charCodeAt(0);
-const ZCode = "Z".charCodeAt(0);
-function isUpperCaseChar(c) {
-    const code = c.charCodeAt(0);
-    return code >= ACode && code <= ZCode;
-}
-exports.isUpperCaseChar = isUpperCaseChar;
-const aCode = "a".charCodeAt(0);
-const zCode = "z".charCodeAt(0);
-function isAlpha(c) {
-    const code = c.charCodeAt(0);
-    return (code >= ACode && code <= ZCode) || (code >= aCode && code <= zCode);
-}
-exports.isAlpha = isAlpha;
-function countUpperCaseSlow(str) {
-    return str.split("").reduce((p, c) => p + (isUpperCaseChar(c) ? 1 : 0), 0);
-}
-exports.countUpperCaseSlow = countUpperCaseSlow;
-function countAlphaSlow(str) {
-    return str.split("").reduce((p, c) => p + (isAlpha(c) ? 1 : 0), 0);
-}
-exports.countAlphaSlow = countAlphaSlow;
-function countUpperCase(str) {
-    let count = 0;
-    const n = str.length;
-    for (let i = 0; i < n; i++) {
-        count += isUpperCaseChar(str[i]) ? 1 : 0;
-    }
-    return count;
-}
-exports.countUpperCase = countUpperCase;
-function countAlpha(str) {
-    let count = 0;
-    const n = str.length;
-    for (let i = 0; i < n; i++) {
-        count += isAlpha(str[i]) ? 1 : 0;
-    }
-    return count;
-}
-exports.countAlpha = countAlpha;
-/**
- *
- * lowerFirstLetter convert a OPCUA Identifier to a javascript Identifier
- *
- * @summary
- *
- *  OPCUA and Javascript use two different rules to build identifiers.
- *
- *  OPCUA Identifier usually starts with a upper case letter and word are join together, this is known as
- *  the Pascal case, or CapitalizedWords convention.  (for instance HelloWorld)
- *  But sometime, OPCUA identifiers do not follow this convention strictly and we can find various
- *  other convention being applied such as underscore between word, or addition of ACRONYMIC prefixes.
- *  On it's own, this causes great confusion and inconsistency in programming style.
- *
- *  Javascript uses a slightly different convention called camelCase where word are joined together
- *  and inner words starts with a capital letter whereas first word starts with a lower case letter.
- *  (for instance helloWorld)
- *
- *  In node-opcua we have taken the opinionated decision to consistently use camelCase convention for
- *  object properties so that all the code look nice and consistent.
- *  the lowerFirstLetter method can be used to easily convert from the OPCUA  naming convention
- *  to javascript naming convention by applying the following rules.
- *
- *   * each ascii sequence in a identifier will be converted to lower camel case.
- *   * when an identifier only contains upper case letter then it will be untouched. ( i.e CQDF => CQFD)
- *     (this rules helps to preserve acronyms)
- *   * when a identifier starts with more than one UpperCase letter but still contain lowercase letter
- *     then the first Uppercase letter excluding the last one will be converted to lower case
- *     ( ie:  EURange = > euRange)
- *   * when a identifier contains several sequences delimited with underscores (_) the above rules
- *     will be applied to each of the element of the sequence
- *     ( ie: ALM_FlowOutOfTolerance => ALM_flowOutOfTolerance ( ALM=>ALM , FlowOutOfTolerance=>flowOutOfTolerance)
- *
- * @reference
- *    * https://en.wikipedia.org/wiki/Camel_case
- *    * https://en.wikipedia.org/wiki/Hungarian_notation
- *    * http://wiki.c2.com/?UnderscoreVersusCapitalAndLowerCaseVariableNaming
- *
- *
- *
- * @example
- *  HelloWorld => helloWorld
- *  XAxis      => xAxis
- *  EURange    => euRange
- *  DATE       => DATE
- *  XYZ        => XYZ
- *  AB         => AB
- *  Ab         => ab
- *  A          => a
- *  T1ABC8     => T1ABC8
- *  F_ABC_D    => F_ABC_D
- *  ALM_Timeout    => ALM_timeout
- *  SV_GasOn       => SV_gasOn
- *  DI_VAL_FlowImp => DI_VAL_flowImp
- */
-function lowerFirstLetter(str) {
-    if (str == null) {
-        return str;
-    }
-    // at least, 2 all upper
-    if (str.length >= 2 && countUpperCase(str) === countAlpha(str)) {
-        return str;
-    }
-    if (str.match(/_/)) {
-        return str.split("_").map(lowerFirstLetter).join("_");
-    }
-    let result = str.substring(0, 1).toLowerCase() + str.substring(1);
-    if (result.length > 3 && isUpperCaseChar(str[1]) && isUpperCaseChar(str[2])) {
-        result = str.substring(0, 2).toLowerCase() + str.substring(2);
-    }
-    return result;
-}
-exports.lowerFirstLetter = lowerFirstLetter;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lowerFirstLetter = exports.countAlpha = exports.countUpperCase = exports.countAlphaSlow = exports.countUpperCaseSlow = exports.isAlpha = exports.isUpperCaseChar = exports.capitalizeFirstLetter = void 0;
+/**
+ * @module node-opcua-utils
+ */
+// tslint:disable:variable-name
+function capitalizeFirstLetter(str) {
+    if (str == null) {
+        return str;
+    }
+    return str.substring(0, 1).toUpperCase() + str.substring(1);
+}
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+const ACode = "A".charCodeAt(0);
+const ZCode = "Z".charCodeAt(0);
+function isUpperCaseChar(c) {
+    const code = c.charCodeAt(0);
+    return code >= ACode && code <= ZCode;
+}
+exports.isUpperCaseChar = isUpperCaseChar;
+const aCode = "a".charCodeAt(0);
+const zCode = "z".charCodeAt(0);
+function isAlpha(c) {
+    const code = c.charCodeAt(0);
+    return (code >= ACode && code <= ZCode) || (code >= aCode && code <= zCode);
+}
+exports.isAlpha = isAlpha;
+function countUpperCaseSlow(str) {
+    return str.split("").reduce((p, c) => p + (isUpperCaseChar(c) ? 1 : 0), 0);
+}
+exports.countUpperCaseSlow = countUpperCaseSlow;
+function countAlphaSlow(str) {
+    return str.split("").reduce((p, c) => p + (isAlpha(c) ? 1 : 0), 0);
+}
+exports.countAlphaSlow = countAlphaSlow;
+function countUpperCase(str) {
+    let count = 0;
+    const n = str.length;
+    for (let i = 0; i < n; i++) {
+        count += isUpperCaseChar(str[i]) ? 1 : 0;
+    }
+    return count;
+}
+exports.countUpperCase = countUpperCase;
+function countAlpha(str) {
+    let count = 0;
+    const n = str.length;
+    for (let i = 0; i < n; i++) {
+        count += isAlpha(str[i]) ? 1 : 0;
+    }
+    return count;
+}
+exports.countAlpha = countAlpha;
+/**
+ *
+ * lowerFirstLetter convert a OPCUA Identifier to a javascript Identifier
+ *
+ * @summary
+ *
+ *  OPCUA and Javascript use two different rules to build identifiers.
+ *
+ *  OPCUA Identifier usually starts with a upper case letter and word are join together, this is known as
+ *  the Pascal case, or CapitalizedWords convention.  (for instance HelloWorld)
+ *  But sometime, OPCUA identifiers do not follow this convention strictly and we can find various
+ *  other convention being applied such as underscore between word, or addition of ACRONYMIC prefixes.
+ *  On it's own, this causes great confusion and inconsistency in programming style.
+ *
+ *  Javascript uses a slightly different convention called camelCase where word are joined together
+ *  and inner words starts with a capital letter whereas first word starts with a lower case letter.
+ *  (for instance helloWorld)
+ *
+ *  In node-opcua we have taken the opinionated decision to consistently use camelCase convention for
+ *  object properties so that all the code look nice and consistent.
+ *  the lowerFirstLetter method can be used to easily convert from the OPCUA  naming convention
+ *  to javascript naming convention by applying the following rules.
+ *
+ *   * each ascii sequence in a identifier will be converted to lower camel case.
+ *   * when an identifier only contains upper case letter then it will be untouched. ( i.e CQDF => CQFD)
+ *     (this rules helps to preserve acronyms)
+ *   * when a identifier starts with more than one UpperCase letter but still contain lowercase letter
+ *     then the first Uppercase letter excluding the last one will be converted to lower case
+ *     ( ie:  EURange = > euRange)
+ *   * when a identifier contains several sequences delimited with underscores (_) the above rules
+ *     will be applied to each of the element of the sequence
+ *     ( ie: ALM_FlowOutOfTolerance => ALM_flowOutOfTolerance ( ALM=>ALM , FlowOutOfTolerance=>flowOutOfTolerance)
+ *
+ * @reference
+ *    * https://en.wikipedia.org/wiki/Camel_case
+ *    * https://en.wikipedia.org/wiki/Hungarian_notation
+ *    * http://wiki.c2.com/?UnderscoreVersusCapitalAndLowerCaseVariableNaming
+ *
+ *
+ *
+ * @example
+ *  HelloWorld => helloWorld
+ *  XAxis      => xAxis
+ *  EURange    => euRange
+ *  DATE       => DATE
+ *  XYZ        => XYZ
+ *  AB         => AB
+ *  Ab         => ab
+ *  A          => a
+ *  T1ABC8     => T1ABC8
+ *  F_ABC_D    => F_ABC_D
+ *  ALM_Timeout    => ALM_timeout
+ *  SV_GasOn       => SV_gasOn
+ *  DI_VAL_FlowImp => DI_VAL_flowImp
+ */
+function lowerFirstLetter(str) {
+    if (str == null) {
+        return str;
+    }
+    // at least, 2 all upper
+    if (str.length >= 2 && countUpperCase(str) === countAlpha(str)) {
+        return str;
+    }
+    if (str.match(/_/)) {
+        return str.split("_").map(lowerFirstLetter).join("_");
+    }
+    let result = str.substring(0, 1).toLowerCase() + str.substring(1);
+    if (result.length > 3 && isUpperCaseChar(str[1]) && isUpperCaseChar(str[2])) {
+        result = str.substring(0, 2).toLowerCase() + str.substring(2);
+    }
+    return result;
+}
+exports.lowerFirstLetter = lowerFirstLetter;
 //# sourceMappingURL=string_utils.js.map

package/dist/timestamp.d.ts

@@ -1 +1 @@
-export declare function timestamp(): string;
+export declare function timestamp(): string;

package/dist/timestamp.js

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.timestamp = void 0;
-function w(s, length) {
-    return ("" + s).padStart(length, "0");
-}
-function t(d) {
-    return w(d.getUTCHours(), 2) + ":" + w(d.getUTCMinutes(), 2) + ":" + w(d.getUTCSeconds(), 2) + ":" + w(d.getMilliseconds(), 3);
-}
-function timestamp() {
-    return t(new Date());
-}
-exports.timestamp = timestamp;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timestamp = void 0;
+function w(s, length) {
+    return ("" + s).padStart(length, "0");
+}
+function t(d) {
+    return w(d.getUTCHours(), 2) + ":" + w(d.getUTCMinutes(), 2) + ":" + w(d.getUTCSeconds(), 2) + ":" + w(d.getMilliseconds(), 3);
+}
+function timestamp() {
+    return t(new Date());
+}
+exports.timestamp = timestamp;
 //# sourceMappingURL=timestamp.js.map