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

package/dist/generator/models.js

@@ -150,16 +150,16 @@ function _ts_generator(thisArg, body) {
     }
 }
 var _path;
-import chalk from "chalk";
-import { readFile, readdir, stat, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { getCodeBlock } from "../markdown/getCodeBlock.js";
-import { getFrontMatter } from "../markdown/getFrontMatter.js";
-import { generateModels } from "./generateModels.js";
-import { printNode } from "./printNode.js";
-import { FrontMatter } from "../models/types.js";
-import { isDir } from "./isDir.js";
+import chalk from 'chalk';
+import { readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { getCodeBlock } from '../markdown/getCodeBlock.js';
+import { getFrontMatter } from '../markdown/getFrontMatter.js';
+import { generateModels } from './generateModels.js';
+import { printNode } from './printNode.js';
+import { FrontMatter } from '../models/types.js';
+import { isDir } from './isDir.js';
 var baseDir = process.cwd();
 var subDir = function() {
     for(var _len = arguments.length, tree = new Array(_len), _key = 0; _key < _len; _key++){
@@ -169,14 +169,14 @@ var subDir = function() {
         baseDir
     ].concat(_to_consumable_array(tree)));
 };
-console.log(chalk.gray("Models"));
+console.log(chalk.gray('Models'));
 var loadModelTransforms = function() {
     var _ref = _async_to_generator(function(model) {
         var transformersDir, _;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    transformersDir = subDir("models", model, "transforms");
+                    transformersDir = subDir('models', model, 'transforms');
                     return [
                         4,
                         isDir(transformersDir)
@@ -198,7 +198,7 @@ var loadModelTransforms = function() {
                             _state.sent()
                         ]).then(function(entries) {
                             return entries.filter(function(e) {
-                                return e.endsWith(".md");
+                                return e.endsWith('.md');
                             });
                         }).then(function() {
                             var _ref = _async_to_generator(function(expressions) {
@@ -210,7 +210,7 @@ var loadModelTransforms = function() {
                                                 return _ts_generator(this, function(_state) {
                                                     return [
                                                         2,
-                                                        readFile(subDir("models", model, "transforms", expression), "utf-8")
+                                                        readFile(subDir('models', model, 'transforms', expression), 'utf-8')
                                                     ];
                                                 });
                                             });
@@ -229,8 +229,8 @@ var loadModelTransforms = function() {
                                 var findBlock = getCodeBlock(markdown);
                                 return {
                                     type: getFrontMatter(markdown, FrontMatter).type,
-                                    match: findBlock("jsonata", "Match Expression"),
-                                    transform: findBlock("jsonata", "Transform Expression")
+                                    match: findBlock('jsonata', 'Match Expression'),
+                                    transform: findBlock('jsonata', 'Transform Expression')
                                 };
                             });
                         })
@@ -242,7 +242,7 @@ var loadModelTransforms = function() {
         return _ref.apply(this, arguments);
     };
 }();
-var models = await Promise.all((await Promise.all((await readdir(subDir("models"))).map(function() {
+var models = await Promise.all((await Promise.all((await readdir(subDir('models'))).map(function() {
     var _ref = _async_to_generator(function(f) {
         var _tmp;
         return _ts_generator(this, function(_state) {
@@ -253,7 +253,7 @@ var models = await Promise.all((await Promise.all((await readdir(subDir("models"
                     };
                     return [
                         4,
-                        stat(subDir("models", f))
+                        stat(subDir('models', f))
                     ];
                 case 1:
                     return [
@@ -275,7 +275,7 @@ var models = await Promise.all((await Promise.all((await readdir(subDir("models"
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    console.log(chalk.gray("\xb7"), chalk.white(model.name));
+                    console.log(chalk.gray('·'), chalk.white(model.name));
                     _tmp = {
                         id: model.name
                     };
@@ -287,7 +287,7 @@ var models = await Promise.all((await Promise.all((await readdir(subDir("models"
                     _tmp.transforms = _state.sent();
                     return [
                         4,
-                        readFile(path.join(subDir("models"), model.name, "README.md"), "utf-8")
+                        readFile(path.join(subDir('models'), model.name, 'README.md'), 'utf-8')
                     ];
                 case 2:
                     return [
@@ -301,6 +301,6 @@ var models = await Promise.all((await Promise.all((await readdir(subDir("models"
         return _ref.apply(this, arguments);
     };
 }()));
-var modelsFile = subDir("models", "models.ts");
-console.log(chalk.green("Writing"), chalk.blue(modelsFile.replace(baseDir, "")));
-await writeFile(modelsFile, generateModels(models).map(printNode).join(os.EOL), "utf-8");
+var modelsFile = subDir('models', 'models.ts');
+console.log(chalk.green('Writing'), chalk.blue(modelsFile.replace(baseDir, '')));
+await writeFile(modelsFile, generateModels(models).map(printNode).join(os.EOL), 'utf-8');

package/dist/generator/printNode.js

@@ -1,5 +1,5 @@
-import ts from "typescript";
-var resultFile = ts.createSourceFile("stub.ts", "", ts.ScriptTarget.Latest, /*setParentNodes*/ false, ts.ScriptKind.TS);
+import ts from 'typescript';
+var resultFile = ts.createSourceFile("stub.ts", '', ts.ScriptTarget.Latest, /*setParentNodes*/ false, ts.ScriptKind.TS);
 var printer = ts.createPrinter({
     newLine: ts.NewLineKind.LineFeed
 });

package/dist/generator/tokenizeName.js

@@ -1,5 +1,5 @@
 export var tokenizeName = function(name) {
-    return name.split(" ").map(function(s) {
+    return name.split(' ').map(function(s) {
         return "".concat(s.slice(0, 1).toUpperCase()).concat(s.slice(1));
-    }).join(" ").replaceAll(" ", "").replaceAll("&", "and").replace(/^(\d)(.+)/, "n$1$2").replaceAll(/[^a-z0-9]/gi, "_").replaceAll(/_{2,}/g, "_").replaceAll(/_+$/g, "").trim();
+    }).join(' ').replaceAll(' ', '').replaceAll('&', 'and').replace(/^(\d)(.+)/, 'n$1$2').replaceAll(/[^a-z0-9]/gi, '_').replaceAll(/_{2,}/g, '_').replaceAll(/_+$/g, '').trim();
 };

package/dist/generator/tokenizeName.spec.js

@@ -44,10 +44,10 @@ 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 { tokenizeName } from "./tokenizeName.js";
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-void describe("tokenizeName", function() {
+import { tokenizeName } from './tokenizeName.js';
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+void describe('tokenizeName', function() {
     var _loop = function(_i, _iter) {
         var _iter__i = _sliced_to_array(_iter[_i], 2), name = _iter__i[0], expected = _iter__i[1];
         void it("should replaced ".concat(name, " to ").concat(expected), function() {
@@ -57,42 +57,42 @@ void describe("tokenizeName", function() {
     for(var _i = 0, _iter = [
         // Uppercase words
         [
-            "Battery and Power",
-            "BatteryAndPower"
+            'Battery and Power',
+            'BatteryAndPower'
         ],
         [
-            "LwM2M Server",
-            "LwM2MServer"
+            'LwM2M Server',
+            'LwM2MServer'
         ],
         // Dash -> underline
         [
-            "LTE-MTC Band Config",
-            "LTE_MTCBandConfig"
+            'LTE-MTC Band Config',
+            'LTE_MTCBandConfig'
         ],
         // Number at the Beginning, prefix with n
         [
-            "5GNR Connectivity",
-            "n5GNRConnectivity"
+            '5GNR Connectivity',
+            'n5GNRConnectivity'
         ],
         // Slash -> underline
         [
-            "On/Off Switch",
-            "On_OffSwitch"
+            'On/Off Switch',
+            'On_OffSwitch'
         ],
         // Dot -> underline
         [
-            "LwM2M v1.1 Test Object",
-            "LwM2MV1_1TestObject"
+            'LwM2M v1.1 Test Object',
+            'LwM2MV1_1TestObject'
         ],
         // & -> and
         [
-            "AT&T Connectivity Extension",
-            "ATandTConnectivityExtension"
+            'AT&T Connectivity Extension',
+            'ATandTConnectivityExtension'
         ],
         // Remove whitespace
         [
-            " Server ",
-            "Server"
+            ' Server ',
+            'Server'
         ]
     ]; _i < _iter.length; _i++)_loop(_i, _iter);
 });

package/dist/generator/types.js

@@ -24,19 +24,19 @@ 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 { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { unwrapNestedArray } from "../lwm2m/unwrapNestedArray.js";
-import xml2js from "xml2js";
-import ts from "typescript";
-import { printNode } from "./printNode.js";
-import os from "node:os";
-import { generateType } from "./generateType.js";
-import { addDocBlock } from "./addDocBlock.js";
-import { generateName } from "./generateType.js";
-import { generateValidator } from "./generateValidator.js";
-import { generateValidators } from "./generateValidators.js";
+import chalk from 'chalk';
+import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { unwrapNestedArray } from '../lwm2m/unwrapNestedArray.js';
+import xml2js from 'xml2js';
+import ts from 'typescript';
+import { printNode } from './printNode.js';
+import os from 'node:os';
+import { generateType } from './generateType.js';
+import { addDocBlock } from './addDocBlock.js';
+import { generateName } from './generateType.js';
+import { generateValidator } from './generateValidator.js';
+import { generateValidators } from './generateValidators.js';
 var baseDir = process.cwd();
 var subDir = function() {
     for(var _len = arguments.length, tree = new Array(_len), _key = 0; _key < _len; _key++){
@@ -48,14 +48,14 @@ var subDir = function() {
 };
 var idMembers = [];
 var objects = [];
-console.log(chalk.gray("Creating TypeBox definition for LwM2M objects"));
+console.log(chalk.gray('Creating TypeBox definition for LwM2M objects'));
 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;
         var ObjectID = parseInt(definition.ObjectID, 10);
         var member = ts.factory.createEnumMember(generateName(definition), ts.factory.createNumericLiteral(ObjectID));
         addDocBlock([
@@ -65,18 +65,18 @@ try {
         ], member);
         idMembers.push(member);
         try {
-            await mkdir(subDir("lwm2m", "object"));
+            await mkdir(subDir('lwm2m', "object"));
         } catch (e) {
         // pass
         }
         // Type
-        var typeFile = subDir("lwm2m", "object", "".concat(ObjectID, ".d.ts"));
-        console.log(chalk.green("Writing"), chalk.blue(typeFile.replace(baseDir, "")));
-        await writeFile(typeFile, generateType(definition).map(printNode).join(os.EOL), "utf-8");
+        var typeFile = subDir('lwm2m', "object", "".concat(ObjectID, ".d.ts"));
+        console.log(chalk.green('Writing'), chalk.blue(typeFile.replace(baseDir, '')));
+        await writeFile(typeFile, generateType(definition).map(printNode).join(os.EOL), 'utf-8');
         // Validator
-        var validatorFile = subDir("lwm2m", "object", "validate".concat(ObjectID, ".ts"));
-        console.log(chalk.green("Writing"), chalk.blue(validatorFile.replace(baseDir, "")));
-        await writeFile(validatorFile, generateValidator(definition).map(printNode).join(os.EOL), "utf-8");
+        var validatorFile = subDir('lwm2m', "object", "validate".concat(ObjectID, ".ts"));
+        console.log(chalk.green('Writing'), chalk.blue(validatorFile.replace(baseDir, '')));
+        await writeFile(validatorFile, generateValidator(definition).map(printNode).join(os.EOL), 'utf-8');
         objects.push(definition);
     }
 } catch (err) {
@@ -93,36 +93,36 @@ try {
         }
     }
 }
-var validatorsFile = subDir("lwm2m", "validators.ts");
-console.log(chalk.green("Writing"), chalk.blue(validatorsFile.replace(baseDir, "")));
-await writeFile(validatorsFile, generateValidators(objects).map(printNode).join(os.EOL), "utf-8");
-var idFile = subDir("lwm2m", "LwM2MObjectID.ts");
-console.log(chalk.green("Writing"), chalk.blue(idFile.replace(baseDir, "")));
+var validatorsFile = subDir('lwm2m', "validators.ts");
+console.log(chalk.green('Writing'), chalk.blue(validatorsFile.replace(baseDir, '')));
+await writeFile(validatorsFile, generateValidators(objects).map(printNode).join(os.EOL), 'utf-8');
+var idFile = subDir('lwm2m', "LwM2MObjectID.ts");
+console.log(chalk.green('Writing'), chalk.blue(idFile.replace(baseDir, '')));
 var enumNode = ts.factory.createEnumDeclaration([
     ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
-], ts.factory.createIdentifier("LwM2MObjectID"), idMembers);
+], ts.factory.createIdentifier('LwM2MObjectID'), idMembers);
 addDocBlock([
-    "The LwM2M Object IDs defined in this repo."
+    'The LwM2M Object IDs defined in this repo.'
 ], enumNode);
 var objectIdArray = ts.factory.createVariableStatement([
     ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
 ], ts.factory.createVariableDeclarationList([
     ts.factory.createVariableDeclaration(ts.factory.createIdentifier("LwM2MObjectIDs"), undefined, undefined, ts.factory.createArrayLiteralExpression(objects.map(function(definition) {
         // const id = ts.factory.createNumericLiteral(ObjectID)
-        var id = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("LwM2MObjectID"), ts.factory.createIdentifier(generateName(definition)));
+        var id = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('LwM2MObjectID'), ts.factory.createIdentifier(generateName(definition)));
         ts.addSyntheticLeadingComment(id, ts.SyntaxKind.SingleLineCommentTrivia, " ".concat(definition.Name, " (").concat(definition.ObjectID, ")"), true);
         return id;
     })))
 ], ts.NodeFlags.Const));
 addDocBlock([
-    "The LwM2M Object IDs defined in this repo."
+    'The LwM2M Object IDs defined in this repo.'
 ], objectIdArray);
 await writeFile(idFile, [
     enumNode,
     objectIdArray
-].map(printNode).join(os.EOL), "utf-8");
-var objectsFile = subDir("lwm2m", "objects.ts");
-console.log(chalk.green("Writing"), chalk.blue(objectsFile.replace(baseDir, "")));
+].map(printNode).join(os.EOL), 'utf-8');
+var objectsFile = subDir('lwm2m', "objects.ts");
+console.log(chalk.green('Writing'), chalk.blue(objectsFile.replace(baseDir, '')));
 await writeFile(objectsFile, objects.map(function(param) {
     var ObjectID = param.ObjectID, Name = param.Name;
     var name = generateName({
@@ -137,4 +137,4 @@ await writeFile(objectsFile, objects.map(function(param) {
             ts.factory.createExportSpecifier(false, undefined, ts.factory.createIdentifier("validate".concat(ObjectID)))
         ]), ts.factory.createStringLiteral("./object/validate".concat(ObjectID, ".js")))
     ];
-}).flat().map(printNode).join(os.EOL), "utf-8");
+}).flat().map(printNode).join(os.EOL), 'utf-8');

package/dist/lwm2m/LWM2MObjectDefinition.js

@@ -1,45 +1,45 @@
-import { Type } from "@sinclair/typebox";
+import { Type } from '@sinclair/typebox';
 var ResourceType = Type.Union([
-    Type.Literal("String"),
-    Type.Literal("Integer"),
-    Type.Literal("Float"),
-    Type.Literal("Boolean"),
-    Type.Literal("Opaque"),
-    Type.Literal("Time")
+    Type.Literal('String'),
+    Type.Literal('Integer'),
+    Type.Literal('Float'),
+    Type.Literal('Boolean'),
+    Type.Literal('Opaque'),
+    Type.Literal('Time')
 ]);
 export var RangeEnumerationRegExp = RegExp("^(?<min>-?[0-9]+(?:\\.[0-9]+)?)\\.\\.(?<max>-?[0-9]+(?:\\.[0-9]+)?)$");
 var RangeEnumeration = Type.RegExp(RangeEnumerationRegExp, {
-    title: "RangeEnumeration"
+    title: 'RangeEnumeration'
 });
 export var LWM2MObjectDefinition = Type.Object({
     Name: Type.String({
         minLength: 1,
         examples: [
-            "Location"
+            'Location'
         ]
     }),
     Description1: Type.String({
         minLength: 1,
         examples: [
-            "This LwM2M Object provides a range of location telemetry related information which can be queried by the LwM2M Server."
+            'This LwM2M Object provides a range of location telemetry related information which can be queried by the LwM2M Server.'
         ]
     }),
     ObjectID: Type.RegExp(/^14[0-9]{3}$/),
     ObjectURN: Type.RegExp(/^urn:oma:lwm2m:x:14[0-9]{3}$/),
-    LWM2MVersion: Type.Literal("1.1", {
-        title: "LwM2M version",
-        description: "Defaults to 1.1"
+    LWM2MVersion: Type.Literal('1.1', {
+        title: 'LwM2M version',
+        description: 'Defaults to 1.1'
     }),
     ObjectVersion: Type.Optional(Type.String({
         minLength: 1,
         examples: [
-            "1.1"
+            '1.1'
         ],
-        title: "ObjectVersion",
-        description: "Defaults to 1.0"
+        title: 'ObjectVersion',
+        description: 'Defaults to 1.0'
     })),
-    MultipleInstances: Type.Literal("Multiple"),
-    Mandatory: Type.Literal("Optional"),
+    MultipleInstances: Type.Literal('Multiple'),
+    Mandatory: Type.Literal('Optional'),
     Resources: Type.Record(Type.Integer({
         minimum: 0,
         maximum: 65534
@@ -47,42 +47,42 @@ export var LWM2MObjectDefinition = Type.Object({
         Name: Type.String({
             minLength: 1,
             examples: [
-                "Latitude"
+                'Latitude'
             ]
         }),
-        Operations: Type.Literal("R", {
-            description: "Only read-properties are supported"
+        Operations: Type.Literal('R', {
+            description: 'Only read-properties are supported'
         }),
-        MultipleInstances: Type.Literal("Single"),
+        MultipleInstances: Type.Literal('Single'),
         Mandatory: Type.Union([
-            Type.Literal("Optional"),
-            Type.Literal("Mandatory")
+            Type.Literal('Optional'),
+            Type.Literal('Mandatory')
         ]),
         Type: ResourceType,
         RangeEnumeration: Type.Union([
             Type.String({
                 maxLength: 0,
-                title: "an empty string"
+                title: 'an empty string'
             }),
             RangeEnumeration
         ]),
         Units: Type.String({
             examples: [
-                "lat"
+                'lat'
             ],
-            title: "Units"
+            title: 'Units'
         }),
         Description: Type.String({
             minLength: 1,
             examples: [
-                "The decimal notation of latitude, e.g. -43.5723 [World Geodetic System 1984]."
+                'The decimal notation of latitude, e.g. -43.5723 [World Geodetic System 1984].'
             ]
         })
     }), {
         minProperties: 1,
-        description: "Defines the object resources as a map"
+        description: 'Defines the object resources as a map'
     }),
     Description2: Type.String()
 }, {
-    description: "LwM2M Object definitions with additional limitations applied to suit the hello.nrfcloud.com/map use-case"
+    description: 'LwM2M Object definitions with additional limitations applied to suit the hello.nrfcloud.com/map use-case'
 });

package/dist/lwm2m/check-lwm2m-rules.js

@@ -261,16 +261,16 @@ function _ts_values(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
-import chalk from "chalk";
-import { readFile, readdir, stat } from "node:fs/promises";
-import path, { parse } from "node:path";
-import assert from "node:assert/strict";
-import xml2js from "xml2js";
-import { exec } from "node:child_process";
-import { unwrapNestedArray } from "./unwrapNestedArray.js";
-import { LWM2MObjectDefinition } from "./LWM2MObjectDefinition.js";
-import { validate } from "../validate.js";
-import { parseRangeEnumeration } from "./parseRangeEnumeration.js";
+import chalk from 'chalk';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import path, { parse } from 'node:path';
+import assert from 'node:assert/strict';
+import xml2js from 'xml2js';
+import { exec } from 'node:child_process';
+import { unwrapNestedArray } from './unwrapNestedArray.js';
+import { LWM2MObjectDefinition } from './LWM2MObjectDefinition.js';
+import { validate } from '../validate.js';
+import { parseRangeEnumeration } from './parseRangeEnumeration.js';
 var v = validate(LWM2MObjectDefinition);
 var listLwm2mDefinitions = function() {
     var _ref = _async_to_generator(function(modelDir) {
@@ -301,13 +301,13 @@ var listLwm2mDefinitions = function() {
                                 case 0:
                                     _ref = _step.value;
                                     file = _ref;
-                                    if (!file.endsWith(".xml")) return [
+                                    if (!file.endsWith('.xml')) return [
                                         2,
                                         "continue"
                                     ];
-                                    console.log(chalk.white("\xb7"), chalk.white.bold(file));
-                                    assert.match(file, /^[0-9]+\.xml$/, "LwM2M object definition files must only have numbers in their file names");
-                                    console.log(chalk.green("✔"), chalk.gray("File name is correct"));
+                                    console.log(chalk.white('·'), chalk.white.bold(file));
+                                    assert.match(file, /^[0-9]+\.xml$/, 'LwM2M object definition files must only have numbers in their file names');
+                                    console.log(chalk.green('✔'), chalk.gray('File name is correct'));
                                     objectDefinitionFile = path.join(modelDir, file);
                                     return [
                                         4,
@@ -321,7 +321,7 @@ var listLwm2mDefinitions = function() {
                                     return [
                                         4,
                                         new Promise(function(resolve) {
-                                            return exec("xmllint --noout --schema ".concat(path.join(process.cwd(), "lwm2m", "LWM2M-v1_1.xsd"), " ").concat(objectDefinitionFile), function(error, _, stderr) {
+                                            return exec("xmllint --noout --schema ".concat(path.join(process.cwd(), 'lwm2m', 'LWM2M-v1_1.xsd'), " ").concat(objectDefinitionFile), function(error, _, stderr) {
                                                 if (error) {
                                                     console.error(stderr);
                                                     return resolve(false);
@@ -332,16 +332,16 @@ var listLwm2mDefinitions = function() {
                                     ];
                                 case 2:
                                     schemaValidated = _state.sent();
-                                    assert.equal(schemaValidated, true, "");
-                                    console.log(chalk.green("✔"), chalk.gray("Is a valid LwM2M object definition"));
+                                    assert.equal(schemaValidated, true, '');
+                                    console.log(chalk.green('✔'), chalk.gray('Is a valid LwM2M object definition'));
                                     ObjectID = parseInt(parse(objectDefinitionFile).name, 10);
-                                    assert.equal(ObjectID > 14200, true, "ObjectID must be greater than 14200");
-                                    assert.equal(ObjectID < 15000, true, "ObjectID must be smaller than 15000");
+                                    assert.equal(ObjectID > 14200, true, 'ObjectID must be greater than 14200');
+                                    assert.equal(ObjectID < 15000, true, 'ObjectID must be smaller than 15000');
                                     ObjectURN = "urn:oma:lwm2m:x:".concat(ObjectID);
                                     _ = xml2js.parseStringPromise;
                                     return [
                                         4,
-                                        readFile(objectDefinitionFile, "utf-8")
+                                        readFile(objectDefinitionFile, 'utf-8')
                                     ];
                                 case 3:
                                     return [
@@ -356,9 +356,9 @@ var listLwm2mDefinitions = function() {
                                     ]).LWM2M.Object;
                                     assert.equal(ObjectID.toString(), definition.ObjectID, "ObjectID must match filename");
                                     assert.equal(ObjectURN, definition.ObjectURN, "ObjectURN must follow schema");
-                                    console.log(chalk.green("✔"), chalk.blue(ObjectURN), chalk.gray("ObjectID and URN match filename and schema"));
+                                    console.log(chalk.green('✔'), chalk.blue(ObjectURN), chalk.gray('ObjectID and URN match filename and schema'));
                                     objectDef = _object_spread_props(_object_spread({}, definition), {
-                                        LWM2MVersion: "1.1",
+                                        LWM2MVersion: '1.1',
                                         Resources: definition.Resources.Item.reduce(function(resources, _param) {
                                             var $ = _param.$, item = _object_without_properties(_param, [
                                                 "$"
@@ -366,33 +366,33 @@ var listLwm2mDefinitions = function() {
                                             if (resources[$.ID] !== undefined) throw new Error("Duplicate resource ID: ".concat($.ID));
                                             if (item.RangeEnumeration.length > 0) {
                                                 var maybeRange = parseRangeEnumeration(item.RangeEnumeration);
-                                                if ("error" in maybeRange) throw maybeRange.error;
+                                                if ('error' in maybeRange) throw maybeRange.error;
                                             }
                                             return _object_spread_props(_object_spread({}, resources), _define_property({}, $.ID, item));
                                         }, {})
                                     });
                                     maybeValid = v(objectDef);
-                                    if ("errors" in maybeValid) {
+                                    if ('errors' in maybeValid) {
                                         console.error(maybeValid.errors);
                                         throw new Error("The definition should be valid!");
                                     }
-                                    console.log(chalk.green("✔"), chalk.gray("LwM2M limitations are honored"));
+                                    console.log(chalk.green('✔'), chalk.gray('LwM2M limitations are honored'));
                                     defs.push(maybeValid.value);
                                     _maybeValid_value = maybeValid.value, Name = _maybeValid_value.Name, Resources = _maybeValid_value.Resources;
                                     TimeResources = Object.values(Resources).filter(function(param) {
                                         var Type = param.Type;
-                                        return Type === "Time";
+                                        return Type === 'Time';
                                     });
-                                    assert.equal(TimeResources.length, 1, "Objects must define one Time resource");
-                                    assert.equal((_TimeResources_ = TimeResources[0]) === null || _TimeResources_ === void 0 ? void 0 : _TimeResources_.Mandatory, "Mandatory", "The Time resources must be mandatory.");
-                                    console.log(chalk.green("✔"), chalk.gray("Object has one time resource (".concat((_TimeResources_1 = TimeResources[0]) === null || _TimeResources_1 === void 0 ? void 0 : _TimeResources_1.Name, ")")));
+                                    assert.equal(TimeResources.length, 1, 'Objects must define one Time resource');
+                                    assert.equal((_TimeResources_ = TimeResources[0]) === null || _TimeResources_ === void 0 ? void 0 : _TimeResources_.Mandatory, 'Mandatory', 'The Time resources must be mandatory.');
+                                    console.log(chalk.green('✔'), chalk.gray("Object has one time resource (".concat((_TimeResources_1 = TimeResources[0]) === null || _TimeResources_1 === void 0 ? void 0 : _TimeResources_1.Name, ")")));
                                     console.log("".concat(chalk.yellow(ObjectID), ":"), chalk.white(Name));
                                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                                     try {
                                         for(_iterator = Object.entries(Resources)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true){
                                             _step_value = _sliced_to_array(_step1.value, 2), id = _step_value[0], resource = _step_value[1];
                                             ;
-                                            console.log("".concat(chalk.gray(ObjectID), ".").concat(chalk.yellow(id), ":"), chalk.white(resource.Name), "".concat(chalk.gray(resource.Type), " ").concat(chalk.gray("(".concat((_resource_Units = resource.Units) !== null && _resource_Units !== void 0 ? _resource_Units : "no unit", ")"))));
+                                            console.log("".concat(chalk.gray(ObjectID), ".").concat(chalk.yellow(id), ":"), chalk.white(resource.Name), "".concat(chalk.gray(resource.Type), " ").concat(chalk.gray("(".concat((_resource_Units = resource.Units) !== null && _resource_Units !== void 0 ? _resource_Units : 'no unit', ")"))));
                                         }
                                     } catch (err) {
                                         _didIteratorError = true;
@@ -473,8 +473,8 @@ var listLwm2mDefinitions = function() {
     };
 }();
 // LwM2M
-console.log(chalk.gray("LwM2M rules check"));
-console.log("");
-var lwm2mDir = path.join(process.cwd(), "lwm2m");
+console.log(chalk.gray('LwM2M rules check'));
+console.log('');
+var lwm2mDir = path.join(process.cwd(), 'lwm2m');
 var lwm2mDefinitions = await listLwm2mDefinitions(lwm2mDir);
-assert.equal(lwm2mDefinitions.length > 0, true, "LwM2M objects must be defined.");
+assert.equal(lwm2mDefinitions.length > 0, true, 'LwM2M objects must be defined.');