@hello.nrfcloud.com/proto-map 4.0.0

package/dist/models/models.js

@@ -0,0 +1,137 @@
+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;
+}
+import { TransformType } from "./types.js";
+export var ModelID;
+(function(ModelID) {
+    ModelID["PCA20035_solar"] = "PCA20035+solar";
+    ModelID["Asset_tracker_v2_AWS"] = "asset_tracker_v2+AWS";
+    ModelID["Kartverket_vasstandsdata"] = "kartverket-vasstandsdata";
+})(ModelID || (ModelID = {}));
+var _obj;
+/**
+ * The models defined for hello.nrfcloud.com
+ */ export var models = (_obj = {}, _define_property(_obj, "PCA20035+solar", {
+    "id": "PCA20035+solar",
+    "transforms": [
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'AIR_QUAL'",
+            "transform": '[\n    {"bn": "/14205/0/", "n": "10", "v": $number(data), "bt": ts }\n]'
+        },
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'BATTERY'",
+            "transform": '[\n    {"bn": "/14202/0/", "n": "0", "v": $number(data), "bt": ts }\n]'
+        },
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'BUTTON'",
+            "transform": '[\n    {"bn": "/14220/0/", "n": "0", "v": $number(data), "bt": ts }\n]'
+        },
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'DEVICE' and $exists(data.deviceInfo)",
+            "transform": '[\n    {"bn": "/14204/0/", "n": "0", "vs": data.deviceInfo.imei, "bt": ts },\n    {"n": "1", "vs": data.deviceInfo.iccid },\n    {"n": "2", "vs": data.deviceInfo.modemFirmware },\n    {"n": "3", "vs": data.deviceInfo.appVersion },\n    {"n": "4", "vs": data.deviceInfo.board },\n    {"n": "5", "vs": data.deviceInfo.bat }\n]'
+        },
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'SOLAR'",
+            "transform": '[\n    {"bn": "/14210/0/", "n": "0", "v": $number(data), "bt": ts }\n]'
+        },
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'GROUND_FIX' and $exists(data.lat) and $exists(data.lon) and $exists(data.uncertainty) and $exists(data.fulfilledWith)",
+            "transform": '[\n    {"bn": "/14201/1/", "n": "0", "v": data.lat, "bt": $millis() },\n    {"n": "1", "v": data.lon },\n    {"n": "3", "v": data.uncertainty },\n    {"n": "6", "vs": data.fulfilledWith }\n]'
+        },
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'GNSS'",
+            "transform": '[\n    {"bn": "/14201/0/", "n": "0", "v": data.lat, "bt": ts },\n    {"n": "1", "v": data.lng },\n    {"n": "2", "v": data.alt },\n    {"n": "3", "v": data.acc },\n    {"n": "4", "v": data.spd },\n    {"n": "5", "v": data.hdg },\n    {"n": "6", "vs": "GNSS" }\n]'
+        },
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'HUMID'",
+            "transform": '[\n    {"bn": "/14205/0/", "n": "1", "v": $number(data), "bt": ts }\n]'
+        },
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'DEVICE' and $exists(data.networkInfo)",
+            "transform": '[\n    {"bn": "/14203/0/", "n": "0", "vs": data.networkInfo.networkMode, "bt": ts },\n    {"n": "1", "v": data.networkInfo.currentBand },\n    {"n": "2", "v": data.networkInfo.rsrp },\n    {"n": "3", "v": data.networkInfo.areaCode },\n    {"n": "4", "v": data.networkInfo.cellID },\n    {"n": "5", "v": data.networkInfo.mccmnc },\n    {"n": "6", "vs": data.networkInfo.ipAddress },\n    {"n": "11", "v": data.networkInfo.eest }\n]'
+        },
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'AIR_PRESS'",
+            "transform": '[\n    {"bn": "/14205/0/", "n": "2", "v": $number(data)*10, "bt": ts }\n]'
+        },
+        {
+            "type": TransformType.Messages,
+            "match": "appId = 'TEMP'",
+            "transform": '[\n    {"bn": "/14205/0/", "n": "0", "v": $number(data), "bt": ts }\n]'
+        }
+    ],
+    "about": {
+        "title": "Thingy:91 with Solar Shield",
+        "description": "The Nordic Thingy:91 Solar Shield is a plug-and-play prototyping platform. Powerfoyle solar cell is mounted onto the Thingy to quickly get started exploring the endless possibilities with solar powered IoT applications and to develop products with eternal life or even battery-free products.​\nThe Thingy:91 runs the asset_tracker_v2 application and sends messages to nRF Cloud using MQTT."
+    }
+}), _define_property(_obj, "asset_tracker_v2+AWS", {
+    "id": "asset_tracker_v2+AWS",
+    "transforms": [
+        {
+            "type": TransformType.Shadow,
+            "match": "$exists(state.reported.gnss)",
+            "transform": '[\n    {"bn": "/14201/0/", "n": "0", "v": state.reported.gnss.v.lat, "bt": state.reported.gnss.ts },\n    {"n": "1", "v": state.reported.gnss.v.lng },\n    {"n": "2", "v": state.reported.gnss.v.alt },\n    {"n": "3", "v": state.reported.gnss.v.acc },\n    {"n": "4", "v": state.reported.gnss.v.spd },\n    {"n": "5", "v": state.reported.gnss.v.hdg },\n    {"n": "6", "vs": "GNSS" }\n]'
+        },
+        {
+            "type": TransformType.Shadow,
+            "match": "$exists(state.reported.bat)",
+            "transform": '[\n    {"bn": "/14202/0/", "n": "1", "v": state.reported.bat.v/1000, "bt": state.reported.bat.ts }\n]'
+        },
+        {
+            "type": TransformType.Shadow,
+            "match": "$exists(state.reported.dev)",
+            "transform": '[\n    {"bn": "/14204/0/", "n": "0", "vs": state.reported.dev.v.imei, "bt": state.reported.dev.ts },\n    {"n": "1", "vs": state.reported.dev.v.iccid },\n    {"n": "2", "vs": state.reported.dev.v.modV },\n    {"n": "3", "vs": state.reported.dev.v.appV },\n    {"n": "4", "vs": state.reported.dev.v.brdV }\n]'
+        },
+        {
+            "type": TransformType.Shadow,
+            "match": "$exists(state.reported.env)",
+            "transform": '[\n    {"bn": "/14205/0/", "n": "0", "v": state.reported.env.v.temp, "bt": state.reported.env.ts },\n    {"n": "1", "v": state.reported.env.v.hum },\n    {"n": "2", "v": state.reported.env.v.atmp },\n    {"n": "10", "v": state.reported.env.v.bsec_iaq }\n]'
+        },
+        {
+            "type": TransformType.Shadow,
+            "match": "$exists(state.reported.fg)",
+            "transform": '[\n    {"bn": "/14202/0/", "n": "0", "v": state.reported.fg.v.SoC, "bt": state.reported.fg.ts },\n    {"n": "1", "v": state.reported.fg.v.V/1000 },\n    {"n": "2", "v": state.reported.fg.v.I },\n    {"n": "3", "v": state.reported.fg.v.T = null ? null : state.reported.fg.v.T/10 },\n    {"n": "4", "v": state.reported.fg.v.TTF },\n    {"n": "5", "v": state.reported.fg.v.TTE }\n]'
+        },
+        {
+            "type": TransformType.Shadow,
+            "match": "$exists(state.reported.roam)",
+            "transform": '[\n    {"bn": "/14203/0/", "n": "0", "vs": state.reported.roam.v.nw, "bt": state.reported.roam.ts },\n    {"n": "1", "v": state.reported.roam.v.band },\n    {"bn": "/14203/0/", "n": "2", "v": state.reported.roam.v.rsrp, "bt": state.reported.roam.ts },\n    {"n": "3", "v": state.reported.roam.v.area },\n    {"n": "4", "v": state.reported.roam.v.cell },\n    {"n": "5", "v": state.reported.roam.v.mccmnc },\n    {"n": "6", "vs": state.reported.roam.v.ip },\n    {"bn": "/14203/0/", "n": "11", "v": state.reported.roam.v.eest, "bt": state.reported.roam.ts }\n]'
+        },
+        {
+            "type": TransformType.Shadow,
+            "match": "$exists(state.reported.sol)",
+            "transform": '[\n    {"bn": "/14210/0/", "n": "0", "v": state.reported.sol.v.gain, "bt": state.reported.sol.ts },\n    {"n": "1", "v": state.reported.sol.v.bat }\n]'
+        }
+    ],
+    "about": {
+        "title": "asset_tracker_v2 on AWS",
+        "description": "This implements the conversion for the asset_tracker_v2 message protocol when connected to AWS IoT."
+    }
+}), _define_property(_obj, "kartverket-vasstandsdata", {
+    "id": "kartverket-vasstandsdata",
+    "transforms": [],
+    "about": {
+        "title": "Kartverket Vasstandsdata",
+        "description": "A simulated device reporting the current sea level as provided by the Kartverket's (Norwegian Mapping Authority) API for vasstandsdata (API for water level data).\nReports sea water level using the Object 14230.\nThe data is licensed by the Norwegian Mapping Authority’s under the Creative Commons Attribution 4.0 International (CC BY 4.0) license."
+    }
+}), _obj);

package/dist/models/types.js

@@ -0,0 +1,13 @@
+import { Type } from "@sinclair/typebox";
+export var ModelIDRegExp = /^[A-Za-z0-9+_-]+$/;
+export var TransformType;
+(function(TransformType) {
+    TransformType["Shadow"] = "shadow";
+    TransformType["Messages"] = "messages";
+})(TransformType || (TransformType = {}));
+export var FrontMatter = Type.Object({
+    type: Type.Union([
+        Type.Literal("shadow"),
+        Type.Literal("messages")
+    ])
+});

package/dist/senml/SenMLSchema.js

@@ -0,0 +1,79 @@
+import { Type } from "@sinclair/typebox";
+var ResourceIDPart = Type.RegExp(/^[0-9/]+$/, {
+    title: "ResourceIDPart",
+    description: "Combines `bn` and `n` to a fully qualified resource identifier in the form of `/<object ID>/<object instance ID>/<resource ID>/0`. (Multiple resource instances are not supported right now.).",
+    examples: [
+        "/",
+        "/14201/0/",
+        "5"
+    ]
+});
+var BaseValue = Type.Number({
+    title: "Base Value"
+});
+var Value = Type.Number({
+    title: "Value"
+});
+var Time = Type.Integer({
+    minimum: 0,
+    title: "Time"
+});
+/**
+ * Defines a SenML type with some unsupported elements removed: Sum, Base Sum, Update Time
+ *
+ * @see https://datatracker.ietf.org/doc/html/rfc8428
+ */ export var Measurement = Type.Intersect([
+    Type.Union([
+        Type.Object({
+            n: ResourceIDPart
+        }),
+        Type.Object({
+            bn: ResourceIDPart,
+            n: ResourceIDPart,
+            blv: Type.String({
+                minLength: 1,
+                description: "The LwM2M object version used",
+                default: "1.0"
+            }),
+            bt: Type.Optional(Time)
+        })
+    ]),
+    // Value combinations
+    Type.Union([
+        Type.Union([
+            Type.Object({
+                bv: BaseValue
+            }),
+            Type.Object({
+                bv: BaseValue,
+                v: Value
+            }),
+            Type.Object({
+                // Value can be undefined, if it is not mandatory
+                v: Type.Optional(Value)
+            })
+        ]),
+        Type.Object({
+            vs: Type.String({
+                minLength: 1,
+                title: "String Value"
+            })
+        }),
+        Type.Object({
+            vb: Type.Boolean({
+                title: "Boolean Value"
+            })
+        }),
+        Type.Object({
+            vd: Type.String({
+                title: "Data Value.",
+                description: "Octets in the Data Value are base64 encoded with the URL-safe alphabet as defined in Section 5 of [RFC4648], with padding omitted."
+            })
+        })
+    ])
+], {
+    description: "SenML schema for conversion results. This is limited to properties useful for the hello.nrfcloud.com/map application."
+});
+export var SenML = Type.Array(Measurement, {
+    minItems: 1
+});

package/dist/senml/SenMLSchema.spec.js

@@ -0,0 +1,23 @@
+import { describe, it } from "node:test";
+import { SenML } from "./SenMLSchema.js";
+import assert from "node:assert/strict";
+import { validate } from "../validate.js";
+void describe("SenMLType", function() {
+    void it("it should validate a SenML payload", function() {
+        var example = [
+            {
+                bn: "/14201/0/",
+                n: "0",
+                v: 33.98755678796222,
+                bt: 1698155694999
+            },
+            {
+                n: "1",
+                v: -84.506132079174634
+            }
+        ];
+        var res = validate(SenML)(example);
+        assert.equal("errors" in res, false);
+        assert.deepEqual("value" in res && res.value, example);
+    });
+});

package/dist/senml/hasValue.js

@@ -0,0 +1,8 @@
+export var hasValue = function(m) {
+    if (m === null) return false;
+    if (typeof m !== "object") return false;
+    var _ref, _ref1, _ref2, _ref3;
+    var v = (_ref3 = (_ref2 = (_ref1 = (_ref = "bv" in m ? m.bv : undefined) !== null && _ref !== void 0 ? _ref : "v" in m ? m.v : undefined) !== null && _ref1 !== void 0 ? _ref1 : "vs" in m ? m.vs : undefined) !== null && _ref2 !== void 0 ? _ref2 : "vb" in m ? m.vb : undefined) !== null && _ref3 !== void 0 ? _ref3 : "vd" in m ? m.vd : undefined;
+    if (v === null || v === undefined) return false;
+    return true;
+};

package/dist/senml/hasValue.spec.js

@@ -0,0 +1,103 @@
+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 _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 _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 { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { hasValue } from "./hasValue.js";
+void describe("hasValue() should determine whether an object has a value", function() {
+    var _loop = function(_i, _iter) {
+        var _iter__i = _sliced_to_array(_iter[_i], 2), record = _iter__i[0], expected = _iter__i[1];
+        void it("should determine that ".concat(JSON.stringify(record), " has a value: ").concat(JSON.stringify(expected)), function() {
+            return assert.equal(hasValue(record), expected);
+        });
+    };
+    for(var _i = 0, _iter = [
+        [
+            {
+                bn: 14202,
+                n: 0,
+                v: 99,
+                bt: 1699049685992
+            },
+            true
+        ],
+        [
+            {
+                n: 1,
+                v: 4.179
+            },
+            true
+        ],
+        [
+            {
+                n: 2,
+                v: 0
+            },
+            true
+        ],
+        [
+            {
+                n: 3,
+                v: 25.7
+            },
+            true
+        ],
+        [
+            {
+                n: 4,
+                v: null
+            },
+            false
+        ],
+        [
+            {
+                n: 5,
+                v: null
+            },
+            false
+        ]
+    ]; _i < _iter.length; _i++)_loop(_i, _iter);
+});

package/dist/senml/lwm2mToSenML.js

@@ -0,0 +1,137 @@
+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 _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(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(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+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 _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 _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 _to_array(arr) {
+    return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_rest();
+}
+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);
+}
+import { instanceTs } from "../lwm2m/instanceTs.js";
+import { timestampResources } from "../lwm2m/timestampResources.js";
+import { definitions } from "../lwm2m/definitions.js";
+import { ResourceType } from "../lwm2m/LWM2MObjectInfo.js";
+/**
+ * Convert LwM2M Object Instances to senML
+ */ export var lwm2mToSenML = function(lwm2m) {
+    return lwm2m.map(asSenML).flat().filter(function(v) {
+        return v !== null;
+    });
+};
+var asSenML = function(lwm2m) {
+    var def = definitions[lwm2m.ObjectID];
+    var i = instanceTs(lwm2m);
+    var tsResourceId = timestampResources[lwm2m.ObjectID]// All registered objects must have a timestamp resource
+    ;
+    var _Object_entries_filter = _to_array(Object.entries(_object_spread_props(_object_spread({}, lwm2m.Resources), _define_property({}, tsResourceId, undefined)))// Filter out undefined values (and timestamp resource)
+    .filter(function(r) {
+        return r[1] !== undefined;
+    })), first = _Object_entries_filter[0], rest = _Object_entries_filter.slice(1);
+    if (first === undefined) return null;
+    var _lwm2m_ObjectInstanceID;
+    var _obj;
+    return [
+        (_obj = {
+            bn: "/".concat(lwm2m.ObjectID, "/").concat((_lwm2m_ObjectInstanceID = lwm2m.ObjectInstanceID) !== null && _lwm2m_ObjectInstanceID !== void 0 ? _lwm2m_ObjectInstanceID : 0, "/"),
+            n: first[0]
+        }, _define_property(_obj, toKey(def, parseInt(first[0], 10)), first[1]), _define_property(_obj, "bt", i.getTime()), _obj)
+    ].concat(_to_consumable_array(rest.map(function(r) {
+        return _define_property({
+            n: r[0]
+        }, toKey(def, parseInt(r[0], 10)), r[1]);
+    })));
+};
+var toKey = function(def, resourceId) {
+    var _def_Resources_resourceId;
+    switch((_def_Resources_resourceId = def.Resources[resourceId]) === null || _def_Resources_resourceId === void 0 ? void 0 : _def_Resources_resourceId.Type){
+        case ResourceType.String:
+            return "vs";
+        case ResourceType.Boolean:
+            return "vb";
+        case ResourceType.Float:
+        case ResourceType.Integer:
+        case ResourceType.Time:
+            return "v";
+        case ResourceType.Opaque:
+            return "vd";
+        default:
+            throw new Error("Unknown ResourceID ".concat(resourceId, " for LwM2M Object ").concat(def.ObjectID, "!"));
+    }
+};

package/dist/senml/lwm2mToSenML.spec.js

@@ -0,0 +1,104 @@
+import { it, describe } from "node:test";
+import { LwM2MObjectID } from "../lwm2m/LwM2MObjectID.js";
+import assert from "node:assert/strict";
+import { lwm2mToSenML } from "./lwm2mToSenML.js";
+void describe("lwm2mToSenML()", function() {
+    void it("should convert LwM2M to SenML", function() {
+        var location = {
+            ObjectID: LwM2MObjectID.Geolocation_14201,
+            ObjectVersion: "1.0",
+            Resources: {
+                "0": 62.469414,
+                "1": 6.151946,
+                "6": "Fixed",
+                "3": 1,
+                "99": new Date(1710147413003)
+            }
+        };
+        var level1 = {
+            ObjectID: LwM2MObjectID.SeaWaterLevel_14230,
+            ObjectVersion: "1.0",
+            Resources: {
+                "0": 84.3,
+                "1": "AES",
+                "99": new Date(1710140400000)
+            }
+        };
+        var level2 = {
+            ObjectID: LwM2MObjectID.SeaWaterLevel_14230,
+            ObjectVersion: "1.0",
+            Resources: {
+                "0": 140.4,
+                "1": "AES",
+                "99": new Date(1710144000000)
+            }
+        };
+        var level3 = {
+            ObjectID: LwM2MObjectID.SeaWaterLevel_14230,
+            ObjectVersion: "1.0",
+            ObjectInstanceID: 1,
+            Resources: {
+                "0": 140.7,
+                "1": "AES",
+                "99": new Date(1710144001000)
+            }
+        };
+        var lwm2m = [
+            location,
+            level1,
+            level2,
+            level3
+        ];
+        var expected = [
+            {
+                bn: "/14201/0/",
+                n: "0",
+                v: 62.469414,
+                bt: 1710147413003
+            },
+            {
+                n: "1",
+                v: 6.151946
+            },
+            {
+                n: "3",
+                v: 1
+            },
+            {
+                n: "6",
+                vs: "Fixed"
+            },
+            {
+                bn: "/14230/0/",
+                n: "0",
+                v: 84.3,
+                bt: 1710140400000
+            },
+            {
+                n: "1",
+                vs: "AES"
+            },
+            {
+                bn: "/14230/0/",
+                n: "0",
+                v: 140.4,
+                bt: 1710144000000
+            },
+            {
+                n: "1",
+                vs: "AES"
+            },
+            {
+                bn: "/14230/1/",
+                n: "0",
+                v: 140.7,
+                bt: 1710144001000
+            },
+            {
+                n: "1",
+                vs: "AES"
+            }
+        ];
+        assert.deepEqual(lwm2mToSenML(lwm2m), expected);
+    });
+});

package/dist/senml/parseResourceId.js

@@ -0,0 +1,58 @@
+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 _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 _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 parseResourceId = function(resourceId) {
+    if (!/^\/\d+\/\d+\/\d+\/\d+$/.test(resourceId)) return null;
+    var _resourceId_slice_split_map = _sliced_to_array(resourceId.slice(1).split("/").map(function(s) {
+        return parseInt(s, 10);
+    }), 4), ObjectID = _resourceId_slice_split_map[0], ObjectInstanceID = _resourceId_slice_split_map[1], ResourceID = _resourceId_slice_split_map[2], ResourceInstanceId = _resourceId_slice_split_map[3];
+    return {
+        ObjectID: ObjectID,
+        ObjectInstanceID: ObjectInstanceID,
+        ResourceID: ResourceID,
+        ResourceInstanceId: ResourceInstanceId
+    };
+};