SOF-7602: rewrite entity mixins

dist/js/context/mixins.d.ts

@@ -1,5 +1,6 @@
 import { ApplicationSchemaBase, JobSchema, MaterialSchema, WorkflowSchema } from "@mat3ra/esse/dist/js/types";
 import { InMemoryEntity } from "../entity";
+import type { OrderedInMemoryEntityInSet } from "../entity/set/ordered/OrderedInMemoryEntityInSetMixin";
 type Constructor<T = any> = new (...args: any[]) => T;
 export declare function ApplicationContextMixin<T extends Constructor>(superclass: T): {
     new (...args: any): {
@@ -31,7 +32,9 @@ export declare function MaterialsSetContextMixin<T extends Constructor>(supercla
         [x: string]: any;
         _materialsSet: any;
         readonly materialsSet: any;
-        sortMaterialsByIndexInSet(materials?: never[]): never[];
+        sortMaterialsByIndexInSet(materials?: OrderedInMemoryEntityInSet[]): {
+            getIndexByIdInOrderedSet(setId: string): number;
+        }[];
     };
 } & T;
 export declare function MaterialsContextMixin<T extends Constructor>(superclass: T): {

dist/js/entity/in_memory.d.ts

@@ -68,7 +68,7 @@ export declare class InMemoryEntity implements BaseInMemoryEntitySchema {
     getAsEntityReference(byIdOnly: true): {
         _id: string;
     };
-    getAsEntityReference(byIdOnly: false): Required<EntityReferenceSchema>;
+    getAsEntityReference(byIdOnly?: false): Required<EntityReferenceSchema>;
     /**
      * @summary Pluck an entity from a collection by name.
      *          If no name is provided and no entity has prop isDefault, return the first entity

dist/js/entity/mixins/DefaultableMixin.d.ts

@@ -0,0 +1,19 @@
+import type { Constructor } from "../../utils/types";
+import { InMemoryEntity } from "../in_memory";
+type ClassBase = Constructor<InMemoryEntity> & {
+    defaultConfig?: object | null;
+};
+export declare function defaultableMixinProps<T extends InMemoryEntity>(item: T): {
+    isDefault: boolean;
+};
+declare const staticProperties: {
+    createDefault<T extends ClassBase>(this: T): InstanceType<T> & DefaultableInMemoryEntity;
+};
+export declare function defaultableMixinStaticProps<T extends ClassBase>(Item: T): {
+    createDefault<T_1 extends ClassBase>(this: T_1): InstanceType<T_1> & DefaultableInMemoryEntity;
+};
+export type DefaultableInMemoryEntity = ReturnType<typeof defaultableMixinProps>;
+export type DefaultableInMemoryEntityConstructor = Constructor<DefaultableInMemoryEntity>;
+export type DefaultableConstructor = DefaultableInMemoryEntityConstructor & typeof staticProperties;
+export default function DefaultableMixin<S extends ClassBase>(superclass: S): S & DefaultableConstructor;
+export {};

dist/js/entity/mixins/DefaultableMixin.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultableMixinProps = defaultableMixinProps;
+exports.defaultableMixinStaticProps = defaultableMixinStaticProps;
+exports.default = DefaultableMixin;
+function defaultableMixinProps(item) {
+    const properties = {
+        get isDefault() {
+            return item.prop("isDefault", false);
+        },
+        set isDefault(isDefault) {
+            item.setProp("isDefault", isDefault);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+    return properties;
+}
+const staticProperties = {
+    createDefault() {
+        return new this(this.defaultConfig);
+    },
+};
+function defaultableMixinStaticProps(Item) {
+    Object.defineProperties(Item, Object.getOwnPropertyDescriptors(staticProperties));
+    return staticProperties;
+}
+function DefaultableMixin(superclass) {
+    class DefaultableMixin extends superclass {
+        constructor(...args) {
+            super(...args);
+            defaultableMixinProps(this);
+        }
+    }
+    defaultableMixinStaticProps(DefaultableMixin);
+    return DefaultableMixin;
+}

dist/js/entity/mixins/HasConsistencyChecksMixin.d.ts

@@ -0,0 +1,10 @@
+import type { ConsistencyCheck } from "@mat3ra/esse/dist/js/types";
+import type { Constructor } from "../../utils/types";
+import { InMemoryEntity, InMemoryEntityConstructor } from "../in_memory";
+export declare function hasConsistencyChecksMixin(item: InMemoryEntity): {
+    addConsistencyChecks(array: ConsistencyCheck[]): void;
+    consistencyChecks: ConsistencyCheck[];
+};
+export type HasConsistencyChecksInMemoryEntity = ReturnType<typeof hasConsistencyChecksMixin>;
+export type HasConsistencyChecksInMemoryEntityConstructor = Constructor<HasConsistencyChecksInMemoryEntity>;
+export default function HasConsistencyChecksMixin<S extends InMemoryEntityConstructor>(superclass: S): S & HasConsistencyChecksInMemoryEntityConstructor;

dist/js/entity/mixins/HasConsistencyChecksMixin.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasConsistencyChecksMixin = hasConsistencyChecksMixin;
+exports.default = HasConsistencyChecksMixin;
+function schemaMixin(item) {
+    const schema = {
+        get consistencyChecks() {
+            return item.prop("consistencyChecks", []);
+        },
+        set consistencyChecks(array) {
+            item.setProp("consistencyChecks", array);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(schema));
+    return schema;
+}
+function propertiesMixin(item) {
+    const properties = {
+        addConsistencyChecks(array) {
+            item.consistencyChecks = [...(item.consistencyChecks || []), ...array];
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+    return properties;
+}
+function hasConsistencyChecksMixin(item) {
+    return {
+        ...schemaMixin(item),
+        ...propertiesMixin(item),
+    };
+}
+function HasConsistencyChecksMixin(superclass) {
+    class HasConsistencyChecksMixin extends superclass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            hasConsistencyChecksMixin(this);
+        }
+    }
+    return HasConsistencyChecksMixin;
+}

dist/js/entity/mixins/HasDescriptionMixin.d.ts

@@ -0,0 +1,10 @@
+import type { DescriptionSchema } from "@mat3ra/esse/dist/js/types";
+import type { Constructor } from "../../utils/types";
+import { InMemoryEntity, InMemoryEntityConstructor } from "../in_memory";
+export declare function hasDescriptionMixin(item: InMemoryEntity): {
+    description: string;
+    descriptionObject: DescriptionSchema["descriptionObject"];
+};
+export type HasDescriptionInMemoryEntity = ReturnType<typeof hasDescriptionMixin>;
+export type HasDescriptionInMemoryEntityConstructor = Constructor<HasDescriptionInMemoryEntity>;
+export default function HasDescriptionMixin<S extends InMemoryEntityConstructor>(superclass: S): S & HasDescriptionInMemoryEntityConstructor;

dist/js/entity/mixins/HasDescriptionMixin.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDescriptionMixin = hasDescriptionMixin;
+exports.default = HasDescriptionMixin;
+function schemaMixin(item) {
+    const schema = {
+        get description() {
+            return item.prop("description", "");
+        },
+        set description(string) {
+            item.setProp("description", string);
+        },
+        get descriptionObject() {
+            return item.prop("descriptionObject");
+        },
+        set descriptionObject(obj) {
+            item.setProp("descriptionObject", obj);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(schema));
+    return schema;
+}
+function hasDescriptionMixin(item) {
+    return schemaMixin(item);
+}
+function HasDescriptionMixin(superclass) {
+    class HasDescriptionMixin extends superclass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            hasDescriptionMixin(this);
+        }
+    }
+    return HasDescriptionMixin;
+}

dist/js/entity/mixins/HasMetadataMixin.d.ts

@@ -0,0 +1,9 @@
+import type { Constructor } from "../../utils/types";
+import { InMemoryEntity, InMemoryEntityConstructor } from "../in_memory";
+export declare function hasMetadataMixin(item: InMemoryEntity): {
+    updateMetadata(object: object): void;
+    metadata: object;
+};
+export type HasMetadataInMemoryEntity = ReturnType<typeof hasMetadataMixin>;
+export type HasMetadataInMemoryEntityConstructor = Constructor<HasMetadataInMemoryEntity>;
+export default function HasMetadataMixin<S extends InMemoryEntityConstructor>(superclass: S): S & HasMetadataInMemoryEntityConstructor;

dist/js/entity/mixins/HasMetadataMixin.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasMetadataMixin = hasMetadataMixin;
+exports.default = HasMetadataMixin;
+function schemaMixin(item) {
+    const schema = {
+        get metadata() {
+            return item.prop("metadata", {});
+        },
+        set metadata(object) {
+            item.setProp("metadata", object);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(schema));
+    return schema;
+}
+function propertiesMixin(item) {
+    const properties = {
+        updateMetadata(object) {
+            item.metadata = { ...item.metadata, ...object };
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+    return properties;
+}
+function hasMetadataMixin(item) {
+    return {
+        ...schemaMixin(item),
+        ...propertiesMixin(item),
+    };
+}
+function HasMetadataMixin(superclass) {
+    class HasMetadataMixin extends superclass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            hasMetadataMixin(this);
+        }
+    }
+    return HasMetadataMixin;
+}

dist/js/entity/mixins/HasScopeTrackMixin.d.ts

@@ -0,0 +1,8 @@
+import type { Constructor } from "../../utils/types";
+import { InMemoryEntity, InMemoryEntityConstructor } from "../in_memory";
+export declare function hasScopeTrackMixin(item: InMemoryEntity): {
+    scopeTrack: unknown[];
+};
+export type HasScopeTrackInMemoryEntity = ReturnType<typeof hasScopeTrackMixin>;
+export type HasScopeTrackInMemoryEntityConstructor = Constructor<HasScopeTrackInMemoryEntity>;
+export default function HasScopeTrackMixin<S extends InMemoryEntityConstructor>(superclass: S): S & HasScopeTrackInMemoryEntityConstructor;

dist/js/entity/mixins/HasScopeTrackMixin.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasScopeTrackMixin = hasScopeTrackMixin;
+exports.default = HasScopeTrackMixin;
+function schemaMixin(item) {
+    const schema = {
+        get scopeTrack() {
+            return item.prop("scopeTrack", []);
+        },
+        set scopeTrack(array) {
+            item.setProp("scopeTrack", array);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(schema));
+    return schema;
+}
+function hasScopeTrackMixin(item) {
+    return schemaMixin(item);
+}
+function HasScopeTrackMixin(superclass) {
+    class HasScopeTrackMixin extends superclass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            hasScopeTrackMixin(this);
+        }
+    }
+    return HasScopeTrackMixin;
+}

dist/js/entity/mixins/NamedEntityMixin.d.ts

@@ -0,0 +1,9 @@
+import type { Constructor } from "../../utils/types";
+import { InMemoryEntity, InMemoryEntityConstructor } from "../in_memory";
+export declare function namedEntityMixin(item: InMemoryEntity): {
+    setName(name: string): void;
+    name: string;
+};
+export type NamedInMemoryEntity = ReturnType<typeof namedEntityMixin>;
+export type NamedInMemoryEntityConstructor = Constructor<NamedInMemoryEntity>;
+export default function NamedEntityMixin<S extends InMemoryEntityConstructor>(superclass: S): S & NamedInMemoryEntityConstructor;

dist/js/entity/mixins/NamedEntityMixin.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.namedEntityMixin = namedEntityMixin;
+exports.default = NamedEntityMixin;
+function schemaMixin(item) {
+    const schema = {
+        get name() {
+            return item.prop("name", "");
+        },
+        set name(name) {
+            item.setProp("name", name);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(schema));
+    return schema;
+}
+function propertiesMixin(item) {
+    const properties = {
+        setName(name) {
+            item.setProp("name", name);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+    return properties;
+}
+function namedEntityMixin(item) {
+    return {
+        ...schemaMixin(item),
+        ...propertiesMixin(item),
+    };
+}
+function NamedEntityMixin(superclass) {
+    class NamedEntityMixin extends superclass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            namedEntityMixin(this);
+        }
+    }
+    return NamedEntityMixin;
+}

dist/js/entity/mixins/TaggableMixin.d.ts

@@ -0,0 +1,9 @@
+import type { Constructor } from "../../utils/types";
+import type { InMemoryEntity, InMemoryEntityConstructor } from "../in_memory";
+export declare function taggableMixin(item: InMemoryEntity): {
+    setTags(array: string[]): void;
+    tags: string[];
+};
+export type TaggableInMemoryEntity = ReturnType<typeof taggableMixin>;
+export type TaggableInMemoryEntityConstructor = Constructor<TaggableInMemoryEntity>;
+export default function TaggableMixin<S extends InMemoryEntityConstructor>(superclass: S): S & TaggableInMemoryEntityConstructor;

dist/js/entity/mixins/TaggableMixin.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taggableMixin = taggableMixin;
+exports.default = TaggableMixin;
+function schemaMixin(item) {
+    const schema = {
+        get tags() {
+            return item.prop("tags", []);
+        },
+        set tags(array) {
+            item.setProp("tags", array);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(schema));
+    return schema;
+}
+function propertiesMixin(item) {
+    const properties = {
+        setTags(array) {
+            item.tags = array.filter((value, index, self) => self.indexOf(value) === index);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+    return properties;
+}
+function taggableMixin(item) {
+    return {
+        ...schemaMixin(item),
+        ...propertiesMixin(item),
+    };
+}
+function TaggableMixin(superclass) {
+    class TaggableMixin extends superclass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            taggableMixin(this);
+        }
+    }
+    return TaggableMixin;
+}