@duet3d/objectmodel 3.5.0-beta.42 → 3.5.0-beta.44

package/dist/ModelCollection.d.ts

@@ -0,0 +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>;

package/dist/ModelCollection.js

@@ -0,0 +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;

package/dist/ModelDictionary.d.ts

@@ -0,0 +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>;

package/dist/ModelDictionary.js

@@ -0,0 +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;

package/dist/ModelObject.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 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;

package/dist/ModelObject.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initObject = exports.ModelObject = exports.isModelObject = void 0;
+const index_1 = require("./index");
+/**
+ * Check whether a given value provides model update functionality
+ * @param value Value to check
+ */
+function isModelObject(value) {
+    return (value instanceof Object) && value.update !== undefined;
+}
+exports.isModelObject = isModelObject;
+/**
+ * Base class for object model classes
+ */
+class ModelObject {
+    /**
+     * 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) {
+        if (jsonElement === null) {
+            return null;
+        }
+        for (const [key, value] of Object.entries(jsonElement)) {
+            if (key in this) {
+                const ownKey = key;
+                const prop = this[ownKey];
+                if (isModelObject(prop)) {
+                    // Update model objects
+                    const updatedObject = prop.update(value);
+                    if (prop !== updatedObject) {
+                        const propDescriptor = Object.getOwnPropertyDescriptor(this, key);
+                        if (propDescriptor !== undefined) {
+                            if (propDescriptor.writable) {
+                                this[ownKey] = updatedObject;
+                            }
+                            else if (propDescriptor.set !== undefined) {
+                                propDescriptor.set(updatedObject);
+                            }
+                            else if (process.env.NODE_ENV !== "production") {
+                                console.warn(`Model object ${key} changed but it could not be set due to missing setter`);
+                            }
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Model object ${key} changed but it lacks the property descriptor`);
+                        }
+                    }
+                }
+                else if (prop instanceof Array) {
+                    if (value instanceof Array) {
+                        // Remove deleted items
+                        prop.splice(value.length);
+                        // Update existing items
+                        for (let i = 0; i < Math.min(prop.length, value.length); i++) {
+                            const propItem = prop[i];
+                            if (propItem === null) {
+                                (0, index_1.setArrayItem)(prop, i, value[i]);
+                            }
+                            else {
+                                const newItem = value[i];
+                                if (propItem !== newItem) {
+                                    (0, index_1.setArrayItem)(prop, i, newItem);
+                                }
+                            }
+                        }
+                        // Add new items
+                        for (let i = prop.length; i < value.length; i++) {
+                            prop.push(value[i]);
+                        }
+                    }
+                    else if (value === null) {
+                        // Arrays may be assignable to null
+                        this[ownKey] = value;
+                    }
+                    else if (process.env.NODE_ENV !== "production") {
+                        console.warn(`Model array ${key} could not be changed because the target type ${typeof value} is invalid`);
+                    }
+                }
+                else if (prop instanceof Set) {
+                    if (value instanceof Array || value instanceof Set) {
+                        // Remove deleted items
+                        for (let item of new Set(prop)) {
+                            if (!prop.has(item)) {
+                                prop.delete(item);
+                            }
+                        }
+                        // Add new items
+                        for (let item of value) {
+                            if (!prop.has(item)) {
+                                prop.add(item);
+                            }
+                        }
+                    }
+                    else if (value === null) {
+                        // Sets may be assignable to null
+                        this[ownKey] = value;
+                    }
+                    else if (process.env.NODE_ENV !== "production") {
+                        console.warn(`Model set ${key} could not be changed because the target type ${typeof value} is invalid`);
+                    }
+                }
+                else if (prop === null || value === null) {
+                    // Unfortunately we cannot do type checks during runtime without excessive extra work and possibly
+                    // third-party libraries, so skip them for null values until there is a better solution.
+                    // FWIW, we would just need "typeof prop" but TS does not seem to be capable of providing this.
+                    this[ownKey] = value;
+                }
+                else {
+                    const propType = typeof prop;
+                    if (propType === "boolean") {
+                        if (typeof value === "boolean") {
+                            this[ownKey] = value;
+                        }
+                        else if (typeof value === "number") {
+                            // RRF used to report booleans as integers so convert them if necessary
+                            this[ownKey] = Boolean(value);
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible bool target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (propType === "number") {
+                        if (typeof value === "number" || typeof value === "bigint") {
+                            this[ownKey] = value;
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible number target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (propType === "bigint") {
+                        if (typeof value === "number" || typeof value === "bigint") {
+                            this[ownKey] = value;
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible bigint target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (propType === "string") {
+                        if (typeof value === "string") {
+                            this[ownKey] = value;
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible string target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (propType === "function") {
+                        if (typeof value === "function") {
+                            this[ownKey] = value;
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible function target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (propType === "object") {
+                        if (typeof value === "object") {
+                            this[ownKey] = value;
+                        }
+                        else if (process.env.NODE_ENV !== "production") {
+                            console.warn(`Incompatible object target type ${typeof value} for property ${key}`);
+                        }
+                    }
+                    else if (process.env.NODE_ENV !== "production") {
+                        console.warn(`Incompatible type ${propType} for property ${key} (${typeof value})`);
+                    }
+                }
+            }
+        }
+        return this;
+    }
+    /**
+     * 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(self, key, constructor) {
+        let propertyValue = self[key];
+        Object.defineProperty(self, key, {
+            get() { return propertyValue; },
+            set(newValue) {
+                if (newValue === null) {
+                    propertyValue = null;
+                }
+                else if (propertyValue !== null) {
+                    const newModel = propertyValue.update(newValue);
+                    if (propertyValue !== newModel) {
+                        propertyValue = newModel;
+                    }
+                }
+                else {
+                    const newModel = new constructor();
+                    propertyValue = newModel.update(newValue);
+                }
+            },
+            configurable: true,
+            enumerable: true
+        });
+    }
+}
+exports.ModelObject = ModelObject;
+exports.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
+ */
+function initObject(itemType, data) {
+    return new itemType().update(data);
+}
+exports.initObject = initObject;

package/dist/ModelSet.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wrapper around a standard set to make sure it serializes to an array
+ */
+export declare class ModelSet<T> extends Set<T> {
+    /**
+     * Convert this object to JSON
+     * @returns JSON object
+     */
+    toJSON(): T[];
+}
+export default ModelSet;

package/dist/ModelSet.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelSet = void 0;
+/**
+ * Wrapper around a standard set to make sure it serializes to an array
+ */
+class ModelSet extends Set {
+    /**
+     * Convert this object to JSON
+     * @returns JSON object
+     */
+    toJSON() { return Array.from(this); }
+}
+exports.ModelSet = ModelSet;
+exports.default = ModelSet;

package/dist/ObjectModel.d.ts

@@ -0,0 +1,47 @@
+import ModelCollection from "./ModelCollection";
+import ModelDictionary from "./ModelDictionary";
+import ModelObject from "./ModelObject";
+import Board from "./boards";
+import Directories from "./directories";
+import Fan from "./fans";
+import Heat from "./heat";
+import InputChannel from "./inputs/InputChannel";
+import Job from "./job";
+import Limits from "./limits";
+import Message from "./messages";
+import Move from "./move";
+import Network from "./network";
+import Plugin from "./plugins";
+import SBC from "./sbc";
+import Sensors from "./sensors";
+import Spindle from "./spindles";
+import State from "./state";
+import Tool from "./tools";
+import UserSession from "./userSessions";
+import Volume from "./volumes";
+/**
+ * Refer to the DSF/RRF documentation for descriptions of the object model fields
+ */
+export declare class ObjectModel extends ModelObject {
+    constructor();
+    readonly boards: ModelCollection<Board>;
+    readonly directories: Directories;
+    readonly fans: ModelCollection<Fan | null>;
+    readonly global: ModelDictionary<any>;
+    readonly heat: Heat;
+    readonly inputs: ModelCollection<InputChannel | null>;
+    readonly job: Job;
+    readonly limits: Limits;
+    readonly messages: ModelCollection<Message>;
+    readonly move: Move;
+    readonly network: Network;
+    readonly plugins: ModelDictionary<Plugin>;
+    sbc: SBC | null;
+    readonly sensors: Sensors;
+    readonly spindles: ModelCollection<Spindle | null>;
+    readonly state: State;
+    readonly tools: ModelCollection<Tool | null>;
+    readonly userSessions: ModelCollection<UserSession>;
+    readonly volumes: ModelCollection<Volume>;
+}
+export default ObjectModel;

package/dist/ObjectModel.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectModel = void 0;
+const ModelCollection_1 = require("./ModelCollection");
+const ModelDictionary_1 = require("./ModelDictionary");
+const ModelObject_1 = require("./ModelObject");
+const boards_1 = require("./boards");
+const directories_1 = require("./directories");
+const fans_1 = require("./fans");
+const heat_1 = require("./heat");
+const InputChannel_1 = require("./inputs/InputChannel");
+const job_1 = require("./job");
+const limits_1 = require("./limits");
+const messages_1 = require("./messages");
+const move_1 = require("./move");
+const network_1 = require("./network");
+const plugins_1 = require("./plugins");
+const sbc_1 = require("./sbc");
+const sensors_1 = require("./sensors");
+const spindles_1 = require("./spindles");
+const state_1 = require("./state");
+const tools_1 = require("./tools");
+const userSessions_1 = require("./userSessions");
+const volumes_1 = require("./volumes");
+/**
+ * Refer to the DSF/RRF documentation for descriptions of the object model fields
+ */
+class ObjectModel extends ModelObject_1.default {
+    constructor() {
+        super();
+        this.boards = new ModelCollection_1.default(boards_1.default);
+        this.directories = new directories_1.default();
+        this.fans = new ModelCollection_1.default(fans_1.default);
+        this.global = new ModelDictionary_1.default(false);
+        this.heat = new heat_1.default();
+        this.inputs = new ModelCollection_1.default(InputChannel_1.default);
+        this.job = new job_1.default();
+        this.limits = new limits_1.default();
+        this.messages = new ModelCollection_1.default(messages_1.default); // must be manually cleared after updates
+        this.move = new move_1.default();
+        this.network = new network_1.default();
+        this.plugins = new ModelDictionary_1.default(true, plugins_1.default);
+        this.sbc = null;
+        this.sensors = new sensors_1.default();
+        this.spindles = new ModelCollection_1.default(spindles_1.default);
+        this.state = new state_1.default();
+        this.tools = new ModelCollection_1.default(tools_1.default);
+        this.userSessions = new ModelCollection_1.default(userSessions_1.default);
+        this.volumes = new ModelCollection_1.default(volumes_1.default);
+        ModelObject_1.default.wrapModelProperty(this, "sbc", sbc_1.default);
+    }
+}
+exports.ObjectModel = ObjectModel;
+exports.default = ObjectModel;