@hello.nrfcloud.com/proto-map 4.0.0

package/dist/lwm2m/fromXML2JSON.js

@@ -0,0 +1,194 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import xml2js from "xml2js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+/**
+ * From XML to JSON
+ */ export var fromXML2JSON = function() {
+    var _ref = _async_to_generator(function(id) {
+        var _path, baseDir, subDir, jsonObject, _;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    baseDir = process.cwd();
+                    subDir = function() {
+                        for(var _len = arguments.length, tree = new Array(_len), _key = 0; _key < _len; _key++){
+                            tree[_key] = arguments[_key];
+                        }
+                        return (_path = path).join.apply(_path, [
+                            baseDir
+                        ].concat(_to_consumable_array(tree)));
+                    };
+                    _ = xml2js.parseStringPromise;
+                    return [
+                        4,
+                        readFile(subDir("lwm2m", "".concat(id, ".xml")), "utf-8")
+                    ];
+                case 1:
+                    return [
+                        4,
+                        _.apply(xml2js, [
+                            _state.sent()
+                        ])
+                    ];
+                case 2:
+                    jsonObject = _state.sent();
+                    return [
+                        2,
+                        jsonObject.LWM2M.Object[0]
+                    ];
+            }
+        });
+    });
+    return function fromXML2JSON(id) {
+        return _ref.apply(this, arguments);
+    };
+}();

package/dist/lwm2m/instanceTs.js

@@ -0,0 +1,9 @@
+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
+    ;
+    var ts = instance.Resources[tsResourceId];
+    return new Date(ts);
+};

package/dist/lwm2m/instanceTs.spec.js

@@ -0,0 +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() {
+        return assert.equal(instanceTs({
+            ObjectID: 14210,
+            ObjectVersion: "1.0",
+            Resources: {
+                "0": 3.5399999618530273,
+                "1": 4.168000221252441,
+                "99": "2024-02-23T10:18:20.474Z"
+            }
+        }).getTime(), new Date("2024-02-23T10:18:20.474Z").getTime());
+    });
+});

package/dist/lwm2m/isRegisteredLwM2MObject.js

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

package/dist/lwm2m/isRegisteredLwM2MObject.spec.js

@@ -0,0 +1,45 @@
+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",
+            Resources: {
+                0: 33.98771459323253,
+                1: -84.50632147267358,
+                2: 241.9342498779297,
+                3: 11.317643165588379,
+                4: 0.03478508070111275,
+                5: 90.31222534179688,
+                6: "GNSS",
+                99: new Date(1699049744000)
+            }
+        };
+        assert.equal(isRegisteredLwM2MObject(o), true);
+    });
+    void it("should validate a LwM2M object with optional resources", function() {
+        var o = {
+            ObjectID: 14201,
+            ObjectVersion: "1.0",
+            Resources: {
+                0: 33.98771459323253,
+                1: -84.50632147267358,
+                6: "GNSS",
+                99: new Date(1699049744000)
+            }
+        };
+        assert.equal(isRegisteredLwM2MObject(o), true);
+    });
+    void it("should not validate an unknown LwM2M object", function() {
+        var o = {
+            ObjectID: 666,
+            ObjectVersion: "1.0",
+            Resources: {
+                0: 42
+            }
+        };
+        assert.equal(isRegisteredLwM2MObject(o), false);
+    });
+});

package/dist/lwm2m/object/14201.d.js

@@ -0,0 +1,5 @@
+/**
+ * Geolocation (14201)
+ *
+ * Describes the geo location of a device
+ */ export { };

package/dist/lwm2m/object/14202.d.js

@@ -0,0 +1,5 @@
+/**
+ * Battery and Power (14202)
+ *
+ * Information about the battery and power status of the device.
+ */ export { };

package/dist/lwm2m/object/14203.d.js

@@ -0,0 +1,5 @@
+/**
+ * Connection information (14203)
+ *
+ * Details about the device's connection.
+ */ export { };

package/dist/lwm2m/object/14204.d.js

@@ -0,0 +1,5 @@
+/**
+ * Device information (14204)
+ *
+ * Details about the device's connection.
+ */ export { };

package/dist/lwm2m/object/14205.d.js

@@ -0,0 +1,5 @@
+/**
+ * Environment (14205)
+ *
+ * Environment information.
+ */ export { };

package/dist/lwm2m/object/14210.d.js

@@ -0,0 +1,5 @@
+/**
+ * Solar charge (14210)
+ *
+ * Measurements from the solar shield.
+ */ export { };

package/dist/lwm2m/object/14220.d.js

@@ -0,0 +1,5 @@
+/**
+ * Button press (14220)
+ *
+ * Describes a button press event.
+ */ export { };

package/dist/lwm2m/object/14230.d.js

@@ -0,0 +1,5 @@
+/**
+ * Sea Water Level (14230)
+ *
+ * Describes observed sea water level.
+ */ export { };

package/dist/lwm2m/object/validate14201.js

@@ -0,0 +1,18 @@
+import { NumberResource, StringResource, DateResource, OptionalResource, validate } from "../validation.js";
+import { LwM2MObjectID } from "../LwM2MObjectID.js";
+/**
+ * Validate Geolocation (14201)
+ *
+ * Ensures the given object is an LwM2M object according to the schema 14201.xml.
+ */ export var validate14201 = function(o, onError) {
+    return validate(LwM2MObjectID.Geolocation_14201, "1.0", {
+        0: NumberResource,
+        1: NumberResource,
+        6: StringResource,
+        99: DateResource,
+        2: OptionalResource(NumberResource),
+        3: OptionalResource(NumberResource),
+        4: OptionalResource(NumberResource),
+        5: OptionalResource(NumberResource)
+    })(o, onError);
+};

package/dist/lwm2m/object/validate14202.js

@@ -0,0 +1,17 @@
+import { DateResource, NumberResource, OptionalResource, validate } from "../validation.js";
+import { LwM2MObjectID } from "../LwM2MObjectID.js";
+/**
+ * Validate Battery and Power (14202)
+ *
+ * Ensures the given object is an LwM2M object according to the schema 14202.xml.
+ */ export var validate14202 = function(o, onError) {
+    return validate(LwM2MObjectID.BatteryAndPower_14202, "1.0", {
+        99: DateResource,
+        0: OptionalResource(NumberResource),
+        1: OptionalResource(NumberResource),
+        2: OptionalResource(NumberResource),
+        3: OptionalResource(NumberResource),
+        4: OptionalResource(NumberResource),
+        5: OptionalResource(NumberResource)
+    })(o, onError);
+};

package/dist/lwm2m/object/validate14203.js

@@ -0,0 +1,19 @@
+import { DateResource, StringResource, OptionalResource, NumberResource, validate } from "../validation.js";
+import { LwM2MObjectID } from "../LwM2MObjectID.js";
+/**
+ * Validate Connection information (14203)
+ *
+ * Ensures the given object is an LwM2M object according to the schema 14203.xml.
+ */ export var validate14203 = function(o, onError) {
+    return validate(LwM2MObjectID.ConnectionInformation_14203, "1.0", {
+        99: DateResource,
+        0: OptionalResource(StringResource),
+        1: OptionalResource(NumberResource),
+        2: OptionalResource(NumberResource),
+        3: OptionalResource(NumberResource),
+        4: OptionalResource(NumberResource),
+        5: OptionalResource(NumberResource),
+        6: OptionalResource(StringResource),
+        11: OptionalResource(NumberResource)
+    })(o, onError);
+};

package/dist/lwm2m/object/validate14204.js

@@ -0,0 +1,17 @@
+import { StringResource, DateResource, OptionalResource, validate } from "../validation.js";
+import { LwM2MObjectID } from "../LwM2MObjectID.js";
+/**
+ * Validate Device information (14204)
+ *
+ * Ensures the given object is an LwM2M object according to the schema 14204.xml.
+ */ export var validate14204 = function(o, onError) {
+    return validate(LwM2MObjectID.DeviceInformation_14204, "1.0", {
+        0: StringResource,
+        2: StringResource,
+        3: StringResource,
+        4: StringResource,
+        99: DateResource,
+        1: OptionalResource(StringResource),
+        5: OptionalResource(StringResource)
+    })(o, onError);
+};

package/dist/lwm2m/object/validate14205.js

@@ -0,0 +1,15 @@
+import { DateResource, NumberResource, OptionalResource, validate } from "../validation.js";
+import { LwM2MObjectID } from "../LwM2MObjectID.js";
+/**
+ * Validate Environment (14205)
+ *
+ * Ensures the given object is an LwM2M object according to the schema 14205.xml.
+ */ export var validate14205 = function(o, onError) {
+    return validate(LwM2MObjectID.Environment_14205, "1.0", {
+        99: DateResource,
+        0: OptionalResource(NumberResource),
+        1: OptionalResource(NumberResource),
+        2: OptionalResource(NumberResource),
+        10: OptionalResource(NumberResource)
+    })(o, onError);
+};

package/dist/lwm2m/object/validate14210.js

@@ -0,0 +1,13 @@
+import { NumberResource, DateResource, OptionalResource, validate } from "../validation.js";
+import { LwM2MObjectID } from "../LwM2MObjectID.js";
+/**
+ * Validate Solar charge (14210)
+ *
+ * Ensures the given object is an LwM2M object according to the schema 14210.xml.
+ */ export var validate14210 = function(o, onError) {
+    return validate(LwM2MObjectID.SolarCharge_14210, "1.0", {
+        0: NumberResource,
+        99: DateResource,
+        1: OptionalResource(NumberResource)
+    })(o, onError);
+};

package/dist/lwm2m/object/validate14220.js

@@ -0,0 +1,12 @@
+import { NumberResource, DateResource, validate } from "../validation.js";
+import { LwM2MObjectID } from "../LwM2MObjectID.js";
+/**
+ * Validate Button press (14220)
+ *
+ * Ensures the given object is an LwM2M object according to the schema 14220.xml.
+ */ export var validate14220 = function(o, onError) {
+    return validate(LwM2MObjectID.ButtonPress_14220, "1.0", {
+        0: NumberResource,
+        99: DateResource
+    })(o, onError);
+};

package/dist/lwm2m/object/validate14230.js

@@ -0,0 +1,13 @@
+import { NumberResource, StringResource, DateResource, validate } from "../validation.js";
+import { LwM2MObjectID } from "../LwM2MObjectID.js";
+/**
+ * Validate Sea Water Level (14230)
+ *
+ * Ensures the given object is an LwM2M object according to the schema 14230.xml.
+ */ export var validate14230 = function(o, onError) {
+    return validate(LwM2MObjectID.SeaWaterLevel_14230, "1.0", {
+        0: NumberResource,
+        1: StringResource,
+        99: DateResource
+    })(o, onError);
+};

package/dist/lwm2m/objects.js

@@ -0,0 +1,8 @@
+export { validate14201 } from "./object/validate14201.js";
+export { validate14202 } from "./object/validate14202.js";
+export { validate14203 } from "./object/validate14203.js";
+export { validate14204 } from "./object/validate14204.js";
+export { validate14205 } from "./object/validate14205.js";
+export { validate14210 } from "./object/validate14210.js";
+export { validate14220 } from "./object/validate14220.js";
+export { validate14230 } from "./object/validate14230.js";

package/dist/lwm2m/parseRangeEnumeration.js

@@ -0,0 +1,20 @@
+import { RangeEnumerationRegExp } from "./LWM2MObjectDefinition.js";
+export var parseRangeEnumeration = function(re) {
+    var match = RangeEnumerationRegExp.exec(re);
+    if (match === null) return {
+        error: new Error("Could not match '".concat(re, "' against ").concat(RangeEnumerationRegExp, "!"))
+    };
+    var _match_groups;
+    var _ref = (_match_groups = match.groups) !== null && _match_groups !== void 0 ? _match_groups : {}, minS = _ref.min, maxS = _ref.max;
+    var min = parseFloat(minS);
+    var max = parseFloat(maxS);
+    if (min > max) return {
+        error: new Error("'min' must be smaller than 'max' in RangeEnumeration '".concat(re, "'!"))
+    };
+    return {
+        range: {
+            min: min,
+            max: max
+        }
+    };
+};

package/dist/lwm2m/parseRangeEnumeration.spec.js

@@ -0,0 +1,27 @@
+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,
+                max: 10
+            }
+        });
+    });
+    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");
+        assert.deepEqual(result, {
+            error: new Error("Could not match 'invalid' against ".concat(RangeEnumerationRegExp, "!"))
+        });
+    });
+});

package/dist/lwm2m/resourceType.js

@@ -0,0 +1,12 @@
+export var LwM2MType;
+(function(LwM2MType) {
+    LwM2MType["Boolean"] = "Boolean";
+    LwM2MType["Float"] = "Float";
+    LwM2MType["Integer"] = "Integer";
+    LwM2MType["UnsignedInteger"] = "Unsigned Integer";
+    LwM2MType["Objlnk"] = "Objlnk";
+    LwM2MType["Corelnk"] = "Corelnk";
+    LwM2MType["Opaque"] = "Opaque";
+    LwM2MType["String"] = "String";
+    LwM2MType["Time"] = "Time";
+})(LwM2MType || (LwM2MType = {}));

package/dist/lwm2m/timestampResources.js

@@ -0,0 +1,12 @@
+/**
+ * Contains the ID of the resource that defines the timestamp for each LwM2M object definition
+ */ export var timestampResources = {
+    14201: 99,
+    14202: 99,
+    14203: 99,
+    14204: 99,
+    14205: 99,
+    14210: 99,
+    14220: 99,
+    14230: 99
+};

package/dist/lwm2m/unwrapNestedArray.js

@@ -0,0 +1,114 @@
+/**
+ * A recursive function that walks through the given object and for each property checks if its value is an array and only has one element. If that is the case it takes the first element and uses it instead.
+ */ function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    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;
+    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 (Array.isArray(v)) {
+            if (v.length === 1) {
+                return _object_spread_props(_object_spread({}, result), _define_property({}, k, unwrapNestedArray(v[0])));
+            }
+            return _object_spread_props(_object_spread({}, result), _define_property({}, k, v.map(unwrapNestedArray)));
+        }
+        return _object_spread_props(_object_spread({}, result), _define_property({}, k, unwrapNestedArray(v)));
+    }, {});
+};