@hello.nrfcloud.com/proto-map 5.6.1 → 5.6.3

package/dist/lwm2m/check-lwm2m-rules.js

@@ -261,16 +261,16 @@ function _ts_values(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
-import chalk from "chalk";
-import { readFile, readdir, stat } from "node:fs/promises";
-import path, { parse } from "node:path";
-import assert from "node:assert/strict";
-import xml2js from "xml2js";
-import { exec } from "node:child_process";
-import { unwrapNestedArray } from "./unwrapNestedArray.js";
-import { LWM2MObjectDefinition } from "./LWM2MObjectDefinition.js";
-import { validate } from "../validate.js";
-import { parseRangeEnumeration } from "./parseRangeEnumeration.js";
+import chalk from 'chalk';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import path, { parse } from 'node:path';
+import assert from 'node:assert/strict';
+import xml2js from 'xml2js';
+import { exec } from 'node:child_process';
+import { unwrapNestedArray } from './unwrapNestedArray.js';
+import { LWM2MObjectDefinition } from './LWM2MObjectDefinition.js';
+import { validate } from '../validate.js';
+import { parseRangeEnumeration } from './parseRangeEnumeration.js';
 var v = validate(LWM2MObjectDefinition);
 var listLwm2mDefinitions = function() {
     var _ref = _async_to_generator(function(modelDir) {
@@ -301,13 +301,13 @@ var listLwm2mDefinitions = function() {
                                 case 0:
                                     _ref = _step.value;
                                     file = _ref;
-                                    if (!file.endsWith(".xml")) return [
+                                    if (!file.endsWith('.xml')) return [
                                         2,
                                         "continue"
                                     ];
-                                    console.log(chalk.white("\xb7"), chalk.white.bold(file));
-                                    assert.match(file, /^[0-9]+\.xml$/, "LwM2M object definition files must only have numbers in their file names");
-                                    console.log(chalk.green("✔"), chalk.gray("File name is correct"));
+                                    console.log(chalk.white('·'), chalk.white.bold(file));
+                                    assert.match(file, /^[0-9]+\.xml$/, 'LwM2M object definition files must only have numbers in their file names');
+                                    console.log(chalk.green('✔'), chalk.gray('File name is correct'));
                                     objectDefinitionFile = path.join(modelDir, file);
                                     return [
                                         4,
@@ -321,7 +321,7 @@ var listLwm2mDefinitions = function() {
                                     return [
                                         4,
                                         new Promise(function(resolve) {
-                                            return exec("xmllint --noout --schema ".concat(path.join(process.cwd(), "lwm2m", "LWM2M-v1_1.xsd"), " ").concat(objectDefinitionFile), function(error, _, stderr) {
+                                            return exec("xmllint --noout --schema ".concat(path.join(process.cwd(), 'lwm2m', 'LWM2M-v1_1.xsd'), " ").concat(objectDefinitionFile), function(error, _, stderr) {
                                                 if (error) {
                                                     console.error(stderr);
                                                     return resolve(false);
@@ -332,16 +332,16 @@ var listLwm2mDefinitions = function() {
                                     ];
                                 case 2:
                                     schemaValidated = _state.sent();
-                                    assert.equal(schemaValidated, true, "");
-                                    console.log(chalk.green("✔"), chalk.gray("Is a valid LwM2M object definition"));
+                                    assert.equal(schemaValidated, true, '');
+                                    console.log(chalk.green('✔'), chalk.gray('Is a valid LwM2M object definition'));
                                     ObjectID = parseInt(parse(objectDefinitionFile).name, 10);
-                                    assert.equal(ObjectID > 14200, true, "ObjectID must be greater than 14200");
-                                    assert.equal(ObjectID < 15000, true, "ObjectID must be smaller than 15000");
+                                    assert.equal(ObjectID > 14200, true, 'ObjectID must be greater than 14200');
+                                    assert.equal(ObjectID < 15000, true, 'ObjectID must be smaller than 15000');
                                     ObjectURN = "urn:oma:lwm2m:x:".concat(ObjectID);
                                     _ = xml2js.parseStringPromise;
                                     return [
                                         4,
-                                        readFile(objectDefinitionFile, "utf-8")
+                                        readFile(objectDefinitionFile, 'utf-8')
                                     ];
                                 case 3:
                                     return [
@@ -356,9 +356,9 @@ var listLwm2mDefinitions = function() {
                                     ]).LWM2M.Object;
                                     assert.equal(ObjectID.toString(), definition.ObjectID, "ObjectID must match filename");
                                     assert.equal(ObjectURN, definition.ObjectURN, "ObjectURN must follow schema");
-                                    console.log(chalk.green("✔"), chalk.blue(ObjectURN), chalk.gray("ObjectID and URN match filename and schema"));
+                                    console.log(chalk.green('✔'), chalk.blue(ObjectURN), chalk.gray('ObjectID and URN match filename and schema'));
                                     objectDef = _object_spread_props(_object_spread({}, definition), {
-                                        LWM2MVersion: "1.1",
+                                        LWM2MVersion: '1.1',
                                         Resources: definition.Resources.Item.reduce(function(resources, _param) {
                                             var $ = _param.$, item = _object_without_properties(_param, [
                                                 "$"
@@ -366,33 +366,33 @@ var listLwm2mDefinitions = function() {
                                             if (resources[$.ID] !== undefined) throw new Error("Duplicate resource ID: ".concat($.ID));
                                             if (item.RangeEnumeration.length > 0) {
                                                 var maybeRange = parseRangeEnumeration(item.RangeEnumeration);
-                                                if ("error" in maybeRange) throw maybeRange.error;
+                                                if ('error' in maybeRange) throw maybeRange.error;
                                             }
                                             return _object_spread_props(_object_spread({}, resources), _define_property({}, $.ID, item));
                                         }, {})
                                     });
                                     maybeValid = v(objectDef);
-                                    if ("errors" in maybeValid) {
+                                    if ('errors' in maybeValid) {
                                         console.error(maybeValid.errors);
                                         throw new Error("The definition should be valid!");
                                     }
-                                    console.log(chalk.green("✔"), chalk.gray("LwM2M limitations are honored"));
+                                    console.log(chalk.green('✔'), chalk.gray('LwM2M limitations are honored'));
                                     defs.push(maybeValid.value);
                                     _maybeValid_value = maybeValid.value, Name = _maybeValid_value.Name, Resources = _maybeValid_value.Resources;
                                     TimeResources = Object.values(Resources).filter(function(param) {
                                         var Type = param.Type;
-                                        return Type === "Time";
+                                        return Type === 'Time';
                                     });
-                                    assert.equal(TimeResources.length, 1, "Objects must define one Time resource");
-                                    assert.equal((_TimeResources_ = TimeResources[0]) === null || _TimeResources_ === void 0 ? void 0 : _TimeResources_.Mandatory, "Mandatory", "The Time resources must be mandatory.");
-                                    console.log(chalk.green("✔"), chalk.gray("Object has one time resource (".concat((_TimeResources_1 = TimeResources[0]) === null || _TimeResources_1 === void 0 ? void 0 : _TimeResources_1.Name, ")")));
+                                    assert.equal(TimeResources.length, 1, 'Objects must define one Time resource');
+                                    assert.equal((_TimeResources_ = TimeResources[0]) === null || _TimeResources_ === void 0 ? void 0 : _TimeResources_.Mandatory, 'Mandatory', 'The Time resources must be mandatory.');
+                                    console.log(chalk.green('✔'), chalk.gray("Object has one time resource (".concat((_TimeResources_1 = TimeResources[0]) === null || _TimeResources_1 === void 0 ? void 0 : _TimeResources_1.Name, ")")));
                                     console.log("".concat(chalk.yellow(ObjectID), ":"), chalk.white(Name));
                                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                                     try {
                                         for(_iterator = Object.entries(Resources)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true){
                                             _step_value = _sliced_to_array(_step1.value, 2), id = _step_value[0], resource = _step_value[1];
                                             ;
-                                            console.log("".concat(chalk.gray(ObjectID), ".").concat(chalk.yellow(id), ":"), chalk.white(resource.Name), "".concat(chalk.gray(resource.Type), " ").concat(chalk.gray("(".concat((_resource_Units = resource.Units) !== null && _resource_Units !== void 0 ? _resource_Units : "no unit", ")"))));
+                                            console.log("".concat(chalk.gray(ObjectID), ".").concat(chalk.yellow(id), ":"), chalk.white(resource.Name), "".concat(chalk.gray(resource.Type), " ").concat(chalk.gray("(".concat((_resource_Units = resource.Units) !== null && _resource_Units !== void 0 ? _resource_Units : 'no unit', ")"))));
                                         }
                                     } catch (err) {
                                         _didIteratorError = true;
@@ -473,8 +473,8 @@ var listLwm2mDefinitions = function() {
     };
 }();
 // LwM2M
-console.log(chalk.gray("LwM2M rules check"));
-console.log("");
-var lwm2mDir = path.join(process.cwd(), "lwm2m");
+console.log(chalk.gray('LwM2M rules check'));
+console.log('');
+var lwm2mDir = path.join(process.cwd(), 'lwm2m');
 var lwm2mDefinitions = await listLwm2mDefinitions(lwm2mDir);
-assert.equal(lwm2mDefinitions.length > 0, true, "LwM2M objects must be defined.");
+assert.equal(lwm2mDefinitions.length > 0, true, 'LwM2M objects must be defined.');

package/dist/lwm2m/definitions.js

@@ -32,7 +32,7 @@ var _obj;
                 min: -90,
                 max: 90
             },
-            Units: "\xb0"
+            Units: "\u00B0"
         },
         /**
              * Longitude (Float)
@@ -51,7 +51,7 @@ var _obj;
                 min: -180,
                 max: 180
             },
-            Units: "\xb0"
+            Units: "\u00B0"
         },
         /**
              * Altitude (Float)
@@ -106,7 +106,7 @@ var _obj;
                 min: 0,
                 max: 360
             },
-            Units: "\xb0"
+            Units: "\u00B0"
         },
         /**
              * Source (String)
@@ -432,7 +432,7 @@ var _obj;
             Mandatory: false,
             Type: ResourceType.Float,
             Description: "Environmental temperature in Celsius. Examples: 23.5, -10.2.",
-            Units: "\xb0C"
+            Units: "\u00B0C"
         },
         /**
              * Humidity (Float)

package/dist/lwm2m/fromXML2JSON.js

@@ -147,9 +147,9 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import xml2js from "xml2js";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
+import xml2js from 'xml2js';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
 /**
  * From XML to JSON
  */ export var fromXML2JSON = function() {
@@ -170,7 +170,7 @@ import path from "node:path";
                     _ = xml2js.parseStringPromise;
                     return [
                         4,
-                        readFile(subDir("lwm2m", "".concat(id, ".xml")), "utf-8")
+                        readFile(subDir('lwm2m', "".concat(id, ".xml")), 'utf-8')
                     ];
                 case 1:
                     return [

package/dist/lwm2m/instanceTs.js

@@ -1,5 +1,5 @@
-import { definitions } from "./definitions.js";
-import { timestampResources } from "./timestampResources.js";
+import { definitions } from './definitions.js';
+import { timestampResources } from './timestampResources.js';
 export var instanceTs = function(instance) {
     var definition = definitions[instance.ObjectID];
     var tsResourceId = timestampResources[definition.ObjectID]// All registered objects must have a timestamp resource

package/dist/lwm2m/instanceTs.spec.js

@@ -1,16 +1,16 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { instanceTs } from "./instanceTs.js";
-void describe("instanceTs()", function() {
-    void it("should return the timestamp of the instance", function() {
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { instanceTs } from './instanceTs.js';
+void describe('instanceTs()', function() {
+    void it('should return the timestamp of the instance', function() {
         return assert.equal(instanceTs({
             ObjectID: 14210,
-            ObjectVersion: "1.0",
+            ObjectVersion: '1.0',
             Resources: {
-                "0": 3.5399999618530273,
-                "1": 4.168000221252441,
-                "99": "2024-02-23T10:18:20.474Z"
+                '0': 3.5399999618530273,
+                '1': 4.168000221252441,
+                '99': '2024-02-23T10:18:20.474Z'
             }
-        }).getTime(), new Date("2024-02-23T10:18:20.474Z").getTime());
+        }).getTime(), new Date('2024-02-23T10:18:20.474Z').getTime());
     });
 });

package/dist/lwm2m/isRegisteredLwM2MObject.js

@@ -1,3 +1,3 @@
-import { validators } from "./validators.js";
-import { validate } from "./validate.js";
+import { validators } from './validators.js';
+import { validate } from './validate.js';
 export var isRegisteredLwM2MObject = validate(validators);

package/dist/lwm2m/isRegisteredLwM2MObject.spec.js

@@ -1,11 +1,11 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { isRegisteredLwM2MObject } from "./isRegisteredLwM2MObject.js";
-void describe("isRegisteredLwM2MObject()", function() {
-    void it("should validate a LwM2M object", function() {
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { isRegisteredLwM2MObject } from './isRegisteredLwM2MObject.js';
+void describe('isRegisteredLwM2MObject()', function() {
+    void it('should validate a LwM2M object', function() {
         var o = {
             ObjectID: 14201,
-            ObjectVersion: "1.0",
+            ObjectVersion: '1.0',
             Resources: {
                 0: 33.98771459323253,
                 1: -84.50632147267358,
@@ -13,29 +13,29 @@ void describe("isRegisteredLwM2MObject()", function() {
                 3: 11.317643165588379,
                 4: 0.03478508070111275,
                 5: 90.31222534179688,
-                6: "GNSS",
+                6: 'GNSS',
                 99: new Date(1699049744000)
             }
         };
         assert.equal(isRegisteredLwM2MObject(o), true);
     });
-    void it("should validate a LwM2M object with optional resources", function() {
+    void it('should validate a LwM2M object with optional resources', function() {
         var o = {
             ObjectID: 14201,
-            ObjectVersion: "1.0",
+            ObjectVersion: '1.0',
             Resources: {
                 0: 33.98771459323253,
                 1: -84.50632147267358,
-                6: "GNSS",
+                6: 'GNSS',
                 99: new Date(1699049744000)
             }
         };
         assert.equal(isRegisteredLwM2MObject(o), true);
     });
-    void it("should not validate an unknown LwM2M object", function() {
+    void it('should not validate an unknown LwM2M object', function() {
         var o = {
             ObjectID: 666,
-            ObjectVersion: "1.0",
+            ObjectVersion: '1.0',
             Resources: {
                 0: 42
             }

package/dist/lwm2m/parseRangeEnumeration.js

@@ -1,4 +1,4 @@
-import { RangeEnumerationRegExp } from "./LWM2MObjectDefinition.js";
+import { RangeEnumerationRegExp } from './LWM2MObjectDefinition.js';
 export var parseRangeEnumeration = function(re) {
     var match = RangeEnumerationRegExp.exec(re);
     if (match === null) return {

package/dist/lwm2m/parseRangeEnumeration.spec.js

@@ -1,10 +1,10 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { parseRangeEnumeration } from "./parseRangeEnumeration.js";
-import { RangeEnumerationRegExp } from "./LWM2MObjectDefinition.js";
-void describe("parseRangeEnumeration()", function() {
-    void it("should parse valid range enumeration", function() {
-        var result = parseRangeEnumeration("1..10");
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseRangeEnumeration } from './parseRangeEnumeration.js';
+import { RangeEnumerationRegExp } from './LWM2MObjectDefinition.js';
+void describe('parseRangeEnumeration()', function() {
+    void it('should parse valid range enumeration', function() {
+        var result = parseRangeEnumeration('1..10');
         assert.deepEqual(result, {
             range: {
                 min: 1,
@@ -12,14 +12,14 @@ void describe("parseRangeEnumeration()", function() {
             }
         });
     });
-    void it("should handle invalid range enumeration", function() {
-        var result = parseRangeEnumeration("10..1");
+    void it('should handle invalid range enumeration', function() {
+        var result = parseRangeEnumeration('10..1');
         assert.deepEqual(result, {
             error: new Error("'min' must be smaller than 'max' in RangeEnumeration '10..1'!")
         });
     });
-    void it("should handle invalid input", function() {
-        var result = parseRangeEnumeration("invalid");
+    void it('should handle invalid input', function() {
+        var result = parseRangeEnumeration('invalid');
         assert.deepEqual(result, {
             error: new Error("Could not match 'invalid' against ".concat(RangeEnumerationRegExp, "!"))
         });

package/dist/lwm2m/unwrapNestedArray.js

@@ -99,10 +99,10 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 export var unwrapNestedArray = function(object) {
-    if (typeof object === "string") return object;
+    if (typeof object === 'string') return object;
     return Object.entries(object).reduce(function(result, param) {
         var _param = _sliced_to_array(param, 2), k = _param[0], v = _param[1];
-        if (typeof v === "string") return _object_spread_props(_object_spread({}, result), _define_property({}, k, v));
+        if (typeof v === 'string') return _object_spread_props(_object_spread({}, result), _define_property({}, k, v));
         if (Array.isArray(v)) {
             if (v.length === 1) {
                 return _object_spread_props(_object_spread({}, result), _define_property({}, k, unwrapNestedArray(v[0])));