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

package/README.md

@@ -4,13 +4,7 @@ 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.
+Install via `npm install @duet3d/objectmodel`.
 
 ## Bug reports
 

package/dist/ModelCollection.d.ts

@@ -18,9 +18,10 @@ export declare class ModelCollection<T extends IModelObject | null> extends Arra
     /**
      * Update this instance from the given data
      * @param jsonElement JSON data to upgrade this instance from
+     * @param authoritative Whether the given data is a complete snapshot of the items and everything below them
      * @returns Updated instance
      */
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default ModelCollection;
 /**

package/dist/ModelCollection.js

@@ -1,5 +1,4 @@
 import { isModelObject } from "./ModelObject";
-import { setArrayItem } from "./index";
 /**
  * Class for storing model object items in an array
  */
@@ -34,9 +33,10 @@ export class ModelCollection extends Array {
     /**
      * Update this instance from the given data
      * @param jsonElement JSON data to upgrade this instance from
+     * @param authoritative Whether the given data is a complete snapshot of the items and everything below them
      * @returns Updated instance
      */
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             return null;
         }
@@ -52,23 +52,23 @@ export class ModelCollection extends Array {
             if (currentItem === null) {
                 const newItem = jsonElement[i];
                 if (newItem instanceof that.$itemConstructor) {
-                    setArrayItem(this, i, jsonElement[i]);
+                    this[i] = jsonElement[i];
                 }
                 else {
                     const refItem = new that.$itemConstructor();
-                    setArrayItem(this, i, refItem.update(newItem));
+                    this[i] = refItem.update(newItem, authoritative);
                 }
             }
             else if (isModelObject(currentItem)) {
-                const newItem = currentItem.update(jsonElement[i]);
+                const newItem = currentItem.update(jsonElement[i], authoritative);
                 if (currentItem !== newItem) {
-                    setArrayItem(this, i, newItem);
+                    this[i] = newItem;
                 }
             }
             else {
                 const newItem = jsonElement[i];
                 if (currentItem !== newItem) {
-                    setArrayItem(this, i, newItem);
+                    this[i] = newItem;
                 }
             }
         }
@@ -80,7 +80,7 @@ export class ModelCollection extends Array {
             }
             else {
                 const newItem = new that.$itemConstructor();
-                super.push(newItem.update(itemToAdd));
+                super.push(newItem.update(itemToAdd, authoritative));
             }
         }
         return this;

package/dist/ModelDictionary.d.ts

@@ -15,14 +15,16 @@ export declare class ModelDictionary<T> extends Map<string, T | null> implements
      * Overridden set method to perform type-checks and update
      * @param key Key to set
      * @param value Value to set
+     * @param authoritative Whether the given value is a complete snapshot of the item and everything below it
      */
-    set(key: string, value: T | null): this;
+    set(key: string, value: T | null, authoritative?: boolean): this;
     /**
      * Update this instance from the given data
      * @param jsonElement JSON data to upgrade this instance from
+     * @param authoritative Whether the given data is a complete snapshot of the items and everything below them
      * @returns Updated instance
      */
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
     /**
      * Convert this object to JSON
      * @returns JSON object

package/dist/ModelDictionary.js

@@ -18,8 +18,9 @@ export class ModelDictionary extends Map {
      * Overridden set method to perform type-checks and update
      * @param key Key to set
      * @param value Value to set
+     * @param authoritative Whether the given value is a complete snapshot of the item and everything below it
      */
-    set(key, value) {
+    set(key, value, authoritative = false) {
         const that = this;
         if (value === null) {
             if (that.$nullDeletesKeys) {
@@ -33,13 +34,13 @@ export class ModelDictionary extends Map {
             if (that.$itemConstructor !== null && !(value instanceof that.$itemConstructor)) {
                 const newItem = new that.$itemConstructor();
                 if (isModelObject(newItem)) {
-                    const updatedItem = newItem.update(value);
+                    const updatedItem = newItem.update(value, authoritative);
                     return super.set(key, updatedItem);
                 }
             }
         }
         else if (isModelObject(currentItem)) {
-            const newItem = currentItem.update(value);
+            const newItem = currentItem.update(value, authoritative);
             if (currentItem !== newItem) {
                 return super.set(key, value);
             }
@@ -50,20 +51,21 @@ export class ModelDictionary extends Map {
     /**
      * Update this instance from the given data
      * @param jsonElement JSON data to upgrade this instance from
+     * @param authoritative Whether the given data is a complete snapshot of the items and everything below them
      * @returns Updated instance
      */
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             this.clear();
         }
         else if (jsonElement instanceof Map) {
             for (const [key, value] of jsonElement.entries()) {
-                this.set(key, value);
+                this.set(key, value, authoritative);
             }
         }
         else {
             for (const [key, value] of Object.entries(jsonElement)) {
-                this.set(key, value);
+                this.set(key, value, authoritative);
             }
         }
         return this;

package/dist/ModelObject.d.ts

@@ -5,9 +5,12 @@ export interface IModelObject {
     /**
      * Update this instance from the given data
      * @param jsonElement JSON data to upgrade this instance from
+     * @param authoritative Whether the given data is a complete snapshot of this instance and everything below it,
+     * so that properties missing from it are known to be null. Set this only for responses that were not filtered
+     * by the sender, i.e. full object model key queries but never live/patch updates
      * @returns Updated instance (may not equal the original instance)
      */
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 /**
  * Check whether a given value provides model update functionality
@@ -18,12 +21,19 @@ export declare function isModelObject(value: any): value is IModelObject;
  * Base class for object model classes
  */
 export declare abstract class ModelObject implements IModelObject {
+    /**
+     * Reset the properties that may hold null and are missing from the given authoritative data.
+     * Overridden where an instance never receives a complete snapshot of itself
+     * @param jsonElement JSON data this instance is being updated from
+     */
+    protected resetMissingProperties(jsonElement: any): void;
     /**
      * Update this instance from the given data
      * @param jsonElement JSON data to upgrade this instance from
+     * @param authoritative Whether the given data is a complete snapshot of this instance and everything below it
      * @returns Updated instance (may not equal the original instance)
      */
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
     /**
      * Wrap a nullable model object property so that type checks can be performed
      * @param key Property key of the derived class

package/dist/ModelObject.js

@@ -1,4 +1,34 @@
-import { ModelCollection, setArrayItem } from "./index";
+import { ModelCollection } from "./index";
+/**
+ * Names of the properties that default to null, per model object class. Queried from a pristine instance because
+ * TS types are gone at runtime, so a null default is the only remaining evidence that a property may hold null
+ */
+const nullableProperties = new WeakMap();
+/**
+ * Get the names of the properties of the given instance's class that may hold null
+ * @param instance Instance to inspect the class of
+ */
+function getNullableProperties(instance) {
+    let result = nullableProperties.get(instance.constructor);
+    if (result === undefined) {
+        result = new Set();
+        try {
+            for (const [key, value] of Object.entries(new instance.constructor())) {
+                if (value === null) {
+                    result.add(key);
+                }
+            }
+        }
+        catch (e) {
+            // A class that cannot be constructed without arguments simply opts out of null reconstruction
+            if (process.env.NODE_ENV !== "production") {
+                console.warn(`Failed to determine nullable properties of ${instance.constructor.name}`, e);
+            }
+        }
+        nullableProperties.set(instance.constructor, result);
+    }
+    return result;
+}
 /**
  * Check whether a given value provides model update functionality
  * @param value Value to check
@@ -10,22 +40,38 @@ export function isModelObject(value) {
  * Base class for object model classes
  */
 export class ModelObject {
+    /**
+     * Reset the properties that may hold null and are missing from the given authoritative data.
+     * Overridden where an instance never receives a complete snapshot of itself
+     * @param jsonElement JSON data this instance is being updated from
+     */
+    resetMissingProperties(jsonElement) {
+        for (const key of getNullableProperties(this)) {
+            if (!(key in jsonElement)) {
+                this[key] = null;
+            }
+        }
+    }
     /**
      * Update this instance from the given data
      * @param jsonElement JSON data to upgrade this instance from
+     * @param authoritative Whether the given data is a complete snapshot of this instance and everything below it
      * @returns Updated instance (may not equal the original instance)
      */
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             return null;
         }
+        if (authoritative) {
+            this.resetMissingProperties(jsonElement);
+        }
         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);
+                    const updatedObject = prop.update(value, authoritative);
                     if (prop !== updatedObject) {
                         const propDescriptor = Object.getOwnPropertyDescriptor(this, key);
                         if (propDescriptor !== undefined) {
@@ -49,12 +95,12 @@ export class ModelObject {
                         for (let i = 0; i < Math.min(prop.length, value.length); i++) {
                             const propItem = prop[i];
                             if (propItem === null) {
-                                setArrayItem(prop, i, value[i]);
+                                prop[i] = value[i];
                             }
                             else {
                                 const newItem = value[i];
                                 if (propItem !== newItem) {
-                                    setArrayItem(prop, i, newItem);
+                                    prop[i] = newItem;
                                 }
                             }
                         }

package/dist/ObjectModel.d.ts

@@ -24,6 +24,11 @@ import LedStrip from "./ledStrips";
  */
 export declare class ObjectModel extends ModelObject {
     constructor();
+    /**
+     * A payload handed to the root always covers a subset of the top-level keys rather than the whole model,
+     * so authoritative reconstruction has to start one level below it
+     */
+    protected resetMissingProperties(): void;
     readonly boards: ModelCollection<Board>;
     readonly directories: Directories;
     readonly fans: ModelCollection<Fan | null>;

package/dist/ObjectModel.js

@@ -46,5 +46,10 @@ export class ObjectModel extends ModelObject {
         this.volumes = new ModelCollection(Volume);
         ModelObject.wrapModelProperty(this, "sbc", SBC);
     }
+    /**
+     * A payload handed to the root always covers a subset of the top-level keys rather than the whole model,
+     * so authoritative reconstruction has to start one level below it
+     */
+    resetMissingProperties() { }
 }
 export default ObjectModel;

package/dist/index.d.ts

@@ -23,4 +23,3 @@ export * from "./volumes";
 export * from "./ObjectModel";
 import ObjectModel from "./ObjectModel";
 export default ObjectModel;
-export declare function setArrayItem(array: Array<any>, index: number, value: any): void;

package/dist/index.js

@@ -25,13 +25,3 @@ export * from "./ObjectModel";
 // Expose ObjectModel as default export
 import ObjectModel from "./ObjectModel";
 export default ObjectModel;
-// Unfortunately we need to define a way to update arrays to remain compatible with Vue 2 (due to IE11).
-// This will become obsolete as soon as DWC is upgraded to Vue 3, but that isn't going to happen anytime soon.
-// Until then a Vue 2 user would have to call something like this on initialization to work around this limitation:
-// globalThis._duetModelSetArray = (array, index, value) => Vue.set(array, index, value);
-// or in TypeScript
-// (globalThis as any)._duetModelSetArray = (array: object, index: string | number, value: any) => Vue.set(array, index, value);
-globalThis._duetModelSetArray = (array, index, value) => array[index] = value;
-export function setArrayItem(array, index, value) {
-    globalThis._duetModelSetArray(array, index, value);
-}

package/dist/sensors/FilamentMonitors/RotatingMagnetFilamentMonitor.d.ts

@@ -16,6 +16,7 @@ export declare class RotatingMagnetFilamentMonitorConfigured extends ModelObject
 }
 export declare class RotatingMagnetFilamentMonitor extends Duet3DFilamentMonitor {
     constructor();
+    agc: number | null;
     calibrated: RotatingMagnetFilamentMonitorCalibrated | null;
     readonly configured: RotatingMagnetFilamentMonitorConfigured;
     update(jsonElement: any): IModelObject | null;

package/dist/sensors/FilamentMonitors/RotatingMagnetFilamentMonitor.js

@@ -24,6 +24,7 @@ export class RotatingMagnetFilamentMonitorConfigured extends ModelObject {
 export class RotatingMagnetFilamentMonitor extends Duet3DFilamentMonitor {
     constructor() {
         super(FilamentMonitorType.rotatingMagnet);
+        this.agc = null;
         this.calibrated = new RotatingMagnetFilamentMonitorCalibrated();
         this.configured = new RotatingMagnetFilamentMonitorConfigured();
         ModelObject.wrapModelProperty(this, "calibrated", RotatingMagnetFilamentMonitorCalibrated);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duet3d/objectmodel",
-  "version": "3.7.0-beta.5",
+  "version": "3.7.0-beta.7",
   "description": "TypeScript implementation of the Duet3D Object Model",
   "type": "module",
   "main": "dist/index.js",