@hello.nrfcloud.com/proto-map 5.6.2 → 6.0.0

package/dist/generator/generateLwM2MDefinitions.spec.js

@@ -1,23 +1,23 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { definitions } from "../lwm2m/definitions.js";
-import { LwM2MObjectID } from "../lwm2m/LwM2MObjectID.js";
-import { ResourceType } from "../lwm2m/LWM2MObjectInfo.js";
-void describe("generateLwM2MDefinitions()", function() {
-    void it("should have generated definitions from the XML files", function() {
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { definitions } from '../lwm2m/definitions.js';
+import { LwM2MObjectID } from '../lwm2m/LwM2MObjectID.js';
+import { ResourceType } from '../lwm2m/LWM2MObjectInfo.js';
+void describe('generateLwM2MDefinitions()', function() {
+    void it('should have generated definitions from the XML files', function() {
         assert.deepEqual(definitions[LwM2MObjectID.Geolocation_14201], {
             ObjectID: 14201,
-            ObjectVersion: "1.0",
-            Name: "Geolocation",
-            Description: "Describes the geo location of a device",
+            ObjectVersion: '1.0',
+            Name: 'Geolocation',
+            Description: 'Describes the geo location of a device',
             Resources: {
                 0: {
                     ResourceID: 0,
-                    Name: "Latitude",
+                    Name: 'Latitude',
                     Mandatory: true,
                     Type: ResourceType.Float,
-                    Description: "The decimal notation of latitude in degrees, e.g. -43.5723 [World Geodetic System 1984].",
-                    Units: "\xb0",
+                    Description: 'The decimal notation of latitude in degrees, e.g. -43.5723 [World Geodetic System 1984].',
+                    Units: '°',
                     RangeEnumeration: {
                         max: 90,
                         min: -90
@@ -25,11 +25,11 @@ void describe("generateLwM2MDefinitions()", function() {
                 },
                 1: {
                     ResourceID: 1,
-                    Name: "Longitude",
+                    Name: 'Longitude',
                     Mandatory: true,
                     Type: ResourceType.Float,
-                    Description: "The decimal notation of longitude in degrees, e.g. 153.21760 [World Geodetic System 1984].",
-                    Units: "\xb0",
+                    Description: 'The decimal notation of longitude in degrees, e.g. 153.21760 [World Geodetic System 1984].',
+                    Units: '°',
                     RangeEnumeration: {
                         max: 180,
                         min: -180
@@ -37,35 +37,35 @@ void describe("generateLwM2MDefinitions()", function() {
                 },
                 2: {
                     ResourceID: 2,
-                    Name: "Altitude",
+                    Name: 'Altitude',
                     Mandatory: false,
                     Type: ResourceType.Float,
-                    Description: "The decimal notation of altitude in meters above sea level.",
-                    Units: "m"
+                    Description: 'The decimal notation of altitude in meters above sea level.',
+                    Units: 'm'
                 },
                 3: {
                     ResourceID: 3,
-                    Name: "Radius",
+                    Name: 'Radius',
                     Mandatory: false,
                     Type: ResourceType.Float,
-                    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.",
-                    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.',
+                    Units: 'm'
                 },
                 4: {
                     ResourceID: 4,
-                    Name: "Speed",
+                    Name: 'Speed',
                     Mandatory: false,
                     Type: ResourceType.Float,
-                    Description: "Speed is the time rate of change in position.",
-                    Units: "m/s"
+                    Description: 'Speed is the time rate of change in position.',
+                    Units: 'm/s'
                 },
                 5: {
                     ResourceID: 5,
-                    Name: "Heading",
+                    Name: 'Heading',
                     Mandatory: false,
                     Type: ResourceType.Float,
-                    Description: "The angle of movement in degrees.",
-                    Units: "\xb0",
+                    Description: 'The angle of movement in degrees.',
+                    Units: '°',
                     RangeEnumeration: {
                         min: 0,
                         max: 360
@@ -73,17 +73,17 @@ void describe("generateLwM2MDefinitions()", function() {
                 },
                 6: {
                     ResourceID: 6,
-                    Name: "Source",
+                    Name: 'Source',
                     Mandatory: true,
                     Type: ResourceType.String,
-                    Description: "The source of the geo location, e.g. GNSS, SCELL, MCELL, WIFI."
+                    Description: 'The source of the geo location, e.g. GNSS, SCELL, MCELL, WIFI.'
                 },
                 99: {
                     ResourceID: 99,
-                    Name: "Timestamp",
+                    Name: 'Timestamp',
                     Mandatory: true,
                     Type: ResourceType.Time,
-                    Description: "The timestamp of when the location measurement was performed."
+                    Description: 'The timestamp of when the location measurement was performed.'
                 }
             }
         });

package/dist/generator/generateLwm2mTimestampResources.js

@@ -44,16 +44,16 @@ function _unsupported_iterable_to_array(o, minLen) {
     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 ts from "typescript";
-import { addDocBlock } from "./addDocBlock.js";
+import ts from 'typescript';
+import { addDocBlock } from './addDocBlock.js';
 export var generateLwm2mTimestampResources = function(timestampResources) {
     var type = ts.factory.createVariableStatement([
         ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier("timestampResources"), undefined, ts.factory.createTypeReferenceNode("Readonly", [
-            ts.factory.createTypeReferenceNode("Record", [
-                ts.factory.createTypeReferenceNode("number"),
-                ts.factory.createTypeReferenceNode("number")
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier("timestampResources"), undefined, ts.factory.createTypeReferenceNode('Readonly', [
+            ts.factory.createTypeReferenceNode('Record', [
+                ts.factory.createTypeReferenceNode('number'),
+                ts.factory.createTypeReferenceNode('number')
             ])
         ]), ts.factory.createObjectLiteralExpression(Object.entries(timestampResources).map(function(param) {
             var _param = _sliced_to_array(param, 2), k = _param[0], v = _param[1];
@@ -61,7 +61,7 @@ export var generateLwm2mTimestampResources = function(timestampResources) {
         })))
     ], ts.NodeFlags.Const));
     addDocBlock([
-        "Contains the ID of the resource that defines the timestamp for each LwM2M object definition"
+        'Contains the ID of the resource that defines the timestamp for each LwM2M object definition'
     ], type);
     return [
         type

package/dist/generator/generateModels.js

@@ -1,142 +1,57 @@
-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 ts from "typescript";
-import { addDocBlock } from "./addDocBlock.js";
-import { tokenizeName } from "./tokenizeName.js";
-import { parseREADME } from "markdown/parseREADME.js";
+import ts from 'typescript';
+import { addDocBlock } from './addDocBlock.js';
+import { tokenizeName } from './tokenizeName.js';
+import { parseREADME } from 'markdown/parseREADME.js';
 export var generateModels = function(models) {
     var types = [];
-    types.push(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
-        ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier("Transform")),
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("TransformType"))
-    ])), ts.factory.createStringLiteral("./types.js")));
     types.push(addDocBlock([
-        "The Model IDs defined in this repo."
+        'The Model IDs defined in this repo.'
     ], ts.factory.createEnumDeclaration([
         ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
-    ], ts.factory.createIdentifier("ModelID"), models.map(function(param) {
+    ], ts.factory.createIdentifier('ModelID'), models.map(function(param) {
         var id = param.id;
         return ts.factory.createEnumMember(tokenizeName(id), ts.factory.createStringLiteral(id));
     }))));
     types.push(ts.factory.createTypeAliasDeclaration([
         ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
-    ], ts.factory.createIdentifier("Model"), undefined, ts.factory.createTypeLiteralNode([
+    ], ts.factory.createIdentifier('Model'), undefined, ts.factory.createTypeLiteralNode([
         addDocBlock([
-            "The Model ID"
-        ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral("id"), undefined, ts.factory.createTypeReferenceNode("ModelID"))),
+            'The Model ID'
+        ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral('id'), undefined, ts.factory.createTypeReferenceNode('ModelID'))),
         addDocBlock([
-            "The transforms defined for this model."
-        ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral("transforms"), undefined, ts.factory.createTypeReferenceNode("Array", [
-            ts.factory.createTypeReferenceNode("Transform")
-        ]))),
-        addDocBlock([
-            "Description of the Model from the README.md"
-        ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral("about"), undefined, ts.factory.createTypeLiteralNode([
+            'Description of the Model from the README.md'
+        ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral('about'), undefined, ts.factory.createTypeLiteralNode([
             addDocBlock([
-                "The text of the H1 headline"
-            ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral("title"), undefined, ts.factory.createTypeReferenceNode("string"))),
+                'The text of the H1 headline'
+            ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral('title'), undefined, ts.factory.createTypeReferenceNode('string'))),
             addDocBlock([
-                "The text of the paragraphs following the H1 headline"
-            ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral("description"), undefined, ts.factory.createTypeReferenceNode("string")))
+                'The text of the paragraphs following the H1 headline'
+            ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral('description'), undefined, ts.factory.createTypeReferenceNode('string')))
         ])))
     ])));
     types.push(addDocBlock([
-        "The models defined for hello.nrfcloud.com"
+        'The models defined for hello.nrfcloud.com'
     ], ts.factory.createVariableStatement([
         ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier("models"), undefined, ts.factory.createTypeReferenceNode("Readonly", [
-            ts.factory.createTypeReferenceNode("Record", [
-                ts.factory.createTypeReferenceNode("ModelID", []),
-                ts.factory.createTypeReferenceNode("Model", [])
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier("models"), undefined, ts.factory.createTypeReferenceNode('Readonly', [
+            ts.factory.createTypeReferenceNode('Record', [
+                ts.factory.createTypeReferenceNode('ModelID', []),
+                ts.factory.createTypeReferenceNode('Model', [])
             ])
         ]), ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression(models.map(function(model) {
             var readme = parseREADME(model.readmeMarkdown);
-            return ts.factory.createPropertyAssignment(ts.factory.createComputedPropertyName(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ModelID"), ts.factory.createIdentifier(tokenizeName(model.id)))), // The model object
+            return ts.factory.createPropertyAssignment(ts.factory.createComputedPropertyName(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('ModelID'), ts.factory.createIdentifier(tokenizeName(model.id)))), // The model object
             ts.factory.createObjectLiteralExpression([
                 // id
-                ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("id"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ModelID"), ts.factory.createIdentifier(tokenizeName(model.id)))),
-                // transforms
-                ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("transforms"), ts.factory.createArrayLiteralExpression(model.transforms.map(function(transform) {
-                    return ts.factory.createObjectLiteralExpression([
-                        // type
-                        ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("type"), transform.type === "messages" ? ts.factory.createIdentifier("TransformType.Messages") : ts.factory.createIdentifier("TransformType.Shadow")),
-                        // match
-                        ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("match"), createAssignment(transform.match)),
-                        // transform
-                        ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("transform"), createAssignment(transform.transform))
-                    ]);
-                }))),
+                ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('id'), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('ModelID'), ts.factory.createIdentifier(tokenizeName(model.id)))),
                 // About
-                ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("about"), ts.factory.createObjectLiteralExpression([
-                    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("title"), ts.factory.createStringLiteral(readme.heading)),
-                    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("description"), ts.factory.createStringLiteral(readme.description.join("\n")))
+                ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('about'), ts.factory.createObjectLiteralExpression([
+                    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('title'), ts.factory.createStringLiteral(readme.heading)),
+                    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('description'), ts.factory.createStringLiteral(readme.description.join('\n')))
                 ]))
             ]));
-        })), ts.factory.createTypeReferenceNode("const")))
+        })), ts.factory.createTypeReferenceNode('const')))
     ], ts.NodeFlags.Const))));
     return types;
 };
-var createAssignment = function(v) {
-    if (v === null) return ts.factory.createNull();
-    if (typeof v === "string") {
-        return ts.factory.createStringLiteral(v);
-    }
-    if (Array.isArray(v)) {
-        return ts.factory.createArrayLiteralExpression(v.map(function(el) {
-            return createAssignment(el);
-        }));
-    }
-    if (typeof v === "object") return ts.factory.createObjectLiteralExpression(Object.entries(v).map(function(param) {
-        var _param = _sliced_to_array(param, 2), k = _param[0], _$v = _param[1];
-        return ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(k), createAssignment(_$v));
-    }));
-    return addDocBlock([
-        "Could not convert node",
-        JSON.stringify(v)
-    ], ts.factory.createNull());
-};

package/dist/generator/generateType.js

@@ -1,8 +1,8 @@
-import ts from "typescript";
-import { addDocBlock } from "./addDocBlock.js";
-import { LwM2MType } from "../lwm2m/resourceType.js";
-import { tokenizeName } from "./tokenizeName.js";
-import { parseRangeEnumeration } from "lwm2m/parseRangeEnumeration.js";
+import ts from 'typescript';
+import { addDocBlock } from './addDocBlock.js';
+import { LwM2MType } from '../lwm2m/resourceType.js';
+import { tokenizeName } from './tokenizeName.js';
+import { parseRangeEnumeration } from 'lwm2m/parseRangeEnumeration.js';
 export var generateType = function(param) {
     var ObjectID = param.ObjectID, ObjectVersion = param.ObjectVersion, Name = param.Name, Description1 = param.Description1, Resources = param.Resources;
     var name = generateName({
@@ -11,27 +11,27 @@ export var generateType = function(param) {
     });
     var importLwM2MObject = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(true, undefined, ts.factory.createNamedImports([
         ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("LwM2MObject"))
-    ])), ts.factory.createStringLiteral("../LwM2MObject.js"));
+    ])), ts.factory.createStringLiteral('../LwM2MObject.js'));
     var importLwM2MObjectID = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
         ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("LwM2MObjectID"))
-    ])), ts.factory.createStringLiteral("../LwM2MObjectID.js"));
+    ])), ts.factory.createStringLiteral('../LwM2MObjectID.js'));
     // Generate the type
     var exportType = ts.factory.createTypeAliasDeclaration([
         ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
-    ], ts.factory.createIdentifier(name), undefined, ts.factory.createTypeReferenceNode("LwM2MObject", [
+    ], ts.factory.createIdentifier(name), undefined, ts.factory.createTypeReferenceNode('LwM2MObject', [
         ts.factory.createTypeLiteralNode([
-            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier("ObjectID"), undefined, ts.factory.createTypeReferenceNode("LwM2MObjectID.".concat(name), undefined)),
-            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier("ObjectVersion"), undefined, ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(ObjectVersion !== null && ObjectVersion !== void 0 ? ObjectVersion : "1.0"))),
-            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier("Resources"), undefined, ts.factory.createTypeLiteralNode(byImportance(Resources.Item).map(function(resource) {
-                var res = ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier("".concat(resource.$.ID)), resource.Mandatory === "Mandatory" ? undefined : ts.factory.createToken(ts.SyntaxKind.QuestionToken), typeScriptResourceType(resource.Type));
+            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier('ObjectID'), undefined, ts.factory.createTypeReferenceNode("LwM2MObjectID.".concat(name), undefined)),
+            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier('ObjectVersion'), undefined, ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(ObjectVersion !== null && ObjectVersion !== void 0 ? ObjectVersion : '1.0'))),
+            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier('Resources'), undefined, ts.factory.createTypeLiteralNode(byImportance(Resources.Item).map(function(resource) {
+                var res = ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier("".concat(resource.$.ID)), resource.Mandatory === 'Mandatory' ? undefined : ts.factory.createToken(ts.SyntaxKind.QuestionToken), typeScriptResourceType(resource.Type));
                 addDocBlock([
-                    "".concat(resource.Name).concat(resource.Units.length > 0 ? " (".concat(resource.Units, ")") : ""),
+                    "".concat(resource.Name).concat(resource.Units.length > 0 ? " (".concat(resource.Units, ")") : ''),
                     "",
                     resource.Description
                 ], res);
                 if (resource.RangeEnumeration.length > 0) {
                     var maybeRange = parseRangeEnumeration(resource.RangeEnumeration);
-                    if ("error" in maybeRange) throw maybeRange.error;
+                    if ('error' in maybeRange) throw maybeRange.error;
                     addDocBlock([
                         "Minimum: ".concat(maybeRange.range.min),
                         "Maximum: ".concat(maybeRange.range.max)
@@ -43,7 +43,7 @@ export var generateType = function(param) {
     ]));
     addDocBlock([
         "".concat(Name, " (").concat(ObjectID, ")"),
-        "",
+        '',
         Description1
     ], exportType);
     return [
@@ -61,16 +61,16 @@ var typeScriptResourceType = function(type) {
         case LwM2MType.Float:
         case LwM2MType.Integer:
         case LwM2MType.UnsignedInteger:
-            return ts.factory.createTypeReferenceNode("number");
+            return ts.factory.createTypeReferenceNode('number');
         case LwM2MType.Boolean:
-            return ts.factory.createTypeReferenceNode("boolean");
+            return ts.factory.createTypeReferenceNode('boolean');
         case LwM2MType.String:
         case LwM2MType.Opaque:
         case LwM2MType.Corelnk:
         case LwM2MType.Objlnk:
-            return ts.factory.createTypeReferenceNode("string");
+            return ts.factory.createTypeReferenceNode('string');
         case LwM2MType.Time:
-            return ts.factory.createTypeReferenceNode("Date");
+            return ts.factory.createTypeReferenceNode('Date');
         default:
             throw new Error("Unexpected resource type: ".concat(type));
     }
@@ -83,8 +83,8 @@ var byImportance = function(resources) {
     })// sort mandatory up
     .sort(function(param, param1) {
         var m1 = param.Mandatory, m2 = param1.Mandatory;
-        if (m1 === "Mandatory" && m2 === "Mandatory") return 0;
-        if (m1 === "Mandatory") return -1;
+        if (m1 === 'Mandatory' && m2 === 'Mandatory') return 0;
+        if (m1 === 'Mandatory') return -1;
         return 1;
     });
 };

package/dist/generator/generateValidator.js

@@ -23,15 +23,15 @@ function _unsupported_iterable_to_array(o, minLen) {
     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 ts from "typescript";
-import { generateName } from "./generateType.js";
-import { addDocBlock } from "./addDocBlock.js";
+import ts from 'typescript';
+import { generateName } from './generateType.js';
+import { addDocBlock } from './addDocBlock.js';
 export var generateValidator = function(param) {
     var ObjectID = param.ObjectID, ObjectVersion = param.ObjectVersion, Name = param.Name, Resources = param.Resources;
     // import type { LwM2MObject } from './LwM2MObject.js'
     var importLwM2MObject = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(true, undefined, ts.factory.createNamedImports([
         ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("LwM2MObject"))
-    ])), ts.factory.createStringLiteral("../LwM2MObject.js"));
+    ])), ts.factory.createStringLiteral('../LwM2MObject.js'));
     /*
     import {
         DateResource,
@@ -43,10 +43,10 @@ export var generateValidator = function(param) {
     */ var importValidation = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(_to_consumable_array(getResourceValidators({
         Resources: Resources
     })).concat([
-        "validate"
+        'validate'
     ]).map(function(res) {
         return ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(res));
-    }))), ts.factory.createStringLiteral("../validation.js"));
+    }))), ts.factory.createStringLiteral('../validation.js'));
     // import type { Geolocation_14201 } from './objects.js'
     var name = generateName({
         Name: Name,
@@ -54,32 +54,32 @@ export var generateValidator = function(param) {
     });
     var importObjectType = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(true, undefined, ts.factory.createNamedImports([
         ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(name))
-    ])), ts.factory.createStringLiteral("../objects.js"));
+    ])), ts.factory.createStringLiteral('../objects.js'));
     // import { LwM2MObjectID } from './LwM2MObjectID.js'
     var importLwM2MObjectID = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
         ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("LwM2MObjectID"))
-    ])), ts.factory.createStringLiteral("../LwM2MObjectID.js"));
+    ])), ts.factory.createStringLiteral('../LwM2MObjectID.js'));
     // validate ...
     var validate = ts.factory.createVariableStatement([
         ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
         ts.factory.createVariableDeclaration(ts.factory.createIdentifier("validate".concat(ObjectID)), undefined, undefined, ts.factory.createArrowFunction(undefined, undefined, [
-            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("o"), undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
-            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("onError"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createFunctionTypeNode(undefined, [
-                ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("error"), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Error")))
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('o'), undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('onError'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createFunctionTypeNode(undefined, [
+                ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('error'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Error')))
             ], ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword)))
-        ], ts.factory.createTypePredicateNode(undefined, ts.factory.createIdentifier("o"), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("LwM2MObject"), [
+        ], ts.factory.createTypePredicateNode(undefined, ts.factory.createIdentifier('o'), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('LwM2MObject'), [
             ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(name))
-        ])), undefined, ts.factory.createCallExpression(ts.factory.createCallExpression(ts.factory.createIdentifier("validate"), undefined, [
-            ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("LwM2MObjectID"), ts.factory.createIdentifier(name)),
-            ts.factory.createStringLiteral(ObjectVersion !== null && ObjectVersion !== void 0 ? ObjectVersion : "1.0"),
+        ])), undefined, ts.factory.createCallExpression(ts.factory.createCallExpression(ts.factory.createIdentifier('validate'), undefined, [
+            ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('LwM2MObjectID'), ts.factory.createIdentifier(name)),
+            ts.factory.createStringLiteral(ObjectVersion !== null && ObjectVersion !== void 0 ? ObjectVersion : '1.0'),
             ts.factory.createObjectLiteralExpression(Resources.Item.map(function(Resource) {
                 var validator = ts.factory.createPropertyAssignment(ts.factory.createNumericLiteral(Resource.$.ID), toResourceValidator(Resource));
                 return validator;
             }))
         ]), undefined, [
-            ts.factory.createIdentifier("o"),
-            ts.factory.createIdentifier("onError")
+            ts.factory.createIdentifier('o'),
+            ts.factory.createIdentifier('onError')
         ])))
     ], ts.NodeFlags.Const));
     addDocBlock([
@@ -97,23 +97,23 @@ export var generateValidator = function(param) {
 };
 var toResourceValidator = function(Resource) {
     var valueValidator = ts.factory.createIdentifier(typeToValidator(Resource.Type));
-    if (Resource.Mandatory === "Optional") return ts.factory.createCallExpression(ts.factory.createIdentifier("OptionalResource"), undefined, [
+    if (Resource.Mandatory === 'Optional') return ts.factory.createCallExpression(ts.factory.createIdentifier('OptionalResource'), undefined, [
         valueValidator
     ]);
     return valueValidator;
 };
 var typeToValidator = function(Type) {
     switch(Type){
-        case "String":
-        case "Opaque":
-            return "StringResource";
-        case "Float":
-        case "Integer":
-            return "NumberResource";
-        case "Boolean":
-            return "BooleanResource";
-        case "Time":
-            return "DateResource";
+        case 'String':
+        case 'Opaque':
+            return 'StringResource';
+        case 'Float':
+        case 'Integer':
+            return 'NumberResource';
+        case 'Boolean':
+            return 'BooleanResource';
+        case 'Time':
+            return 'DateResource';
         default:
             throw new Error("Unsupported Resource type ".concat(Type, "!"));
     }
@@ -124,7 +124,7 @@ var getResourceValidators = function(param) {
         var Type = param.Type, Mandatory = param.Mandatory;
         return [
             typeToValidator(Type),
-            Mandatory === "Optional" ? "OptionalResource" : undefined
+            Mandatory === 'Optional' ? 'OptionalResource' : undefined
         ];
     }).flat().filter(function(d) {
         return d !== undefined;

package/dist/generator/generateValidators.js

@@ -23,14 +23,14 @@ function _unsupported_iterable_to_array(o, minLen) {
     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 ts from "typescript";
-import { generateName } from "./generateType.js";
-import { addDocBlock } from "./addDocBlock.js";
+import ts from 'typescript';
+import { generateName } from './generateType.js';
+import { addDocBlock } from './addDocBlock.js';
 export var generateValidators = function(objects) {
     // import { LwM2MObjectID } from './LwM2MObjectID.js'
     var importLwM2MObjectID = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
         ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("LwM2MObjectID"))
-    ])), ts.factory.createStringLiteral("./LwM2MObjectID.js"));
+    ])), ts.factory.createStringLiteral('./LwM2MObjectID.js'));
     var validatorImports = objects.map(function(object) {
         return ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
             ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("validate".concat(object.ObjectID)))
@@ -39,10 +39,10 @@ export var generateValidators = function(objects) {
     var validators = ts.factory.createVariableStatement([
         ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier("validators"), undefined, undefined, ts.factory.createNewExpression(ts.factory.createIdentifier("Map"), [
-            ts.factory.createTypeReferenceNode("LwM2MObjectID"),
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier("validators"), undefined, undefined, ts.factory.createNewExpression(ts.factory.createIdentifier('Map'), [
+            ts.factory.createTypeReferenceNode('LwM2MObjectID'),
             ts.factory.createFunctionTypeNode(undefined, [
-                ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("o"), undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword))
+                ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('o'), undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword))
             ], ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword))
         ], []))
     ], ts.NodeFlags.Const));
@@ -50,8 +50,8 @@ export var generateValidators = function(objects) {
         "Contains the validators for all registered LwM2M objects."
     ], validators);
     var validatorRegistrations = objects.map(function(object) {
-        return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("validators"), ts.factory.createIdentifier("set")), undefined, [
-            ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("LwM2MObjectID"), ts.factory.createIdentifier(generateName(object))),
+        return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('validators'), ts.factory.createIdentifier('set')), undefined, [
+            ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('LwM2MObjectID'), ts.factory.createIdentifier(generateName(object))),
             ts.factory.createIdentifier("validate".concat(object.ObjectID))
         ]);
     });