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

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

@@ -44,86 +44,86 @@ 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 { 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.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")
+            '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)))),
+                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) {
+                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")),
+                        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)),
+                        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('transform'), createAssignment(transform.transform))
                     ]);
                 }))),
                 // 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") {
+    if (typeof v === 'string') {
         return ts.factory.createStringLiteral(v);
     }
     if (Array.isArray(v)) {
@@ -131,7 +131,7 @@ var createAssignment = function(v) {
             return createAssignment(el);
         }));
     }
-    if (typeof v === "object") return ts.factory.createObjectLiteralExpression(Object.entries(v).map(function(param) {
+    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));
     }));

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))
         ]);
     });

package/dist/generator/isDir.js

@@ -122,7 +122,7 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { stat } from "node:fs/promises";
+import { stat } from 'node:fs/promises';
 export var isDir = function() {
     var _ref = _async_to_generator(function(path) {
         var e;

package/dist/generator/isDir.spec.js

@@ -122,13 +122,13 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { isDir } from "./isDir.js";
-import { describe, it, before } from "node:test";
-import assert from "node:assert/strict";
-import os from "node:os";
-import { mkdtemp } from "node:fs/promises";
-import path from "node:path";
-void describe("isDir()", function() {
+import { isDir } from './isDir.js';
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert/strict';
+import os from 'node:os';
+import { mkdtemp } from 'node:fs/promises';
+import path from 'node:path';
+void describe('isDir()', function() {
     var dir;
     void before(/*#__PURE__*/ _async_to_generator(function() {
         return _ts_generator(this, function(_state) {
@@ -136,7 +136,7 @@ void describe("isDir()", function() {
                 case 0:
                     return [
                         4,
-                        mkdtemp(path.join(os.tmpdir(), "isdir-"))
+                        mkdtemp(path.join(os.tmpdir(), 'isdir-'))
                     ];
                 case 1:
                     dir = _state.sent();
@@ -146,7 +146,7 @@ void describe("isDir()", function() {
             }
         });
     }));
-    void it("should return true if the path is a directory", /*#__PURE__*/ _async_to_generator(function() {
+    void it('should return true if the path is a directory', /*#__PURE__*/ _async_to_generator(function() {
         var _;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
@@ -167,7 +167,7 @@ void describe("isDir()", function() {
             }
         });
     }));
-    void it("should return false if the path is not a directory", /*#__PURE__*/ _async_to_generator(function() {
+    void it('should return false if the path is not a directory', /*#__PURE__*/ _async_to_generator(function() {
         var _;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
@@ -175,7 +175,7 @@ void describe("isDir()", function() {
                     _ = assert.strictEqual;
                     return [
                         4,
-                        isDir(path.join(dir, "foo.txt"))
+                        isDir(path.join(dir, 'foo.txt'))
                     ];
                 case 1:
                     return [
@@ -188,7 +188,7 @@ void describe("isDir()", function() {
             }
         });
     }));
-    void it("should return false if an error occurs", /*#__PURE__*/ _async_to_generator(function() {
+    void it('should return false if an error occurs', /*#__PURE__*/ _async_to_generator(function() {
         var _;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
@@ -196,7 +196,7 @@ void describe("isDir()", function() {
                     _ = assert.strictEqual;
                     return [
                         4,
-                        isDir(path.join(dir, "foo"))
+                        isDir(path.join(dir, 'foo'))
                     ];
                 case 1:
                     return [

package/dist/generator/lwm2m.js

@@ -24,15 +24,15 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 var _path;
-import chalk from "chalk";
-import { readFile, readdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { unwrapNestedArray } from "../lwm2m/unwrapNestedArray.js";
-import xml2js from "xml2js";
-import { generateLwm2mTimestampResources } from "./generateLwm2mTimestampResources.js";
-import { printNode } from "./printNode.js";
-import os from "node:os";
-import { generateLwM2MDefinitions } from "./generateLwM2MDefinitions.js";
+import chalk from 'chalk';
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { unwrapNestedArray } from '../lwm2m/unwrapNestedArray.js';
+import xml2js from 'xml2js';
+import { generateLwm2mTimestampResources } from './generateLwm2mTimestampResources.js';
+import { printNode } from './printNode.js';
+import os from 'node:os';
+import { generateLwM2MDefinitions } from './generateLwM2MDefinitions.js';
 var baseDir = process.cwd();
 var subDir = function() {
     for(var _len = arguments.length, tree = new Array(_len), _key = 0; _key < _len; _key++){
@@ -42,16 +42,16 @@ var subDir = function() {
         baseDir
     ].concat(_to_consumable_array(tree)));
 };
-console.log(chalk.gray("LwM2M"));
+console.log(chalk.gray('LwM2M'));
 // Load definitions
 var definitions = [];
 var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
 try {
-    for(var _iterator = (await readdir(subDir("lwm2m"))).filter(function(s) {
-        return s.endsWith(".xml");
+    for(var _iterator = (await readdir(subDir('lwm2m'))).filter(function(s) {
+        return s.endsWith('.xml');
     })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
         var objectDefinitionFile = _step.value;
-        var definition = unwrapNestedArray(await xml2js.parseStringPromise(await readFile(subDir("lwm2m", objectDefinitionFile), "utf-8"))).LWM2M.Object;
+        var definition = unwrapNestedArray(await xml2js.parseStringPromise(await readFile(subDir('lwm2m', objectDefinitionFile), 'utf-8'))).LWM2M.Object;
         definitions.push(definition);
     }
 } catch (err) {
@@ -68,7 +68,7 @@ try {
         }
     }
 }
-console.log(chalk.gray("", "\xb7"), chalk.gray("timestamp resources map"));
+console.log(chalk.gray('', '·'), chalk.gray('timestamp resources map'));
 var timestampResources = {};
 var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
 try {
@@ -78,10 +78,10 @@ try {
         var ObjectID = parseInt(definition1.ObjectID, 10);
         var ResourceId = parseInt((_definition_Resources_Item_find = definition1.Resources.Item.find(function(param) {
             var Type = param.Type;
-            return Type === "Time";
+            return Type === 'Time';
         })) === null || _definition_Resources_Item_find === void 0 ? void 0 : _definition_Resources_Item_find.$.ID, 10);
         timestampResources[ObjectID] = ResourceId;
-        console.log("  ", chalk.gray("\xb7"), "".concat(chalk.white(ObjectID)).concat(chalk.gray(".")).concat(chalk.white(ResourceId)));
+        console.log('  ', chalk.gray('·'), "".concat(chalk.white(ObjectID)).concat(chalk.gray('.')).concat(chalk.white(ResourceId)));
     }
 } catch (err) {
     _didIteratorError1 = true;
@@ -97,10 +97,10 @@ try {
         }
     }
 }
-var timestampResourcesFile = subDir("lwm2m", "timestampResources.ts");
-console.log(chalk.green("Writing"), chalk.blue(timestampResourcesFile.replace(baseDir, "")));
-await writeFile(timestampResourcesFile, generateLwm2mTimestampResources(timestampResources).map(printNode).join(os.EOL), "utf-8");
-console.log(chalk.gray("", "\xb7"), chalk.gray("static object information"));
-var definitionsFile = subDir("lwm2m", "definitions.ts");
-console.log(chalk.green("Writing"), chalk.blue(definitionsFile.replace(baseDir, "")));
-await writeFile(definitionsFile, generateLwM2MDefinitions(definitions).map(printNode).join(os.EOL), "utf-8");
+var timestampResourcesFile = subDir('lwm2m', 'timestampResources.ts');
+console.log(chalk.green('Writing'), chalk.blue(timestampResourcesFile.replace(baseDir, '')));
+await writeFile(timestampResourcesFile, generateLwm2mTimestampResources(timestampResources).map(printNode).join(os.EOL), 'utf-8');
+console.log(chalk.gray('', '·'), chalk.gray('static object information'));
+var definitionsFile = subDir('lwm2m', 'definitions.ts');
+console.log(chalk.green('Writing'), chalk.blue(definitionsFile.replace(baseDir, '')));
+await writeFile(definitionsFile, generateLwM2MDefinitions(definitions).map(printNode).join(os.EOL), 'utf-8');