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

package/dist/{src/index.js → index.js}

@@ -13,9 +13,6 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setArrayItem = void 0;
 // Expose all the sub-exports
@@ -43,7 +40,7 @@ __exportStar(require("./userSessions"), exports);
 __exportStar(require("./volumes"), exports);
 __exportStar(require("./ObjectModel"), exports);
 // Expose ObjectModel as default export
-const ObjectModel_1 = __importDefault(require("./ObjectModel"));
+const ObjectModel_1 = require("./ObjectModel");
 exports.default = ObjectModel_1.default;
 // 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duet3d/objectmodel",
-  "version": "3.5.0-beta.41",
+  "version": "3.5.0-beta.42",
   "description": "TypeScript implementation of the Duet3D Object Model",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,6 +27,6 @@
     "typescript": "^5.0.2"
   },
   "files": [
-    "/dist"
+    "/dist/src"
   ]
 }

package/dist/package.json

@@ -1,32 +0,0 @@
-{
-    "name": "@duet3d/objectmodel",
-    "version": "3.5.0-beta.41",
-    "description": "TypeScript implementation of the Duet3D Object Model",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "scripts": {
-        "test": "jest --config jestconfig.json",
-        "build": "tsc",
-        "prepare": "npm run build",
-        "prepublishOnly": "npm test"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/Duet3D/ObjectModel.git"
-    },
-    "author": "Christian Hammacher",
-    "license": "LGPL-2.1",
-    "bugs": {
-        "url": "https://github.com/Duet3D/ObjectModel/issues"
-    },
-    "homepage": "https://github.com/Duet3D/ObjectModel#readme",
-    "devDependencies": {
-        "@types/jest": "^29.4.0",
-        "jest": "^29.4.1",
-        "ts-jest": "^29.0.5",
-        "typescript": "^5.0.2"
-    },
-    "files": [
-        "/dist"
-    ]
-}

package/dist/src/ModelCollection.d.ts

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

@@ -1,103 +0,0 @@
-"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/src/ModelDictionary.d.ts

@@ -1,46 +0,0 @@
-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/src/ModelDictionary.js

@@ -1,108 +0,0 @@
-"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/src/ModelObject.d.ts

@@ -1,47 +0,0 @@
-/**
- * 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/src/ModelObject.js

@@ -1,212 +0,0 @@
-"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/src/ModelSet.d.ts

@@ -1,11 +0,0 @@
-/**
- * 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/src/ModelSet.js

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