@duet3d/objectmodel 3.5.0-beta.30 → 3.5.0-beta.32

package/README.md

@@ -1,17 +1,17 @@
-# ObjectModel
-
-TypeScript implementation of the Duet3D Object Model.
-
-## Installation
-
-Install via `npm install @duet3d/objectmodel`. Users of Vue 2 must also run this command after the first import:
-
-```
-globalThis._duetModelSetArray = (array, index, value) => Vue.set(array, index, value);
-```
-
-This is required to make sure that change events for arrays are correctly fired.
-
-## Bug reports
-
-Please use the [forum](https://forum.duet3d.com) for support requests or the [DuetWebControl](https://github.com/Duet3D/DuetWebControl) GitHub repository for feature requests and bug reports.
+# ObjectModel
+
+TypeScript implementation of the Duet3D Object Model.
+
+## Installation
+
+Install via `npm install @duet3d/objectmodel`. Users of Vue 2 must also run this command after the first import:
+
+```
+globalThis._duetModelSetArray = (array, index, value) => Vue.set(array, index, value);
+```
+
+This is required to make sure that change events for arrays are correctly fired.
+
+## Bug reports
+
+Please use the [forum](https://forum.duet3d.com) for support requests or the [DuetWebControl](https://github.com/Duet3D/DuetWebControl) GitHub repository for feature requests and bug reports.

package/dist/ModelCollection.d.ts

@@ -1,37 +1,37 @@
-import { IModelObject } from "./ModelObject";
-/**
- * Class for storing model object items in an array
- */
-export declare class ModelCollection<T extends IModelObject | null> extends Array<T> implements IModelObject {
-    private readonly itemConstructor;
-    /**
-     * Constructor of this class
-     * @param itemConstructor Item constructor type that items must derive from
-     */
-    constructor(itemConstructor: {
-        new (): T;
-    });
-    /**
-     * Overridden push method to perform better type checks
-     * @param items Items to add
-     */
-    push(...items: T[]): number;
-    /**
-     * Update this instance from the given data
-     * @param jsonElement JSON data to upgrade this instance from
-     * @returns Updated instance
-     */
-    update(jsonElement: any): IModelObject | null;
-}
-export default ModelCollection;
-/**
- * Initialize a model collection from the given data
- * @param itemType Item type to create
- * @param data Data to assign
- * @returns Initialized model collection
- */
-export declare function initCollection<T extends IModelObject>(itemType: {
-    new (): T;
-}, data: Array<{
-    [Property in keyof T]?: T[Property];
-}>): ModelCollection<T>;
+import { IModelObject } from "./ModelObject";
+/**
+ * Class for storing model object items in an array
+ */
+export declare class ModelCollection<T extends IModelObject | null> extends Array<T> implements IModelObject {
+    private readonly itemConstructor;
+    /**
+     * Constructor of this class
+     * @param itemConstructor Item constructor type that items must derive from
+     */
+    constructor(itemConstructor: {
+        new (): T;
+    });
+    /**
+     * Overridden push method to perform better type checks
+     * @param items Items to add
+     */
+    push(...items: T[]): number;
+    /**
+     * Update this instance from the given data
+     * @param jsonElement JSON data to upgrade this instance from
+     * @returns Updated instance
+     */
+    update(jsonElement: any): IModelObject | null;
+}
+export default ModelCollection;
+/**
+ * Initialize a model collection from the given data
+ * @param itemType Item type to create
+ * @param data Data to assign
+ * @returns Initialized model collection
+ */
+export declare function initCollection<T extends IModelObject>(itemType: {
+    new (): T;
+}, data: Array<{
+    [Property in keyof T]?: T[Property];
+}>): ModelCollection<T>;

package/dist/ModelCollection.js

@@ -1,103 +1,103 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initCollection = exports.ModelCollection = void 0;
-const ModelObject_1 = require("./ModelObject");
-const index_1 = require("./index");
-/**
- * Class for storing model object items in an array
- */
-class ModelCollection extends Array {
-    /**
-     * Constructor of this class
-     * @param itemConstructor Item constructor type that items must derive from
-     */
-    constructor(itemConstructor) {
-        super();
-        this.itemConstructor = itemConstructor;
-        Object.setPrototypeOf(this, ModelCollection.prototype);
-    }
-    // Unfortunately it isn't possible to override index operators in JS/TS
-    /**
-     * Overridden push method to perform better type checks
-     * @param items Items to add
-     */
-    push(...items) {
-        for (const item of items) {
-            if (item === null || item instanceof this.itemConstructor) {
-                super.push(item);
-            }
-            else {
-                const newItem = new this.itemConstructor();
-                super.push(newItem.update(item));
-            }
-        }
-        return this.length;
-    }
-    /**
-     * Update this instance from the given data
-     * @param jsonElement JSON data to upgrade this instance from
-     * @returns Updated instance
-     */
-    update(jsonElement) {
-        if (!(jsonElement instanceof Array)) {
-            throw new Error(`Invalid JSON element type for model collection ${typeof jsonElement}`);
-        }
-        // Remove deleted items
-        this.splice(jsonElement.length);
-        // Update existing items
-        for (let i = 0; i < Math.min(jsonElement.length, this.length); i++) {
-            const currentItem = this[i];
-            if (currentItem === null) {
-                const newItem = jsonElement[i];
-                if (newItem instanceof this.itemConstructor) {
-                    (0, index_1.setArrayItem)(this, i, jsonElement[i]);
-                }
-                else {
-                    const refItem = new this.itemConstructor();
-                    (0, index_1.setArrayItem)(this, i, refItem.update(newItem));
-                }
-            }
-            else if ((0, ModelObject_1.isModelObject)(currentItem)) {
-                const newItem = currentItem.update(jsonElement[i]);
-                if (currentItem !== newItem) {
-                    (0, index_1.setArrayItem)(this, i, newItem);
-                }
-            }
-            else {
-                const newItem = jsonElement[i];
-                if (currentItem !== newItem) {
-                    (0, index_1.setArrayItem)(this, i, newItem);
-                }
-            }
-        }
-        // Add new items
-        for (let i = this.length; i < jsonElement.length; i++) {
-            const itemToAdd = jsonElement[i];
-            if (itemToAdd === null) {
-                super.push(itemToAdd);
-            }
-            else {
-                const newItem = new this.itemConstructor();
-                super.push(newItem.update(itemToAdd));
-            }
-        }
-        return this;
-    }
-}
-exports.ModelCollection = ModelCollection;
-exports.default = ModelCollection;
-/**
- * Initialize a model collection from the given data
- * @param itemType Item type to create
- * @param data Data to assign
- * @returns Initialized model collection
- */
-function initCollection(itemType, data) {
-    const result = new ModelCollection(itemType);
-    for (let presetItem of data) {
-        const item = new itemType();
-        result.push(item.update(presetItem));
-    }
-    return result;
-}
-exports.initCollection = initCollection;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCollection = exports.ModelCollection = void 0;
+const ModelObject_1 = require("./ModelObject");
+const index_1 = require("./index");
+/**
+ * Class for storing model object items in an array
+ */
+class ModelCollection extends Array {
+    /**
+     * Constructor of this class
+     * @param itemConstructor Item constructor type that items must derive from
+     */
+    constructor(itemConstructor) {
+        super();
+        this.itemConstructor = itemConstructor;
+        Object.setPrototypeOf(this, ModelCollection.prototype);
+    }
+    // Unfortunately it isn't possible to override index operators in JS/TS
+    /**
+     * Overridden push method to perform better type checks
+     * @param items Items to add
+     */
+    push(...items) {
+        for (const item of items) {
+            if (item === null || item instanceof this.itemConstructor) {
+                super.push(item);
+            }
+            else {
+                const newItem = new this.itemConstructor();
+                super.push(newItem.update(item));
+            }
+        }
+        return this.length;
+    }
+    /**
+     * Update this instance from the given data
+     * @param jsonElement JSON data to upgrade this instance from
+     * @returns Updated instance
+     */
+    update(jsonElement) {
+        if (!(jsonElement instanceof Array)) {
+            throw new Error(`Invalid JSON element type for model collection ${typeof jsonElement}`);
+        }
+        // Remove deleted items
+        this.splice(jsonElement.length);
+        // Update existing items
+        for (let i = 0; i < Math.min(jsonElement.length, this.length); i++) {
+            const currentItem = this[i];
+            if (currentItem === null) {
+                const newItem = jsonElement[i];
+                if (newItem instanceof this.itemConstructor) {
+                    (0, index_1.setArrayItem)(this, i, jsonElement[i]);
+                }
+                else {
+                    const refItem = new this.itemConstructor();
+                    (0, index_1.setArrayItem)(this, i, refItem.update(newItem));
+                }
+            }
+            else if ((0, ModelObject_1.isModelObject)(currentItem)) {
+                const newItem = currentItem.update(jsonElement[i]);
+                if (currentItem !== newItem) {
+                    (0, index_1.setArrayItem)(this, i, newItem);
+                }
+            }
+            else {
+                const newItem = jsonElement[i];
+                if (currentItem !== newItem) {
+                    (0, index_1.setArrayItem)(this, i, newItem);
+                }
+            }
+        }
+        // Add new items
+        for (let i = this.length; i < jsonElement.length; i++) {
+            const itemToAdd = jsonElement[i];
+            if (itemToAdd === null) {
+                super.push(itemToAdd);
+            }
+            else {
+                const newItem = new this.itemConstructor();
+                super.push(newItem.update(itemToAdd));
+            }
+        }
+        return this;
+    }
+}
+exports.ModelCollection = ModelCollection;
+exports.default = ModelCollection;
+/**
+ * Initialize a model collection from the given data
+ * @param itemType Item type to create
+ * @param data Data to assign
+ * @returns Initialized model collection
+ */
+function initCollection(itemType, data) {
+    const result = new ModelCollection(itemType);
+    for (let presetItem of data) {
+        const item = new itemType();
+        result.push(item.update(presetItem));
+    }
+    return result;
+}
+exports.initCollection = initCollection;

package/dist/ModelDictionary.d.ts

@@ -1,46 +1,46 @@
-import { IModelObject } from "./ModelObject";
-/**
- * Dictionary class to map object model data
- */
-export declare class ModelDictionary<T> extends Map<string, T | null> implements IModelObject {
-    private readonly nullDeletesKeys;
-    private readonly itemConstructor;
-    /**
-     * Constructor of this class
-     * @param nullDeletesKeys Whether setting null to items effectively deletes them
-     * @param itemConstructor Item constructor type to use for type-checking
-     */
-    constructor(nullDeletesKeys: boolean, itemConstructor?: {
-        new (): T;
-    } | null);
-    /**
-     * Overridden set method to perform type-checks and update
-     * @param key Key to set
-     * @param value Value to set
-     */
-    set(key: string, value: T | null): this;
-    /**
-     * Update this instance from the given data
-     * @param jsonElement JSON data to upgrade this instance from
-     * @returns Updated instance
-     */
-    update(jsonElement: any): IModelObject | null;
-    /**
-     * Convert this object to JSON
-     * @returns JSON object
-     */
-    toJSON(): Record<string, T | null>;
-}
-export default ModelDictionary;
-/**
- * Initialize a model dictionary from the given data
- * @param nullDeletesKeys Defines whether setting values to null deletes the corresponding key
- * @param itemConstructor Item constructor
- * @param data Data to assign
- * @returns Initialized model dictionary
- */
-export declare function initDictionary<T>(nullDeletesKeys: boolean, itemConstructor: {
-    new (): T;
-}, data: Record<string, {
-    [Property in keyof T]?: T[Property];
-}>): ModelDictionary<T>;
+import { IModelObject } from "./ModelObject";
+/**
+ * Dictionary class to map object model data
+ */
+export declare class ModelDictionary<T> extends Map<string, T | null> implements IModelObject {
+    private readonly nullDeletesKeys;
+    private readonly itemConstructor;
+    /**
+     * Constructor of this class
+     * @param nullDeletesKeys Whether setting null to items effectively deletes them
+     * @param itemConstructor Item constructor type to use for type-checking
+     */
+    constructor(nullDeletesKeys: boolean, itemConstructor?: {
+        new (): T;
+    } | null);
+    /**
+     * Overridden set method to perform type-checks and update
+     * @param key Key to set
+     * @param value Value to set
+     */
+    set(key: string, value: T | null): this;
+    /**
+     * Update this instance from the given data
+     * @param jsonElement JSON data to upgrade this instance from
+     * @returns Updated instance
+     */
+    update(jsonElement: any): IModelObject | null;
+    /**
+     * Convert this object to JSON
+     * @returns JSON object
+     */
+    toJSON(): Record<string, T | null>;
+}
+export default ModelDictionary;
+/**
+ * Initialize a model dictionary from the given data
+ * @param nullDeletesKeys Defines whether setting values to null deletes the corresponding key
+ * @param itemConstructor Item constructor
+ * @param data Data to assign
+ * @returns Initialized model dictionary
+ */
+export declare function initDictionary<T>(nullDeletesKeys: boolean, itemConstructor: {
+    new (): T;
+}, data: Record<string, {
+    [Property in keyof T]?: T[Property];
+}>): ModelDictionary<T>;

package/dist/ModelDictionary.js

@@ -1,108 +1,108 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initDictionary = exports.ModelDictionary = void 0;
-const ModelObject_1 = require("./ModelObject");
-/**
- * Dictionary class to map object model data
- */
-class ModelDictionary extends Map {
-    /**
-     * Constructor of this class
-     * @param nullDeletesKeys Whether setting null to items effectively deletes them
-     * @param itemConstructor Item constructor type to use for type-checking
-     */
-    constructor(nullDeletesKeys, itemConstructor = null) {
-        super();
-        this.itemConstructor = itemConstructor;
-        this.nullDeletesKeys = nullDeletesKeys;
-        Object.setPrototypeOf(this, ModelDictionary.prototype);
-    }
-    /**
-     * Overridden set method to perform type-checks and update
-     * @param key Key to set
-     * @param value Value to set
-     */
-    set(key, value) {
-        if (value === null) {
-            if (this.nullDeletesKeys) {
-                this.delete(key);
-                return this;
-            }
-            return super.set(key, value);
-        }
-        const currentItem = this.get(key);
-        if (currentItem == null) {
-            if (this.itemConstructor !== null && !(value instanceof this.itemConstructor)) {
-                const newItem = new this.itemConstructor();
-                if ((0, ModelObject_1.isModelObject)(newItem)) {
-                    const updatedItem = newItem.update(value);
-                    return super.set(key, updatedItem);
-                }
-            }
-        }
-        else if ((0, ModelObject_1.isModelObject)(currentItem)) {
-            const newItem = currentItem.update(value);
-            if (currentItem !== newItem) {
-                return super.set(key, value);
-            }
-            return this;
-        }
-        return super.set(key, value);
-    }
-    /**
-     * Update this instance from the given data
-     * @param jsonElement JSON data to upgrade this instance from
-     * @returns Updated instance
-     */
-    update(jsonElement) {
-        if (jsonElement === null) {
-            this.clear();
-        }
-        else if (jsonElement instanceof Map) {
-            for (const [key, value] of jsonElement.entries()) {
-                this.set(key, value);
-            }
-        }
-        else {
-            for (const [key, value] of Object.entries(jsonElement)) {
-                this.set(key, value);
-            }
-        }
-        return this;
-    }
-    /**
-     * Convert this object to JSON
-     * @returns JSON object
-     */
-    toJSON() {
-        const json = {};
-        for (const [key, value] of this) {
-            json[key] = value;
-        }
-        return json;
-    }
-}
-exports.ModelDictionary = ModelDictionary;
-exports.default = ModelDictionary;
-/**
- * Initialize a model dictionary from the given data
- * @param nullDeletesKeys Defines whether setting values to null deletes the corresponding key
- * @param itemConstructor Item constructor
- * @param data Data to assign
- * @returns Initialized model dictionary
- */
-function initDictionary(nullDeletesKeys, itemConstructor, data) {
-    const result = new ModelDictionary(nullDeletesKeys, itemConstructor);
-    for (let key in data) {
-        const item = new itemConstructor();
-        if ((0, ModelObject_1.isModelObject)(item)) {
-            item.update(data[key]);
-            result.set(key, item);
-        }
-        else {
-            result.set(key, data[key]);
-        }
-    }
-    return result;
-}
-exports.initDictionary = initDictionary;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDictionary = exports.ModelDictionary = void 0;
+const ModelObject_1 = require("./ModelObject");
+/**
+ * Dictionary class to map object model data
+ */
+class ModelDictionary extends Map {
+    /**
+     * Constructor of this class
+     * @param nullDeletesKeys Whether setting null to items effectively deletes them
+     * @param itemConstructor Item constructor type to use for type-checking
+     */
+    constructor(nullDeletesKeys, itemConstructor = null) {
+        super();
+        this.itemConstructor = itemConstructor;
+        this.nullDeletesKeys = nullDeletesKeys;
+        Object.setPrototypeOf(this, ModelDictionary.prototype);
+    }
+    /**
+     * Overridden set method to perform type-checks and update
+     * @param key Key to set
+     * @param value Value to set
+     */
+    set(key, value) {
+        if (value === null) {
+            if (this.nullDeletesKeys) {
+                this.delete(key);
+                return this;
+            }
+            return super.set(key, value);
+        }
+        const currentItem = this.get(key);
+        if (currentItem == null) {
+            if (this.itemConstructor !== null && !(value instanceof this.itemConstructor)) {
+                const newItem = new this.itemConstructor();
+                if ((0, ModelObject_1.isModelObject)(newItem)) {
+                    const updatedItem = newItem.update(value);
+                    return super.set(key, updatedItem);
+                }
+            }
+        }
+        else if ((0, ModelObject_1.isModelObject)(currentItem)) {
+            const newItem = currentItem.update(value);
+            if (currentItem !== newItem) {
+                return super.set(key, value);
+            }
+            return this;
+        }
+        return super.set(key, value);
+    }
+    /**
+     * Update this instance from the given data
+     * @param jsonElement JSON data to upgrade this instance from
+     * @returns Updated instance
+     */
+    update(jsonElement) {
+        if (jsonElement === null) {
+            this.clear();
+        }
+        else if (jsonElement instanceof Map) {
+            for (const [key, value] of jsonElement.entries()) {
+                this.set(key, value);
+            }
+        }
+        else {
+            for (const [key, value] of Object.entries(jsonElement)) {
+                this.set(key, value);
+            }
+        }
+        return this;
+    }
+    /**
+     * Convert this object to JSON
+     * @returns JSON object
+     */
+    toJSON() {
+        const json = {};
+        for (const [key, value] of this) {
+            json[key] = value;
+        }
+        return json;
+    }
+}
+exports.ModelDictionary = ModelDictionary;
+exports.default = ModelDictionary;
+/**
+ * Initialize a model dictionary from the given data
+ * @param nullDeletesKeys Defines whether setting values to null deletes the corresponding key
+ * @param itemConstructor Item constructor
+ * @param data Data to assign
+ * @returns Initialized model dictionary
+ */
+function initDictionary(nullDeletesKeys, itemConstructor, data) {
+    const result = new ModelDictionary(nullDeletesKeys, itemConstructor);
+    for (let key in data) {
+        const item = new itemConstructor();
+        if ((0, ModelObject_1.isModelObject)(item)) {
+            item.update(data[key]);
+            result.set(key, item);
+        }
+        else {
+            result.set(key, data[key]);
+        }
+    }
+    return result;
+}
+exports.initDictionary = initDictionary;