chore: cleanup mixins/types

k0stik · k0stik · commit 47f16a578c85 · 2025-11-21T19:01:31.000+02:00
diff --git a/dist/js/entity/mixins/DefaultableMixin.d.ts b/dist/js/entity/mixins/DefaultableMixin.d.ts
@@ -1,9 +1,10 @@
 import { type DefaultableSchemaMixin } from "../../generated/DefaultableSchemaMixin";
 import type { Constructor } from "../../utils/types";
 import { InMemoryEntity } from "../in_memory";
-export type DefaultableInMemoryEntity = DefaultableSchemaMixin;
+export type Defaultable = DefaultableSchemaMixin;
+export type DefaultableInMemoryEntity = Defaultable;
 export type DefaultableInMemoryStaticEntity = {
-    createDefault: () => InMemoryEntity & DefaultableSchemaMixin;
+    createDefault: () => InMemoryEntity & Defaultable;
 };
-export type DefaultableInMemoryEntityConstructor = Constructor<DefaultableSchemaMixin> & DefaultableInMemoryStaticEntity;
+export type DefaultableInMemoryEntityConstructor = Constructor<Defaultable> & DefaultableInMemoryStaticEntity;
 export declare function defaultableEntityMixin(Item: Constructor<InMemoryEntity>): void;
diff --git a/dist/js/entity/mixins/HasConsistencyChecksMixin.d.ts b/dist/js/entity/mixins/HasConsistencyChecksMixin.d.ts
@@ -5,8 +5,8 @@ import { InMemoryEntity } from "../in_memory";
 type HasConsistencyChecksProperties = {
     addConsistencyChecks: (array: ConsistencyCheck[]) => void;
 };
-type HasConsistencyChecks = HasConsistencyChecksSchemaMixin & HasConsistencyChecksProperties;
+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 type HasConsistencyChecksInMemoryEntity = HasConsistencyChecksSchemaMixin & HasConsistencyChecksProperties;
-export type HasConsistencyChecksInMemoryEntityConstructor = Constructor<HasConsistencyChecksInMemoryEntity>;
 export {};
diff --git a/dist/js/entity/mixins/HasDescriptionMixin.d.ts b/dist/js/entity/mixins/HasDescriptionMixin.d.ts
@@ -1,6 +1,7 @@
 import { type HasDescriptionSchemaMixin } from "../../generated/HasDescriptionSchemaMixin";
 import type { Constructor } from "../../utils/types";
 import { InMemoryEntity } from "../in_memory";
-export declare function hasDescriptionMixin<T extends InMemoryEntity>(item: T): asserts item is T & 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;
diff --git a/dist/js/entity/mixins/HasMetadataMixin.d.ts b/dist/js/entity/mixins/HasMetadataMixin.d.ts
@@ -4,8 +4,8 @@ import { InMemoryEntity } from "../in_memory";
 type HasMetadataProperties = {
     updateMetadata: (object: object) => void;
 };
-type HasMetadata = HasMetadataSchemaMixin & HasMetadataProperties;
-export declare function hasMetadataMixin<T extends InMemoryEntity>(item: T): asserts item is T & HasMetadata;
-export type HasMetadataInMemoryEntity = HasMetadataSchemaMixin & HasMetadataProperties;
+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 {};
diff --git a/dist/js/entity/mixins/HashedEntityMixin.d.ts b/dist/js/entity/mixins/HashedEntityMixin.d.ts
@@ -1,11 +1,9 @@
-import { type HasDescriptionSchemaMixin } from "../../generated/HasDescriptionSchemaMixin";
 import type { Constructor } from "../../utils/types";
 import { InMemoryEntity } from "../in_memory";
-type HashedEntityProperties = {
+export type HashedEntity = {
     calculateHash: () => string;
     getHashObject?: () => object;
 };
-export declare function hashedEntityMixin<T extends InMemoryEntity>(item: T): asserts item is T & HashedEntityProperties;
-export type HasDescriptionInMemoryEntity = HasDescriptionSchemaMixin;
-export type HasDescriptionInMemoryEntityConstructor = Constructor<HasDescriptionInMemoryEntity>;
-export {};
+export type HashedEntityInMemoryEntity = HashedEntity;
+export type HashedEntityInMemoryEntityConstructor = Constructor<HashedEntityInMemoryEntity>;
+export declare function hashedEntityMixin<T extends InMemoryEntity>(item: T): asserts item is T & HashedEntity;
diff --git a/dist/js/entity/mixins/NamedEntityMixin.d.ts b/dist/js/entity/mixins/NamedEntityMixin.d.ts
@@ -4,7 +4,8 @@ import { InMemoryEntity } from "../in_memory";
 type NamedEntityProperties = {
     setName: (name: string) => void;
 };
-export declare function namedEntityMixin<T extends InMemoryEntity>(item: T): asserts item is T & NamedEntityProperties;
-export type NamedInMemoryEntity = NamedEntitySchemaMixin & NamedEntityProperties;
+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 {};
diff --git a/dist/js/entity/mixins/RuntimeItemsNameObjectMixin.d.ts b/dist/js/entity/mixins/RuntimeItemsNameObjectMixin.d.ts
@@ -8,8 +8,8 @@ type RuntimeItemsNameObjectProperties = {
         postProcessors: RuntimeItemsNameObjectSchemaMixin["postProcessors"];
     };
 };
-type RuntimeItemsNameObject = RuntimeItemsNameObjectSchemaMixin & RuntimeItemsNameObjectProperties;
+export type RuntimeItemsNameObject = RuntimeItemsNameObjectSchemaMixin & RuntimeItemsNameObjectProperties;
+export type RuntimeItemsNameObjectInMemoryEntity = RuntimeItemsNameObject;
+export type RuntimeItemsNameObjectInMemoryEntityConstructor = Constructor<RuntimeItemsNameObject>;
 export declare function runtimeItemsNameObjectMixin<T extends InMemoryEntity>(item: T): asserts item is T & RuntimeItemsNameObject;
-export type RuntimeItemsNameObjectInMemoryEntity = RuntimeItemsNameObjectSchemaMixin & RuntimeItemsNameObjectProperties;
-export type RuntimeItemsNameObjectInMemoryEntityConstructor = Constructor<RuntimeItemsNameObjectInMemoryEntity>;
 export {};
diff --git a/dist/js/entity/mixins/RuntimeItemsStringMixin.d.ts b/dist/js/entity/mixins/RuntimeItemsStringMixin.d.ts
@@ -1,5 +1,6 @@
 import { type RuntimeItemsStringSchemaMixin, runtimeItemsStringSchemaMixin } from "../../generated/RuntimeItemsStringSchemaMixin";
 import type { Constructor } from "../../utils/types";
-export declare const runtimeItemsStringMixin: typeof runtimeItemsStringSchemaMixin;
-export type RuntimeItemsStringInMemoryEntity = RuntimeItemsStringSchemaMixin;
+export type RuntimeItemsString = RuntimeItemsStringSchemaMixin;
+export type RuntimeItemsStringInMemoryEntity = RuntimeItemsString;
 export type RuntimeItemsStringInMemoryEntityConstructor = Constructor<RuntimeItemsStringInMemoryEntity>;
+export declare const runtimeItemsStringMixin: typeof runtimeItemsStringSchemaMixin;
diff --git a/dist/js/entity/mixins/TaggableMixin.d.ts b/dist/js/entity/mixins/TaggableMixin.d.ts
@@ -4,8 +4,8 @@ import { InMemoryEntity } from "../in_memory";
 type TaggableProperties = {
     setTags: (array: string[]) => void;
 };
-type Taggable = TaggableSchemaMixin & TaggableProperties;
-export declare function taggableMixin<T extends InMemoryEntity>(item: T): asserts item is T & Taggable;
-export type TaggableInMemoryEntity = TaggableSchemaMixin & TaggableProperties;
+export type Taggable = TaggableSchemaMixin & TaggableProperties;
+export type TaggableInMemoryEntity = Taggable;
 export type TaggableInMemoryEntityConstructor = Constructor<TaggableInMemoryEntity>;
+export declare function taggableMixin<T extends InMemoryEntity>(item: T): asserts item is T & Taggable;
 export {};
diff --git a/src/js/entity/mixins/DefaultableMixin.ts b/src/js/entity/mixins/DefaultableMixin.ts
@@ -7,6 +7,17 @@ import {
 import type { Constructor } from "../../utils/types";
 import { InMemoryEntity } from "../in_memory";
 
+export type Defaultable = DefaultableSchemaMixin;
+
+export type DefaultableInMemoryEntity = Defaultable;
+
+export type DefaultableInMemoryStaticEntity = {
+    createDefault: () => InMemoryEntity & Defaultable;
+};
+
+export type DefaultableInMemoryEntityConstructor = Constructor<Defaultable> &
+    DefaultableInMemoryStaticEntity;
+
 function defaultableEntityStaticMixin(Item: Constructor<InMemoryEntity>) {
     // @ts-expect-error
     const staticProperties: DefaultableInMemoryStaticEntity &
@@ -24,15 +35,6 @@ function defaultableEntityStaticMixin(Item: Constructor<InMemoryEntity>) {
     return staticProperties;
 }
 
-export type DefaultableInMemoryEntity = DefaultableSchemaMixin;
-
-export type DefaultableInMemoryStaticEntity = {
-    createDefault: () => InMemoryEntity & DefaultableSchemaMixin;
-};
-
-export type DefaultableInMemoryEntityConstructor = Constructor<DefaultableSchemaMixin> &
-    DefaultableInMemoryStaticEntity;
-
 export function defaultableEntityMixin(Item: Constructor<InMemoryEntity>) {
     defaultableSchemaMixin(Item.prototype);
     defaultableEntityStaticMixin(Item);
diff --git a/src/js/entity/mixins/HasConsistencyChecksMixin.ts b/src/js/entity/mixins/HasConsistencyChecksMixin.ts
@@ -11,7 +11,11 @@ type HasConsistencyChecksProperties = {
     addConsistencyChecks: (array: ConsistencyCheck[]) => void;
 };
 
-type HasConsistencyChecks = HasConsistencyChecksSchemaMixin & HasConsistencyChecksProperties;
+export type HasConsistencyChecks = HasConsistencyChecksSchemaMixin & HasConsistencyChecksProperties;
+
+export type HasConsistencyChecksInMemoryEntity = HasConsistencyChecks;
+
+export type HasConsistencyChecksInMemoryEntityConstructor = Constructor<HasConsistencyChecks>;
 
 export function hasConsistencyChecksMixin<T extends InMemoryEntity>(
     item: T,
@@ -27,9 +31,3 @@ export function hasConsistencyChecksMixin<T extends InMemoryEntity>(
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 }
-
-export type HasConsistencyChecksInMemoryEntity = HasConsistencyChecksSchemaMixin &
-    HasConsistencyChecksProperties;
-
-export type HasConsistencyChecksInMemoryEntityConstructor =
-    Constructor<HasConsistencyChecksInMemoryEntity>;
diff --git a/src/js/entity/mixins/HasDescriptionMixin.ts b/src/js/entity/mixins/HasDescriptionMixin.ts
@@ -5,12 +5,14 @@ import {
 import type { Constructor } from "../../utils/types";
 import { InMemoryEntity } from "../in_memory";
 
+export type HasDescription = HasDescriptionSchemaMixin;
+
+export type HasDescriptionInMemoryEntity = HasDescriptionSchemaMixin;
+
+export type HasDescriptionInMemoryEntityConstructor = Constructor<HasDescriptionInMemoryEntity>;
+
 export function hasDescriptionMixin<T extends InMemoryEntity>(
     item: T,
 ): asserts item is T & HasDescriptionSchemaMixin {
     hasDescriptionSchemaMixin(item);
 }
-
-export type HasDescriptionInMemoryEntity = HasDescriptionSchemaMixin;
-
-export type HasDescriptionInMemoryEntityConstructor = Constructor<HasDescriptionInMemoryEntity>;
diff --git a/src/js/entity/mixins/HasMetadataMixin.ts b/src/js/entity/mixins/HasMetadataMixin.ts
@@ -9,7 +9,11 @@ type HasMetadataProperties = {
     updateMetadata: (object: object) => void;
 };
 
-type HasMetadata = HasMetadataSchemaMixin & HasMetadataProperties;
+export type HasMetadata = HasMetadataSchemaMixin & HasMetadataProperties;
+
+export type HasMetadataInMemoryEntity = HasMetadata;
+
+export type HasMetadataInMemoryEntityConstructor = Constructor<HasMetadataInMemoryEntity>;
 
 export function hasMetadataMixin<T extends InMemoryEntity>(
     item: T,
@@ -25,7 +29,3 @@ export function hasMetadataMixin<T extends InMemoryEntity>(
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 }
-
-export type HasMetadataInMemoryEntity = HasMetadataSchemaMixin & HasMetadataProperties;
-
-export type HasMetadataInMemoryEntityConstructor = Constructor<HasMetadataInMemoryEntity>;
diff --git a/src/js/entity/mixins/HashedEntityMixin.ts b/src/js/entity/mixins/HashedEntityMixin.ts
@@ -1,18 +1,21 @@
-import { type HasDescriptionSchemaMixin } from "../../generated/HasDescriptionSchemaMixin";
 import { calculateHashFromObject } from "../../utils/hash";
 import type { Constructor } from "../../utils/types";
 import { InMemoryEntity } from "../in_memory";
 
-type HashedEntityProperties = {
+export type HashedEntity = {
     calculateHash: () => string;
     getHashObject?: () => object;
 };
 
+export type HashedEntityInMemoryEntity = HashedEntity;
+
+export type HashedEntityInMemoryEntityConstructor = Constructor<HashedEntityInMemoryEntity>;
+
 export function hashedEntityMixin<T extends InMemoryEntity>(
     item: T,
-): asserts item is T & HashedEntityProperties {
+): asserts item is T & HashedEntity {
     // @ts-expect-error
-    const properties: InMemoryEntity & HashedEntityProperties = {
+    const properties: InMemoryEntity & HashedEntity = {
         /**
          * @summary Calculates hash based on meaningful fields and unit-specific fields. Unit-specific fields are
          *          separated into _typeSpecificHash function which can be overwritten by child classes.
@@ -25,7 +28,3 @@ export function hashedEntityMixin<T extends InMemoryEntity>(
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 }
-
-export type HasDescriptionInMemoryEntity = HasDescriptionSchemaMixin;
-
-export type HasDescriptionInMemoryEntityConstructor = Constructor<HasDescriptionInMemoryEntity>;
diff --git a/src/js/entity/mixins/NamedEntityMixin.ts b/src/js/entity/mixins/NamedEntityMixin.ts
@@ -9,6 +9,12 @@ type NamedEntityProperties = {
     setName: (name: string) => void;
 };
 
+export type NamedEntity = NamedEntitySchemaMixin & NamedEntityProperties;
+
+export type NamedInMemoryEntity = NamedEntity;
+
+export type NamedInMemoryEntityConstructor = Constructor<NamedInMemoryEntity>;
+
 export function namedEntityMixin<T extends InMemoryEntity>(
     item: T,
 ): asserts item is T & NamedEntityProperties {
@@ -23,7 +29,3 @@ export function namedEntityMixin<T extends InMemoryEntity>(
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 }
-
-export type NamedInMemoryEntity = NamedEntitySchemaMixin & NamedEntityProperties;
-
-export type NamedInMemoryEntityConstructor = Constructor<NamedInMemoryEntity>;
diff --git a/src/js/entity/mixins/RuntimeItemsNameObjectMixin.ts b/src/js/entity/mixins/RuntimeItemsNameObjectMixin.ts
@@ -13,7 +13,12 @@ type RuntimeItemsNameObjectProperties = {
     };
 };
 
-type RuntimeItemsNameObject = RuntimeItemsNameObjectSchemaMixin & RuntimeItemsNameObjectProperties;
+export type RuntimeItemsNameObject = RuntimeItemsNameObjectSchemaMixin &
+    RuntimeItemsNameObjectProperties;
+
+export type RuntimeItemsNameObjectInMemoryEntity = RuntimeItemsNameObject;
+
+export type RuntimeItemsNameObjectInMemoryEntityConstructor = Constructor<RuntimeItemsNameObject>;
 
 export function runtimeItemsNameObjectMixin<T extends InMemoryEntity>(
     item: T,
@@ -33,9 +38,3 @@ export function runtimeItemsNameObjectMixin<T extends InMemoryEntity>(
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 }
-
-export type RuntimeItemsNameObjectInMemoryEntity = RuntimeItemsNameObjectSchemaMixin &
-    RuntimeItemsNameObjectProperties;
-
-export type RuntimeItemsNameObjectInMemoryEntityConstructor =
-    Constructor<RuntimeItemsNameObjectInMemoryEntity>;
diff --git a/src/js/entity/mixins/RuntimeItemsStringMixin.ts b/src/js/entity/mixins/RuntimeItemsStringMixin.ts
@@ -4,9 +4,11 @@ import {
 } from "../../generated/RuntimeItemsStringSchemaMixin";
 import type { Constructor } from "../../utils/types";
 
-export const runtimeItemsStringMixin = runtimeItemsStringSchemaMixin;
+export type RuntimeItemsString = RuntimeItemsStringSchemaMixin;
 
-export type RuntimeItemsStringInMemoryEntity = RuntimeItemsStringSchemaMixin;
+export type RuntimeItemsStringInMemoryEntity = RuntimeItemsString;
 
 export type RuntimeItemsStringInMemoryEntityConstructor =
     Constructor<RuntimeItemsStringInMemoryEntity>;
+
+export const runtimeItemsStringMixin = runtimeItemsStringSchemaMixin;
diff --git a/src/js/entity/mixins/TaggableMixin.ts b/src/js/entity/mixins/TaggableMixin.ts
@@ -6,7 +6,11 @@ type TaggableProperties = {
     setTags: (array: string[]) => void;
 };
 
-type Taggable = TaggableSchemaMixin & TaggableProperties;
+export type Taggable = TaggableSchemaMixin & TaggableProperties;
+
+export type TaggableInMemoryEntity = Taggable;
+
+export type TaggableInMemoryEntityConstructor = Constructor<TaggableInMemoryEntity>;
 
 export function taggableMixin<T extends InMemoryEntity>(item: T): asserts item is T & Taggable {
     taggableSchemaMixin(item);
@@ -20,7 +24,3 @@ export function taggableMixin<T extends InMemoryEntity>(item: T): asserts item i
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 }
-
-export type TaggableInMemoryEntity = TaggableSchemaMixin & TaggableProperties;
-
-export type TaggableInMemoryEntityConstructor = Constructor<TaggableInMemoryEntity>;
