chore: mixins cleanups

Author: k0stik

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.js

@@ -31,6 +31,7 @@ function namedEntityMixin(item) {
 }
 function NamedEntityMixin(superclass) {
     class NamedEntityMixin extends superclass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         constructor(...args) {
             super(...args);
             namedEntityMixin(this);

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

@@ -0,0 +1,9 @@
+import type { Constructor } from "src/js/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;