@hello.nrfcloud.com/proto-map 4.0.0

package/dist/lwm2m/unwrapNestedArray.spec.js

@@ -0,0 +1,374 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { unwrapNestedArray } from "./unwrapNestedArray.js";
+void describe("unwrapNestedArray()", function() {
+    void it("should unwrap an array", function() {
+        return assert.deepEqual(unwrapNestedArray({
+            LWM2M: {
+                $: {
+                    "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+                    "xsi:noNamespaceSchemaLocation": "http://www.openmobilealliance.org/tech/profiles/LWM2M-v1_1.xsd"
+                },
+                Object: [
+                    {
+                        $: {
+                            ObjectType: "MODefinition"
+                        },
+                        Name: [
+                            "Location"
+                        ],
+                        Description1: [
+                            "This LwM2M Object provides a range of location telemetry related information which can be queried by the LwM2M Server."
+                        ],
+                        ObjectID: [
+                            "6"
+                        ],
+                        ObjectURN: [
+                            "urn:oma:lwm2m:oma:6"
+                        ],
+                        LWM2MVersion: [
+                            "1.0"
+                        ],
+                        ObjectVersion: [
+                            "1.0"
+                        ],
+                        MultipleInstances: [
+                            "Single"
+                        ],
+                        Mandatory: [
+                            "Optional"
+                        ],
+                        Resources: [
+                            {
+                                Item: [
+                                    {
+                                        $: {
+                                            ID: "0"
+                                        },
+                                        Name: [
+                                            "Latitude"
+                                        ],
+                                        Operations: [
+                                            "R"
+                                        ],
+                                        MultipleInstances: [
+                                            "Single"
+                                        ],
+                                        Mandatory: [
+                                            "Mandatory"
+                                        ],
+                                        Type: [
+                                            "Float"
+                                        ],
+                                        RangeEnumeration: [
+                                            ""
+                                        ],
+                                        Units: [
+                                            "lat"
+                                        ],
+                                        Description: [
+                                            "The decimal notation of latitude, e.g. -43.5723 [World Geodetic System 1984]."
+                                        ]
+                                    },
+                                    {
+                                        $: {
+                                            ID: "1"
+                                        },
+                                        Name: [
+                                            "Longitude"
+                                        ],
+                                        Operations: [
+                                            "R"
+                                        ],
+                                        MultipleInstances: [
+                                            "Single"
+                                        ],
+                                        Mandatory: [
+                                            "Mandatory"
+                                        ],
+                                        Type: [
+                                            "Float"
+                                        ],
+                                        RangeEnumeration: [
+                                            ""
+                                        ],
+                                        Units: [
+                                            "lon"
+                                        ],
+                                        Description: [
+                                            "The decimal notation of longitude, e.g. 153.21760 [World Geodetic System 1984]."
+                                        ]
+                                    },
+                                    {
+                                        $: {
+                                            ID: "2"
+                                        },
+                                        Name: [
+                                            "Altitude"
+                                        ],
+                                        Operations: [
+                                            "R"
+                                        ],
+                                        MultipleInstances: [
+                                            "Single"
+                                        ],
+                                        Mandatory: [
+                                            "Optional"
+                                        ],
+                                        Type: [
+                                            "Float"
+                                        ],
+                                        RangeEnumeration: [
+                                            ""
+                                        ],
+                                        Units: [
+                                            "m"
+                                        ],
+                                        Description: [
+                                            "The decimal notation of altitude in meters above sea level."
+                                        ]
+                                    },
+                                    {
+                                        $: {
+                                            ID: "3"
+                                        },
+                                        Name: [
+                                            "Radius"
+                                        ],
+                                        Operations: [
+                                            "R"
+                                        ],
+                                        MultipleInstances: [
+                                            "Single"
+                                        ],
+                                        Mandatory: [
+                                            "Optional"
+                                        ],
+                                        Type: [
+                                            "Float"
+                                        ],
+                                        RangeEnumeration: [
+                                            ""
+                                        ],
+                                        Units: [
+                                            "m"
+                                        ],
+                                        Description: [
+                                            "The value in this resource indicates the radius of a circular area in meters. The circular area is used to describe uncertainty about a point for coordinates in a two-dimensional coordinate reference systems (CRS). The center point of a circular area is specified by using the Latitude and the Longitude Resources."
+                                        ]
+                                    },
+                                    {
+                                        $: {
+                                            ID: "4"
+                                        },
+                                        Name: [
+                                            "Velocity"
+                                        ],
+                                        Operations: [
+                                            "R"
+                                        ],
+                                        MultipleInstances: [
+                                            "Single"
+                                        ],
+                                        Mandatory: [
+                                            "Optional"
+                                        ],
+                                        Type: [
+                                            "Opaque"
+                                        ],
+                                        RangeEnumeration: [
+                                            ""
+                                        ],
+                                        Units: [
+                                            ""
+                                        ],
+                                        Description: [
+                                            "The velocity of the LwM2M Client, as defined in [3GPP-TS_23.032]."
+                                        ]
+                                    },
+                                    {
+                                        $: {
+                                            ID: "5"
+                                        },
+                                        Name: [
+                                            "Timestamp"
+                                        ],
+                                        Operations: [
+                                            "R"
+                                        ],
+                                        MultipleInstances: [
+                                            "Single"
+                                        ],
+                                        Mandatory: [
+                                            "Mandatory"
+                                        ],
+                                        Type: [
+                                            "Time"
+                                        ],
+                                        RangeEnumeration: [
+                                            ""
+                                        ],
+                                        Units: [
+                                            ""
+                                        ],
+                                        Description: [
+                                            "The timestamp of when the location measurement was performed."
+                                        ]
+                                    },
+                                    {
+                                        $: {
+                                            ID: "6"
+                                        },
+                                        Name: [
+                                            "Speed"
+                                        ],
+                                        Operations: [
+                                            "R"
+                                        ],
+                                        MultipleInstances: [
+                                            "Single"
+                                        ],
+                                        Mandatory: [
+                                            "Optional"
+                                        ],
+                                        Type: [
+                                            "Float"
+                                        ],
+                                        RangeEnumeration: [
+                                            ""
+                                        ],
+                                        Units: [
+                                            "m/s"
+                                        ],
+                                        Description: [
+                                            "Speed is the time rate of change in position of a LwM2M Client without regard for direction: the scalar component of velocity."
+                                        ]
+                                    }
+                                ]
+                            }
+                        ],
+                        Description2: [
+                            ""
+                        ]
+                    }
+                ]
+            }
+        }), {
+            LWM2M: {
+                $: {
+                    "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+                    "xsi:noNamespaceSchemaLocation": "http://www.openmobilealliance.org/tech/profiles/LWM2M-v1_1.xsd"
+                },
+                Object: {
+                    $: {
+                        ObjectType: "MODefinition"
+                    },
+                    Name: "Location",
+                    Description1: "This LwM2M Object provides a range of location telemetry related information which can be queried by the LwM2M Server.",
+                    ObjectID: "6",
+                    ObjectURN: "urn:oma:lwm2m:oma:6",
+                    LWM2MVersion: "1.0",
+                    ObjectVersion: "1.0",
+                    MultipleInstances: "Single",
+                    Mandatory: "Optional",
+                    Resources: {
+                        Item: [
+                            {
+                                $: {
+                                    ID: "0"
+                                },
+                                Name: "Latitude",
+                                Operations: "R",
+                                MultipleInstances: "Single",
+                                Mandatory: "Mandatory",
+                                Type: "Float",
+                                RangeEnumeration: "",
+                                Units: "lat",
+                                Description: "The decimal notation of latitude, e.g. -43.5723 [World Geodetic System 1984]."
+                            },
+                            {
+                                $: {
+                                    ID: "1"
+                                },
+                                Name: "Longitude",
+                                Operations: "R",
+                                MultipleInstances: "Single",
+                                Mandatory: "Mandatory",
+                                Type: "Float",
+                                RangeEnumeration: "",
+                                Units: "lon",
+                                Description: "The decimal notation of longitude, e.g. 153.21760 [World Geodetic System 1984]."
+                            },
+                            {
+                                $: {
+                                    ID: "2"
+                                },
+                                Name: "Altitude",
+                                Operations: "R",
+                                MultipleInstances: "Single",
+                                Mandatory: "Optional",
+                                Type: "Float",
+                                RangeEnumeration: "",
+                                Units: "m",
+                                Description: "The decimal notation of altitude in meters above sea level."
+                            },
+                            {
+                                $: {
+                                    ID: "3"
+                                },
+                                Name: "Radius",
+                                Operations: "R",
+                                MultipleInstances: "Single",
+                                Mandatory: "Optional",
+                                Type: "Float",
+                                RangeEnumeration: "",
+                                Units: "m",
+                                Description: "The value in this resource indicates the radius of a circular area in meters. The circular area is used to describe uncertainty about a point for coordinates in a two-dimensional coordinate reference systems (CRS). The center point of a circular area is specified by using the Latitude and the Longitude Resources."
+                            },
+                            {
+                                $: {
+                                    ID: "4"
+                                },
+                                Name: "Velocity",
+                                Operations: "R",
+                                MultipleInstances: "Single",
+                                Mandatory: "Optional",
+                                Type: "Opaque",
+                                RangeEnumeration: "",
+                                Units: "",
+                                Description: "The velocity of the LwM2M Client, as defined in [3GPP-TS_23.032]."
+                            },
+                            {
+                                $: {
+                                    ID: "5"
+                                },
+                                Name: "Timestamp",
+                                Operations: "R",
+                                MultipleInstances: "Single",
+                                Mandatory: "Mandatory",
+                                Type: "Time",
+                                RangeEnumeration: "",
+                                Units: "",
+                                Description: "The timestamp of when the location measurement was performed."
+                            },
+                            {
+                                $: {
+                                    ID: "6"
+                                },
+                                Name: "Speed",
+                                Operations: "R",
+                                MultipleInstances: "Single",
+                                Mandatory: "Optional",
+                                Type: "Float",
+                                RangeEnumeration: "",
+                                Units: "m/s",
+                                Description: "Speed is the time rate of change in position of a LwM2M Client without regard for direction: the scalar component of velocity."
+                            }
+                        ]
+                    },
+                    Description2: ""
+                }
+            }
+        });
+    });
+});

package/dist/lwm2m/validate.js

@@ -0,0 +1,14 @@
+import { isLwM2MObject } from "./validation.js";
+export var validate = function(validators) {
+    return function(o, onError) {
+        if (!isLwM2MObject(o, onError)) {
+            return false;
+        }
+        var validator = validators.get(o.ObjectID);
+        if (validator === undefined) {
+            onError === null || onError === void 0 ? void 0 : onError(new Error("No validator defined for ObjectID: ".concat(o.ObjectID, "!")));
+            return false;
+        }
+        return validator(o, onError);
+    };
+};

package/dist/lwm2m/validation.js

@@ -0,0 +1,146 @@
+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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+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 _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 _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+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);
+}
+import { LwM2MObjectIDs } from "./LwM2MObjectID.js";
+export var isLwM2MObject = function(object, onError) {
+    var _Object_keys_find;
+    var error = function(message) {
+        onError === null || onError === void 0 ? void 0 : onError(new Error(message));
+        return false;
+    };
+    // Must be an object
+    if (typeof object !== "object" || object === null) return error("Not an object");
+    // Must have valid ObjectID
+    if (!("ObjectID" in object) || typeof object.ObjectID !== "number" || object.ObjectID < 14200 || object.ObjectID > 15000 || LwM2MObjectIDs.includes(object.ObjectID) === false) return error("Not an valid Object ID: ".concat(JSON.stringify(object.ObjectID)));
+    // ObjectVersion must be valid
+    if ("ObjectVersion" in object) {
+        if (typeof object.ObjectVersion !== "string" || !/^\d+\.\d+$/.test(object.ObjectVersion)) return error("Invalid ObjectVersion");
+    }
+    // Must have valid resources
+    if (!("Resources" in object) || typeof object.Resources !== "object" || object.Resources === null) return error("Resources must be an object");
+    var _Object_keys_find_length;
+    // All keys must be numbers
+    if (((_Object_keys_find_length = (_Object_keys_find = Object.keys(object.Resources).find(function(k) {
+        return /[^\d]/.test(k);
+    })) === null || _Object_keys_find === void 0 ? void 0 : _Object_keys_find.length) !== null && _Object_keys_find_length !== void 0 ? _Object_keys_find_length : 0) > 0) return error("All resource IDs must be a number");
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        // All values must be number, string, boolean, or Date
+        for(var _iterator = Object.values(object.Resources)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var v = _step.value;
+            if (typeof v === "string") continue;
+            if (typeof v === "boolean") continue;
+            if (typeof v === "number") continue;
+            if (typeof v === "object" && _instanceof(v, Date)) continue;
+            return error("Invalid value type ".concat(typeof v === "undefined" ? "undefined" : _type_of(v)));
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return true;
+};
+export var validate = function(ObjectID, ObjectVersion, Resources) {
+    return function(o, onError) {
+        var error = function(message) {
+            onError === null || onError === void 0 ? void 0 : onError(new Error(message));
+            return false;
+        };
+        if (!isLwM2MObject(o, onError)) return false;
+        if (o.ObjectID !== ObjectID) return error("Given Object ID ".concat(o.ObjectID, " does not match expected ").concat(ObjectID));
+        var _o_ObjectVersion;
+        if (((_o_ObjectVersion = o.ObjectVersion) !== null && _o_ObjectVersion !== void 0 ? _o_ObjectVersion : "1.0") !== ObjectVersion) return error("Given Object version ".concat(o.ObjectVersion, " does not match expected ").concat(ObjectVersion));
+        return Object.entries(Resources).reduce(function(allValid, param) {
+            var _param = _sliced_to_array(param, 2), ResourceID = _param[0], validator = _param[1];
+            if (!allValid) return false;
+            if (validator(o.Resources[parseInt(ResourceID, 10)]) === false) {
+                return error("Resource ".concat(ResourceID, " is invalid."));
+            }
+            return allValid;
+        }, true);
+    };
+};
+export var NumberResource = function(r) {
+    return typeof r === "number";
+};
+export var StringResource = function(r) {
+    return typeof r === "string";
+};
+export var DateResource = function(r) {
+    return typeof r === "object" && _instanceof(r, Date);
+};
+export var BooleanResource = function(r) {
+    return typeof r === "boolean";
+};
+export var OptionalResource = function(validator) {
+    return function(r) {
+        return r === undefined ? true : validator(r);
+    };
+};
+export var isLwM2MObjectID = function(o) {
+    return typeof o === "number" && LwM2MObjectIDs.includes(o);
+};

package/dist/lwm2m/validators.js

@@ -0,0 +1,20 @@
+import { LwM2MObjectID } from "./LwM2MObjectID.js";
+import { validate14201 } from "./object/validate14201.js";
+import { validate14202 } from "./object/validate14202.js";
+import { validate14203 } from "./object/validate14203.js";
+import { validate14204 } from "./object/validate14204.js";
+import { validate14205 } from "./object/validate14205.js";
+import { validate14210 } from "./object/validate14210.js";
+import { validate14220 } from "./object/validate14220.js";
+import { validate14230 } from "./object/validate14230.js";
+/**
+ * Contains the validators for all registered LwM2M objects.
+ */ export var validators = new Map();
+validators.set(LwM2MObjectID.Geolocation_14201, validate14201);
+validators.set(LwM2MObjectID.BatteryAndPower_14202, validate14202);
+validators.set(LwM2MObjectID.ConnectionInformation_14203, validate14203);
+validators.set(LwM2MObjectID.DeviceInformation_14204, validate14204);
+validators.set(LwM2MObjectID.Environment_14205, validate14205);
+validators.set(LwM2MObjectID.SolarCharge_14210, validate14210);
+validators.set(LwM2MObjectID.ButtonPress_14220, validate14220);
+validators.set(LwM2MObjectID.SeaWaterLevel_14230, validate14230);

package/dist/markdown/getCodeBlock.js

@@ -0,0 +1,74 @@
+import { remark } from "remark";
+export var parseMarkdown2 = remark();
+var isCodeBlock = function(lang) {
+    return function(child) {
+        return child.type === "code" && child.lang === lang;
+    };
+};
+var isHeadingWithTitle = function(title) {
+    return function(child) {
+        var _child_children_;
+        return child.type === "heading" && ((_child_children_ = child.children[0]) === null || _child_children_ === void 0 ? void 0 : _child_children_.type) === "text" && child.children[0].value === title;
+    };
+};
+var isHeading = function(child) {
+    return child.type === "heading";
+};
+var isParagraph = function(child) {
+    return child.type === "paragraph";
+};
+var codeBlockWithHeading = function(children) {
+    return function(lang, title) {
+        var block = children.find(function(child, index, array) {
+            if (!isCodeBlock(lang)(child)) return false;
+            var prevChild = array[index - 1];
+            if (prevChild === undefined) return false;
+            return isHeadingWithTitle(title)(prevChild);
+        });
+        if (block === undefined) throw new Error("Could not find ".concat(lang, ' codeblock with title "').concat(title, '"!'));
+        return block.value;
+    };
+};
+var headingWithLevel = function(children, level) {
+    return children.filter(isHeading).find(function(param) {
+        var depth = param.depth;
+        return depth === level;
+    });
+};
+export var getCodeBlock = function(markdown) {
+    return codeBlockWithHeading(remark().parse(markdown).children);
+};
+export var getHeading = function(markdown, level) {
+    return headingWithLevel(remark().parse(markdown).children, level);
+};
+// Find all the paragraphs immediately after the first headline with the given level
+export var getParagraphsAfterHeading = function(markdown, level) {
+    var headingFound = false;
+    var paragraphs = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = remark().parse(markdown).children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var child = _step.value;
+            if (!headingFound && isHeading(child) && child.depth === level) {
+                headingFound = true;
+                continue;
+            }
+            if (!isParagraph(child)) break; // once we reached a non-paragraph
+            paragraphs.push(child);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return paragraphs;
+};

package/dist/markdown/getFrontMatter.js

@@ -0,0 +1,15 @@
+import { remark } from "remark";
+import frontmatter from "remark-frontmatter";
+import { validate } from "../validate.js";
+import yaml from "yaml";
+export var getFrontMatter = function(markdown, schema) {
+    var data = yaml.parse(remark().use(frontmatter, [
+        "yaml"
+    ]).parse(markdown).children[0].value);
+    var maybeValid = validate(schema)(data);
+    if ("errors" in maybeValid) {
+        console.error(maybeValid.errors);
+        throw new Error("Frontmatter is not valid!");
+    }
+    return maybeValid.value;
+};

package/dist/markdown/parseREADME.js

@@ -0,0 +1,19 @@
+import { getHeading, getParagraphsAfterHeading } from "./getCodeBlock.js";
+export var parseREADME = function(markdown) {
+    var h1 = getHeading(markdown, 1);
+    if (h1 === undefined) throw new Error("No H1 defined!");
+    var descriptionParagraphs = getParagraphsAfterHeading(markdown, 1);
+    if (descriptionParagraphs.length === 0) throw new Error("No description defined!");
+    return {
+        heading: toOneLine(nodeToString(h1)),
+        description: descriptionParagraphs.map(nodeToString).map(toOneLine)
+    };
+};
+var nodeToString = function(node) {
+    if ("value" in node) return node.value;
+    if ("children" in node) return node.children.map(nodeToString).join("");
+    return "";
+};
+var toOneLine = function(s) {
+    return s.trim().replaceAll("\n", " ");
+};