@duet3d/objectmodel 3.7.0-alpha.5 → 3.7.0-alpha.7

package/dist/sensors/FilamentMonitors/index.js

@@ -10,16 +10,41 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilamentMonitor = void 0;
 exports.getFilamentMonitor = getFilamentMonitor;
-const FilamentMonitorBase_1 = require("./FilamentMonitorBase");
-const LaserFilamentMonitor_1 = require("./LaserFilamentMonitor");
-const PulsedFilamentMonitor_1 = require("./PulsedFilamentMonitor");
-const RotatingMagnetFilamentMonitor_1 = require("./RotatingMagnetFilamentMonitor");
+const FilamentMonitorBase_1 = __importStar(require("./FilamentMonitorBase"));
+const LaserFilamentMonitor_1 = __importDefault(require("./LaserFilamentMonitor"));
+const PulsedFilamentMonitor_1 = __importDefault(require("./PulsedFilamentMonitor"));
+const RotatingMagnetFilamentMonitor_1 = __importDefault(require("./RotatingMagnetFilamentMonitor"));
 class FilamentMonitor extends FilamentMonitorBase_1.default {
     update(jsonElement) {
         if (jsonElement === null) {

package/dist/sensors/Probe.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Probe = exports.ProbeTouchMode = exports.ProbeType = void 0;
-const ModelObject_1 = require("../ModelObject");
+const ModelObject_1 = __importDefault(require("../ModelObject"));
 var ProbeType;
 (function (ProbeType) {
     ProbeType[ProbeType["none"] = 0] = "none";

package/dist/sensors/index.js

@@ -13,14 +13,17 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sensors = exports.GpInputPort = void 0;
-const ModelObject_1 = require("../ModelObject");
-const ModelCollection_1 = require("../ModelCollection");
-const AnalogSensor_1 = require("./AnalogSensor");
-const Endstop_1 = require("./Endstop");
-const FilamentMonitors_1 = require("./FilamentMonitors");
-const Probe_1 = require("./Probe");
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+const ModelCollection_1 = __importDefault(require("../ModelCollection"));
+const AnalogSensor_1 = __importDefault(require("./AnalogSensor"));
+const Endstop_1 = __importDefault(require("./Endstop"));
+const FilamentMonitors_1 = __importDefault(require("./FilamentMonitors"));
+const Probe_1 = __importDefault(require("./Probe"));
 class GpInputPort extends ModelObject_1.default {
     constructor() {
         super(...arguments);

package/dist/spindles/index.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Spindle = exports.SpindleType = exports.SpindleState = void 0;
-const ModelObject_1 = require("../ModelObject");
+const ModelObject_1 = __importDefault(require("../ModelObject"));
 var SpindleState;
 (function (SpindleState) {
     SpindleState["unconfigured"] = "unconfigured";

package/dist/src/ModelCollection.d.ts

@@ -0,0 +1,36 @@
+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 {
+    /**
+     * 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/src/ModelCollection.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelCollection = void 0;
+exports.initCollection = initCollection;
+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();
+        Object.setPrototypeOf(this, ModelCollection.prototype);
+        Object.defineProperty(this, "$itemConstructor", { enumerable: false, value: itemConstructor });
+    }
+    // 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) {
+        const that = this;
+        for (const item of items) {
+            if (item === null || item instanceof that.$itemConstructor) {
+                super.push(item);
+            }
+            else {
+                const newItem = new that.$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 === null) {
+            return null;
+        }
+        if (!(jsonElement instanceof Array)) {
+            throw new Error(`Invalid JSON element type for model collection ${typeof jsonElement}`);
+        }
+        const that = this;
+        // 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 that.$itemConstructor) {
+                    (0, index_1.setArrayItem)(this, i, jsonElement[i]);
+                }
+                else {
+                    const refItem = new that.$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 that.$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;
+}

package/dist/src/ModelDictionary.d.ts

@@ -0,0 +1,44 @@
+import { IModelObject } from "./ModelObject";
+/**
+ * Dictionary class to map object model data
+ */
+export declare class ModelDictionary<T> extends Map<string, T | null> implements IModelObject {
+    /**
+     * 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/src/ModelDictionary.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelDictionary = void 0;
+exports.initDictionary = initDictionary;
+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();
+        Object.setPrototypeOf(this, ModelDictionary.prototype);
+        Object.defineProperty(this, "$nullDeletesKeys", { enumerable: false, value: nullDeletesKeys });
+        Object.defineProperty(this, "$itemConstructor", { enumerable: false, value: itemConstructor });
+    }
+    /**
+     * Overridden set method to perform type-checks and update
+     * @param key Key to set
+     * @param value Value to set
+     */
+    set(key, value) {
+        const that = this;
+        if (value === null) {
+            if (that.$nullDeletesKeys) {
+                this.delete(key);
+                return this;
+            }
+            return super.set(key, value);
+        }
+        const currentItem = this.get(key);
+        if (currentItem == null) {
+            if (that.$itemConstructor !== null && !(value instanceof that.$itemConstructor)) {
+                const newItem = new that.$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;
+}

package/dist/src/ModelObject.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Interface for updating model objects using JSON data
+ */
+export interface IModelObject {
+    /**
+     * Update this instance from the given data
+     * @param jsonElement JSON data to upgrade this instance from
+     * @returns Updated instance (may not equal the original instance)
+     */
+    update(jsonElement: any): IModelObject | null;
+}
+/**
+ * Check whether a given value provides model update functionality
+ * @param value Value to check
+ */
+export declare function isModelObject(value: any): value is IModelObject;
+/**
+ * Base class for object model classes
+ */
+export declare abstract class ModelObject implements IModelObject {
+    /**
+     * Update this instance from the given data
+     * @param jsonElement JSON data to upgrade this instance from
+     * @returns Updated instance (may not equal the original instance)
+     */
+    update(jsonElement: any): IModelObject | null;
+    /**
+     * Wrap a nullable model object property so that type checks can be performed
+     * @param key Property key of the derived class
+     * @param constructor Constructor for creating new elements
+     */
+    static wrapModelCollectionProperty<S extends IModelObject, K extends keyof S, T extends IModelObject | null>(self: S, key: K, itemConstructor: {
+        new (): T;
+    }): void;
+    /**
+     * Wrap a nullable model object property so that type checks can be performed
+     * @param key Property key of the derived class
+     * @param constructor Constructor for creating new elements
+     */
+    static wrapModelProperty<S extends IModelObject, K extends keyof S, T extends IModelObject>(self: S, key: K, constructor: {
+        new (): T;
+    }): void;
+}
+export default ModelObject;
+/**
+ * Initialize a model object from the given data
+ * @param itemType Model type to create
+ * @param data Data to assign
+ * @returns Initialized model instance
+ */
+export declare function initObject<T>(itemType: {
+    new (): T;
+}, data: {
+    [Property in keyof T]?: T[Property];
+}): T;