@awesome-ecs/abstract 0.28.0 → 0.30.0

package/dist/{identity-component-uU0yDR-y.d.cts → identity-component-DLDaOTyK.d.cts}

@@ -1,5 +1,3 @@
-import { n as Immutable } from "./types-DLOd2zXO.cjs";
-
 //#region src/components/component.d.ts
 type ComponentTypeUid = string | number;
 /**
@@ -169,8 +167,9 @@ type EntityUid = string | number;
 /**
  * Represents the core identification and initialization data for an entity.
  * @template TProxyTypes - A readonly array of entity type IDs that must be provided as proxies when creating an entity.
+ *                         When non-empty, the `proxies` property is required on the model.
  */
-interface IEntityModel<TProxyTypes extends readonly EntityTypeUid[] = undefined> {
+type IEntityModel<TProxyTypes extends readonly EntityTypeUid[] = readonly []> = {
   /**
    * The unique identifier for this entity instance.
    */
@@ -181,12 +180,11 @@ interface IEntityModel<TProxyTypes extends readonly EntityTypeUid[] = undefined>
    * child entities inherit from their parent via addEntity().
    */
   readonly scopeId?: string;
-  /**
-   * Optional array of proxies (references) to other entities.
-   * Used to establish relationships at entity creation time.
-   */
+} & (TProxyTypes extends readonly [] ? {
   readonly proxies?: RequiredProxies<TProxyTypes>;
-}
+} : {
+  readonly proxies: RequiredProxies<TProxyTypes>;
+});
 /**
  * The core entity interface representing a composition of components and relationships.
  * Entities are immutable containers that store data (components) and maintain relationships (proxies) to other entities.
@@ -212,6 +210,74 @@ interface IEntity {
   readonly myProxy: Readonly<EntityProxy<this>>;
 }
 //#endregion
+//#region src/utils/types.d.ts
+/**
+ * Maps all properties of a type to boolean flags.
+ * Useful for feature flags, capability indicators, or boolean option sets.
+ *
+ * @template T - The type whose properties are mapped to booleans.
+ * @example type Features = BooleanProps<{health: any; armor: any}>; // => {health: boolean, armor: boolean}
+ */
+type BooleanProps<T> = { [Property in keyof T]: boolean };
+/**
+ * Removes readonly modifiers from all properties, making them mutable.
+ * One level of immutability removal (see MutableDeep for recursive removal).
+ *
+ * @template T - The type to make mutable.
+ * @example type Mut = Mutable<{readonly x: number}>; // => {x: number}
+ */
+type Mutable<T> = { -readonly [K in keyof T]: T[K] };
+/**
+ * Recursively removes readonly modifiers from all properties at all nesting levels.
+ * Makes entire object graph mutable.
+ *
+ * @template T - The type to make mutable recursively.
+ */
+type MutableDeep<T> = { -readonly [K in keyof T]: Mutable<T[K]> };
+type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
+/**
+ * Makes a type fully immutable at the top level only.
+ * Primitives and functions remain unchanged.
+ * Collections (Array, Map, Set) become readonly.
+ * Objects have their properties made readonly.
+ *
+ * @template T - The type to make immutable.
+ * @example type Imm = Immutable<{x: number}>; // => {readonly x: number}
+ */
+type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
+/**
+ * Readonly array variant for use in Immutable type transformation.
+ *
+ * @template T - Element type of the array.
+ */
+type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+/**
+ * Readonly map variant for use in Immutable type transformation.
+ *
+ * @template K - Key type of the map.
+ * @template V - Value type of the map.
+ */
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+/**
+ * Readonly set variant for use in Immutable type transformation.
+ *
+ * @template T - Element type of the set.
+ */
+type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+/**
+ * Makes all object properties readonly (one level only).
+ *
+ * @template T - The type to make immutable.
+ */
+type ImmutableObject<T> = { readonly [K in keyof T]: T[K] };
+/**
+ * Recursively makes all properties readonly at all nesting levels.
+ * Provides complete immutability guarantee for the entire object graph.
+ *
+ * @template T - The type to make deeply immutable.
+ */
+type ImmutableObjectDeep<T> = { readonly [K in keyof T]: Immutable<T[K]> };
+//#endregion
 //#region src/components/identity-component.d.ts
 /**
  * The `BasicComponentType` enum defines the types of basic components available.
@@ -250,5 +316,5 @@ interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
   readonly lastUpdated?: Date;
 }
 //#endregion
-export { IEntity as a, IEntityProxy as c, TypedEntityProxy as d, ComponentTypeUid as f, EntityUid as i, IEntityProxyRepository as l, IdentityComponent as n, IEntityModel as o, IComponent as p, EntityTypeUid as r, EntityProxy as s, BasicComponentType as t, RequiredProxies as u };
-//# sourceMappingURL=identity-component-uU0yDR-y.d.cts.map
+export { IComponent as S, IEntityProxy as _, ImmutableArray as a, TypedEntityProxy as b, ImmutableObjectDeep as c, MutableDeep as d, EntityTypeUid as f, EntityProxy as g, IEntityModel as h, Immutable as i, ImmutableSet as l, IEntity as m, IdentityComponent as n, ImmutableMap as o, EntityUid as p, BooleanProps as r, ImmutableObject as s, BasicComponentType as t, Mutable as u, IEntityProxyRepository as v, ComponentTypeUid as x, RequiredProxies as y };
+//# sourceMappingURL=identity-component-DLDaOTyK.d.cts.map