chore: runtime_items

Author: k0stik

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

@@ -1,12 +1,9 @@
 import type { ConsistencyCheck } from "@mat3ra/esse/dist/js/types";
 import { type HasConsistencyChecksSchemaMixin } from "../../generated/HasConsistencyChecksSchemaMixin";
-import type { Constructor } from "../../utils/types";
 import { InMemoryEntity } from "../in_memory";
 type HasConsistencyChecksProperties = {
     addConsistencyChecks: (array: ConsistencyCheck[]) => void;
 };
 export type HasConsistencyChecks = HasConsistencyChecksSchemaMixin & HasConsistencyChecksProperties;
-export type HasConsistencyChecksInMemoryEntity = HasConsistencyChecks;
-export type HasConsistencyChecksInMemoryEntityConstructor = Constructor<HasConsistencyChecks>;
 export declare function hasConsistencyChecksMixin<T extends InMemoryEntity>(item: T): asserts item is T & HasConsistencyChecks;
 export {};

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

@@ -1,7 +1,3 @@
-import { type HasDescriptionSchemaMixin } from "../../generated/HasDescriptionSchemaMixin";
-import type { Constructor } from "../../utils/types";
-import { InMemoryEntity } from "../in_memory";
+import { type HasDescriptionSchemaMixin, hasDescriptionSchemaMixin } from "../../generated/HasDescriptionSchemaMixin";
 export type HasDescription = HasDescriptionSchemaMixin;
-export type HasDescriptionInMemoryEntity = HasDescriptionSchemaMixin;
-export type HasDescriptionInMemoryEntityConstructor = Constructor<HasDescriptionInMemoryEntity>;
-export declare function hasDescriptionMixin<T extends InMemoryEntity>(item: T): asserts item is T & HasDescriptionSchemaMixin;
+export declare const hasDescriptionPropertiesMixin: typeof hasDescriptionSchemaMixin;

dist/js/entity/mixins/HasDescriptionMixin.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasDescriptionMixin = hasDescriptionMixin;
+exports.hasDescriptionPropertiesMixin = void 0;
 const HasDescriptionSchemaMixin_1 = require("../../generated/HasDescriptionSchemaMixin");
-function hasDescriptionMixin(item) {
-    (0, HasDescriptionSchemaMixin_1.hasDescriptionSchemaMixin)(item);
-}
+exports.hasDescriptionPropertiesMixin = HasDescriptionSchemaMixin_1.hasDescriptionSchemaMixin;

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

@@ -1,11 +1,8 @@
 import { type HasMetadataSchemaMixin } from "../../generated/HasMetadataSchemaMixin";
-import type { Constructor } from "../../utils/types";
 import { InMemoryEntity } from "../in_memory";
 type HasMetadataProperties = {
     updateMetadata: (object: object) => void;
 };
 export type HasMetadata = HasMetadataSchemaMixin & HasMetadataProperties;
-export type HasMetadataInMemoryEntity = HasMetadata;
-export type HasMetadataInMemoryEntityConstructor = Constructor<HasMetadataInMemoryEntity>;
 export declare function hasMetadataMixin<T extends InMemoryEntity>(item: T): asserts item is T & HasMetadata;
 export {};

dist/js/entity/mixins/HasMetadataMixin.js

@@ -2,13 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasMetadataMixin = hasMetadataMixin;
 const HasMetadataSchemaMixin_1 = require("../../generated/HasMetadataSchemaMixin");
-function hasMetadataMixin(item) {
-    (0, HasMetadataSchemaMixin_1.hasMetadataSchemaMixin)(item);
+function hasMetadataPropertiesMixin(item) {
     // @ts-expect-error
     const properties = {
         updateMetadata(object) {
-            this.metadata = { ...this.metadata, ...object };
+            this.setProp("metadata", { ...this.metadata, ...object });
         },
     };
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 }
+function hasMetadataMixin(item) {
+    (0, HasMetadataSchemaMixin_1.hasMetadataSchemaMixin)(item);
+    hasMetadataPropertiesMixin(item);
+}

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

@@ -1,9 +1,6 @@
-import type { Constructor } from "../../utils/types";
 import { InMemoryEntity } from "../in_memory";
 export type HashedEntity = {
     calculateHash(): string;
     getHashObject?(): object;
 };
-export type HashedEntityInMemoryEntity = HashedEntity;
-export type HashedEntityInMemoryEntityConstructor = Constructor<HashedEntityInMemoryEntity>;
 export declare function hashedEntityMixin<T extends InMemoryEntity>(item: T): asserts item is T & HashedEntity;

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

@@ -1,11 +1,8 @@
 import { type NamedEntitySchemaMixin } from "../../generated/NamedEntitySchemaMixin";
-import type { Constructor } from "../../utils/types";
 import { InMemoryEntity } from "../in_memory";
 type NamedEntityProperties = {
     setName: (name: string) => void;
 };
 export type NamedEntity = NamedEntitySchemaMixin & NamedEntityProperties;
-export type NamedInMemoryEntity = NamedEntity;
-export type NamedInMemoryEntityConstructor = Constructor<NamedInMemoryEntity>;
-export declare function namedEntityMixin<T extends InMemoryEntity>(item: T): asserts item is T & NamedEntityProperties;
+export declare function namedEntityMixin<T extends InMemoryEntity>(item: T): asserts item is T & NamedEntity;
 export {};

dist/js/entity/mixins/NamedEntityMixin.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.namedEntityMixin = namedEntityMixin;
 const NamedEntitySchemaMixin_1 = require("../../generated/NamedEntitySchemaMixin");
-function namedEntityMixin(item) {
-    (0, NamedEntitySchemaMixin_1.namedEntitySchemaMixin)(item);
+function namedEntityPropertiesMixin(item) {
     // @ts-expect-error
     const properties = {
         setName(name) {
@@ -12,3 +11,7 @@ function namedEntityMixin(item) {
     };
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 }
+function namedEntityMixin(item) {
+    (0, NamedEntitySchemaMixin_1.namedEntitySchemaMixin)(item);
+    namedEntityPropertiesMixin(item);
+}

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

@@ -0,0 +1,12 @@
+import { type RuntimeItemsSchemaMixin } from "../../generated/RuntimeItemsSchemaMixin";
+import { InMemoryEntity } from "../in_memory";
+type RuntimeItemsProperties = {
+    hashObjectFromRuntimeItems: {
+        results: RuntimeItemsSchemaMixin["results"];
+        preProcessors: RuntimeItemsSchemaMixin["preProcessors"];
+        postProcessors: RuntimeItemsSchemaMixin["postProcessors"];
+    };
+};
+export type RuntimeItems = RuntimeItemsSchemaMixin & RuntimeItemsProperties;
+export declare function runtimeItemsMixin<T extends InMemoryEntity>(item: T): asserts item is T & RuntimeItems;
+export {};

dist/js/entity/mixins/RuntimeItemsMixin.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeItemsMixin = runtimeItemsMixin;
+const RuntimeItemsSchemaMixin_1 = require("../../generated/RuntimeItemsSchemaMixin");
+function runtimeItemsPropertiesMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get hashObjectFromRuntimeItems() {
+            return {
+                results: this.results,
+                preProcessors: this.preProcessors,
+                postProcessors: this.postProcessors,
+            };
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}
+function runtimeItemsMixin(item) {
+    (0, RuntimeItemsSchemaMixin_1.runtimeItemsSchemaMixin)(item);
+    runtimeItemsPropertiesMixin(item);
+}