@duet3d/objectmodel 3.5.0-beta.33 → 3.5.0-beta.34

package/dist/ModelObject.d.ts

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

@@ -1,212 +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;
+"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

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

@@ -1,15 +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;
+"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;