@duet3d/objectmodel 3.4.0

package/lib/ModelDictionary.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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 {
+            for (const [key, value] of Object.entries(jsonElement)) {
+                this.set(key, value);
+            }
+        }
+        return this;
+    }
+}
+exports.ModelDictionary = ModelDictionary;

package/lib/ModelObject.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 default 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
+     */
+    wrapModelProperty<K extends keyof this, T extends IModelObject>(key: K, constructor: {
+        new (): T;
+    }): void;
+}

package/lib/ModelObject.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 (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 (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 === 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") {
+                            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 (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
+     */
+    wrapModelProperty(key, constructor) {
+        let propertyValue = this[key];
+        Object.defineProperty(this, 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.default = ModelObject;

package/lib/boards/index.d.ts

@@ -0,0 +1,49 @@
+import ModelObject from "../ModelObject";
+export declare class Accelerometer extends ModelObject {
+    points: number;
+    runs: number;
+}
+export declare enum BoardState {
+    unknown = "unknown",
+    flashing = "flashing",
+    flashFailed = "flashFailed",
+    resetting = "resetting",
+    running = "running"
+}
+export declare class ClosedLoop extends ModelObject {
+    points: number;
+    runs: number;
+}
+export declare class MinMaxCurrent extends ModelObject {
+    current: number;
+    min: number;
+    max: number;
+}
+export declare class DirectDisplay extends ModelObject {
+    pulsesPerClick: number;
+    spiFreq: number;
+    typeName: string;
+}
+export default class Board extends ModelObject {
+    constructor();
+    accelerometer: Accelerometer | null;
+    bootloaderFileName: string | null;
+    canAddress: number | null;
+    closedLoop: ClosedLoop | null;
+    directDisplay: DirectDisplay | null;
+    firmwareDate: string;
+    firmwareFileName: string;
+    firmwareVersion: string;
+    iapFileNameSBC: string | null;
+    iapFileNameSD: string | null;
+    maxHeaters: number;
+    maxMotors: number;
+    mcuTemp: MinMaxCurrent | null;
+    name: string;
+    shortName: string;
+    state: BoardState;
+    supportsDirectDisplay: boolean;
+    uniqueId: string | null;
+    v12: MinMaxCurrent | null;
+    vIn: MinMaxCurrent | null;
+}

package/lib/boards/index.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectDisplay = exports.MinMaxCurrent = exports.ClosedLoop = exports.BoardState = exports.Accelerometer = void 0;
+const ModelObject_1 = require("../ModelObject");
+class Accelerometer extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.points = 0;
+        this.runs = 0;
+    }
+}
+exports.Accelerometer = Accelerometer;
+var BoardState;
+(function (BoardState) {
+    BoardState["unknown"] = "unknown";
+    BoardState["flashing"] = "flashing";
+    BoardState["flashFailed"] = "flashFailed";
+    BoardState["resetting"] = "resetting";
+    BoardState["running"] = "running";
+})(BoardState = exports.BoardState || (exports.BoardState = {}));
+class ClosedLoop extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.points = 0;
+        this.runs = 0;
+    }
+}
+exports.ClosedLoop = ClosedLoop;
+class MinMaxCurrent extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.current = 0;
+        this.min = 0;
+        this.max = 0;
+    }
+}
+exports.MinMaxCurrent = MinMaxCurrent;
+class DirectDisplay extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.pulsesPerClick = 0;
+        this.spiFreq = 0;
+        this.typeName = "";
+    }
+}
+exports.DirectDisplay = DirectDisplay;
+class Board extends ModelObject_1.default {
+    constructor() {
+        super();
+        this.accelerometer = null;
+        this.bootloaderFileName = null;
+        this.canAddress = 0;
+        this.closedLoop = null;
+        this.directDisplay = null;
+        this.firmwareDate = "";
+        this.firmwareFileName = "";
+        this.firmwareVersion = "";
+        this.iapFileNameSBC = null;
+        this.iapFileNameSD = null;
+        this.maxHeaters = 0;
+        this.maxMotors = 0;
+        this.mcuTemp = null;
+        this.name = "";
+        this.shortName = "";
+        this.state = BoardState.unknown;
+        this.supportsDirectDisplay = false;
+        this.uniqueId = null;
+        this.v12 = null;
+        this.vIn = null;
+        this.wrapModelProperty("accelerometer", Accelerometer);
+        this.wrapModelProperty("closedLoop", ClosedLoop);
+        this.wrapModelProperty("directDisplay", DirectDisplay);
+        this.wrapModelProperty("mcuTemp", MinMaxCurrent);
+        this.wrapModelProperty("v12", MinMaxCurrent);
+        this.wrapModelProperty("vIn", MinMaxCurrent);
+    }
+}
+exports.default = Board;

package/lib/directories/index.d.ts

@@ -0,0 +1,11 @@
+import ModelObject from "../ModelObject";
+export default class Directories extends ModelObject {
+    filaments: string;
+    firmware: string;
+    gCodes: string;
+    macros: string;
+    menu: string;
+    scans: string;
+    system: string;
+    web: string;
+}

package/lib/directories/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModelObject_1 = require("../ModelObject");
+class Directories extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.filaments = "0:/filaments";
+        this.firmware = "0:/firmware";
+        this.gCodes = "0:/gcodes";
+        this.macros = "0:/macros";
+        this.menu = "0:/menu";
+        this.scans = "0:/scans";
+        this.system = "0:/sys";
+        this.web = "0:/www";
+    }
+}
+exports.default = Directories;

package/lib/fans/index.d.ts

@@ -0,0 +1,17 @@
+import ModelObject from "../ModelObject";
+export declare class FanThermostaticControl extends ModelObject {
+    heaters: Array<number>;
+    highTemperature: number | null;
+    lowTemperature: number | null;
+}
+export default class Fan extends ModelObject {
+    actualValue: number;
+    blip: number;
+    frequency: number;
+    max: number;
+    min: number;
+    name: string;
+    requestedValue: number;
+    rpm: number;
+    readonly thermostatic: FanThermostaticControl;
+}

package/lib/fans/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FanThermostaticControl = void 0;
+const ModelObject_1 = require("../ModelObject");
+class FanThermostaticControl extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.heaters = new Array();
+        this.highTemperature = null;
+        this.lowTemperature = null;
+    }
+}
+exports.FanThermostaticControl = FanThermostaticControl;
+class Fan extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.actualValue = 0;
+        this.blip = 0.1;
+        this.frequency = 250;
+        this.max = 1;
+        this.min = 0;
+        this.name = "";
+        this.requestedValue = 0;
+        this.rpm = -1;
+        this.thermostatic = new FanThermostaticControl();
+    }
+}
+exports.default = Fan;

package/lib/heat/Heater.d.ts

@@ -0,0 +1,24 @@
+import ModelCollection from "../ModelCollection";
+import HeaterModel from "./HeaterModel";
+import ModelObject from "../ModelObject";
+import HeaterMonitor from "./HeaterMonitor";
+export declare enum HeaterState {
+    off = "off",
+    standby = "standby",
+    active = "active",
+    fault = "fault",
+    tuning = "tuning",
+    offline = "offline"
+}
+export default class Heater extends ModelObject {
+    active: number;
+    avgPwm: number;
+    current: number;
+    max: number;
+    min: number;
+    readonly model: HeaterModel;
+    readonly monitors: ModelCollection<HeaterMonitor>;
+    sensor: number;
+    standby: number;
+    state: HeaterState;
+}

package/lib/heat/Heater.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaterState = void 0;
+const ModelCollection_1 = require("../ModelCollection");
+const HeaterModel_1 = require("./HeaterModel");
+const ModelObject_1 = require("../ModelObject");
+const HeaterMonitor_1 = require("./HeaterMonitor");
+var HeaterState;
+(function (HeaterState) {
+    HeaterState["off"] = "off";
+    HeaterState["standby"] = "standby";
+    HeaterState["active"] = "active";
+    HeaterState["fault"] = "fault";
+    HeaterState["tuning"] = "tuning";
+    HeaterState["offline"] = "offline";
+})(HeaterState = exports.HeaterState || (exports.HeaterState = {}));
+class Heater extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.active = 0;
+        this.avgPwm = 0;
+        this.current = -273.15;
+        this.max = 285;
+        this.min = -10;
+        this.model = new HeaterModel_1.default();
+        this.monitors = new ModelCollection_1.default(HeaterMonitor_1.default);
+        this.sensor = -1;
+        this.standby = 0;
+        this.state = HeaterState.off;
+    }
+}
+exports.default = Heater;

package/lib/heat/HeaterModel.d.ts

@@ -0,0 +1,20 @@
+import ModelObject from "../ModelObject";
+export declare class HeaterModelPID extends ModelObject {
+    d: number;
+    i: number;
+    overridden: boolean;
+    p: number;
+    used: boolean;
+}
+export default class HeaterModel extends ModelObject {
+    coolingExp: number;
+    coolingRate: number;
+    deadTime: number;
+    enabled: boolean;
+    fanCoolingRate: number;
+    heatingRate: number;
+    inverted: boolean;
+    maxPwm: number;
+    readonly pid: HeaterModelPID;
+    standardVoltage: number | null;
+}

package/lib/heat/HeaterModel.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaterModelPID = void 0;
+const ModelObject_1 = require("../ModelObject");
+class HeaterModelPID extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.d = 0;
+        this.i = 0;
+        this.overridden = false;
+        this.p = 0;
+        this.used = true;
+    }
+}
+exports.HeaterModelPID = HeaterModelPID;
+class HeaterModel extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.coolingExp = 1.35;
+        this.coolingRate = 0.56;
+        this.deadTime = 5.5;
+        this.enabled = false;
+        this.fanCoolingRate = 0.56;
+        this.heatingRate = 2.43;
+        this.inverted = false;
+        this.maxPwm = 1;
+        this.pid = new HeaterModelPID();
+        this.standardVoltage = null;
+    }
+}
+exports.default = HeaterModel;

package/lib/heat/HeaterMonitor.d.ts

@@ -0,0 +1,17 @@
+import ModelObject from "../ModelObject";
+export declare enum HeaterMonitorAction {
+    generateFault = 0,
+    permanentSwitchOff = 1,
+    temporarySwitchOff = 2,
+    shutDown = 3
+}
+export declare enum HeaterMonitorCondition {
+    disabled = "disabled",
+    tooHigh = "tooHigh",
+    tooLow = "tooLow"
+}
+export default class HeaterMonitor extends ModelObject {
+    action: HeaterMonitorAction;
+    condition: HeaterMonitorCondition;
+    limit: number;
+}

package/lib/heat/HeaterMonitor.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaterMonitorCondition = exports.HeaterMonitorAction = void 0;
+const ModelObject_1 = require("../ModelObject");
+var HeaterMonitorAction;
+(function (HeaterMonitorAction) {
+    HeaterMonitorAction[HeaterMonitorAction["generateFault"] = 0] = "generateFault";
+    HeaterMonitorAction[HeaterMonitorAction["permanentSwitchOff"] = 1] = "permanentSwitchOff";
+    HeaterMonitorAction[HeaterMonitorAction["temporarySwitchOff"] = 2] = "temporarySwitchOff";
+    HeaterMonitorAction[HeaterMonitorAction["shutDown"] = 3] = "shutDown";
+})(HeaterMonitorAction = exports.HeaterMonitorAction || (exports.HeaterMonitorAction = {}));
+var HeaterMonitorCondition;
+(function (HeaterMonitorCondition) {
+    HeaterMonitorCondition["disabled"] = "disabled";
+    HeaterMonitorCondition["tooHigh"] = "tooHigh";
+    HeaterMonitorCondition["tooLow"] = "tooLow";
+})(HeaterMonitorCondition = exports.HeaterMonitorCondition || (exports.HeaterMonitorCondition = {}));
+class HeaterMonitor extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.action = HeaterMonitorAction.generateFault;
+        this.condition = HeaterMonitorCondition.disabled;
+        this.limit = 2000;
+    }
+}
+exports.default = HeaterMonitor;

package/lib/heat/index.d.ts

@@ -0,0 +1,10 @@
+import ModelCollection from "../ModelCollection";
+import Heater from "./Heater";
+import ModelObject from "../ModelObject";
+export default class Heat extends ModelObject {
+    bedHeaters: Array<number>;
+    chamberHeaters: Array<number>;
+    coldExtrudeTemperature: number;
+    coldRetractTemperature: number;
+    readonly heaters: ModelCollection<Heater>;
+}

package/lib/heat/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModelCollection_1 = require("../ModelCollection");
+const Heater_1 = require("./Heater");
+const ModelObject_1 = require("../ModelObject");
+class Heat extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.bedHeaters = new Array();
+        this.chamberHeaters = new Array();
+        this.coldExtrudeTemperature = 160;
+        this.coldRetractTemperature = 90;
+        this.heaters = new ModelCollection_1.default(Heater_1.default);
+    }
+}
+exports.default = Heat;

package/lib/httpEndpoints/index.d.ts

@@ -0,0 +1,18 @@
+import ModelObject from "../ModelObject";
+export declare enum HttpEndpointType {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    TRACE = "TRACE",
+    DELETE = "DELETE",
+    OPTIONS = "OPTIONS",
+    WebSocket = "WebSocket"
+}
+export default class HttpEndpoint extends ModelObject {
+    endpointType: HttpEndpointType;
+    namespace: string;
+    path: string;
+    isUploadRequest: boolean;
+    unixSocket: string;
+}