@ankhzet/gcl 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @ankhzet/gcl
 
+## 1.2.0
+
+### Minor Changes
+
+- Fix release
+
+### Patch Changes
+
+- Updated dependencies
+  - @ankhzet/eventual@1.2.0
+
 ## 1.1.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -0,0 +1,183 @@
+import { EventName } from '@ankhzet/eventual';
+import { Eventual } from '@ankhzet/eventual';
+import { IEventHandler } from '@ankhzet/eventual';
+import { IEventSource } from '@ankhzet/eventual';
+
+/** @public */
+export declare type Chain<In extends Class<any, any, any>, Rest extends any[]> = (Rest extends Mixed<infer Head, infer Tail> ? Chain<Mix<In, Head>, Tail> : In);
+
+/** @public */
+export declare type Class<T extends NonNullable<unknown> = any, Args extends unknown[] = any[], IsAbstract = false> = IsAbstract extends true ? abstract new (...args: Args) => T : new (...args: Args) => T;
+
+/** @public */
+export declare abstract class Component<P> extends DisposableEventSource implements GCInterface<P> {
+    parent: P;
+    constructor(parent: P);
+    static isClass<K extends {
+        new (...args: any[]): any;
+    }>(klass: K): (instance: any) => instance is InstanceType<K>;
+}
+
+/** @public */
+export declare type ComponentConstructor<P, E> = {
+    new (parent: P, factories: ComponentsFactory<E, any>[], ...args: any[]): E;
+};
+
+/** @public */
+export declare interface ComponentsFactory<P, C extends GCInterface<P>> {
+    (parent: P): C | C[];
+}
+
+/** @public */
+export declare interface DGCInterface<P = any> extends GCInterface<P> {
+    isDriven: boolean;
+    update(delta: number): void;
+    onDrive(handler: IEventHandler<this>): Disposer;
+}
+
+/** @public */
+export declare class DisposableEventSource extends Eventual implements DisposableInterface {
+    private _disposers?;
+    dispose(): void;
+    addDisposer(d: Disposer): void;
+    addControlledDisposer(d: Disposer): Disposer;
+    removeDisposer(d: Disposer): void;
+    onDispose(handler: IEventHandler<this>): Disposer;
+    /* Excluded from this release type: handleEvent */
+}
+
+/** @public */
+export declare interface DisposableInterface extends IEventSource {
+    dispose(): void;
+    addDisposer(d: Disposer): void;
+    addControlledDisposer(d: Disposer): Disposer;
+    removeDisposer(d: Disposer): void;
+    onDispose(handler: IEventHandler<this>): Disposer;
+}
+
+/** @public */
+export declare type Disposer = () => void;
+
+/** @public */
+export declare abstract class DynamicComponent<P> extends Component<P> implements DGCInterface<P> {
+    private _isDriven;
+    get isDriven(): boolean;
+    set isDriven(value: boolean);
+    onDrive(handler: IEventHandler<this>): Disposer;
+    abstract update(delta: number): void;
+}
+
+/** @public */
+export declare class EntitiesPool<E extends EntityInterface> extends DisposableEventSource {
+    #private;
+    constructor();
+    get uid(): string;
+    get entities(): Iterable<E>;
+    add(entity: E): void;
+    remove(entity: E): void;
+    update(delta: number): void;
+    onEntity(handler: IEventHandler<{
+        entity: E;
+        added: boolean;
+    }>): Disposer;
+}
+
+/** @public */
+export declare class Entity<P extends GCInterface | null = null> extends DynamicComponent<P> implements EntityInterface<P>, Reference<EntityInterface<P>> {
+    private static GUID;
+    static is: (ref: Reference) => ref is Reference<EntityInterface>;
+    readonly uid: string;
+    readonly components: GCInterface<this>[];
+    protected readonly disposers: Map<GCInterface<this>, Disposer>;
+    protected readonly driven: DGCInterface<this>[];
+    private readonly componentsMap;
+    constructor(parent: P, factories?: ComponentsFactory<any, any>[]);
+    toString(): string;
+    get type(): ReferenceType;
+    private handleComponentDrive;
+    private registerComponent;
+    addComponent(component: GCInterface): void;
+    removeComponent(component: GCInterface): void;
+    findComponent<T extends GCInterface>(predicate: (c: any) => c is T): T | undefined;
+    findComponents<T extends GCInterface>(predicate: (c: any) => c is T): T[];
+    onComponent(handler: IEventHandler<{
+        component: GCInterface;
+        added: boolean;
+    }>): Disposer;
+    update(delta: number): void;
+}
+
+/** @public */
+export declare interface EntityInterface<P extends GCInterface | null = any> extends DGCInterface<P>, Reference {
+    readonly uid: string;
+    readonly type: ReferenceType;
+    addComponent(component: GCInterface): void;
+    removeComponent(component: GCInterface): void;
+    findComponents<T extends GCInterface>(predicate: (c: any) => c is T): T[];
+    findComponent<T extends GCInterface>(predicate: (c: any) => c is T): T | undefined;
+    onComponent(handler: IEventHandler<{
+        component: GCInterface;
+        added: boolean;
+    }>): Disposer;
+}
+
+/** @public */
+export declare interface GCInterface<P = any> extends DisposableInterface {
+    parent: P;
+}
+
+/** @public */
+export declare type Getter<This, Value> = (this: This) => Value;
+
+/** @public */
+export declare const isDynamicComponent: <C extends GCInterface>(c: C) => c is (DGCInterface & C);
+
+/** @public */
+export declare const isEntityRef: (ref: Reference) => ref is Reference<EntityInterface>;
+
+/** @public */
+export declare const lazy: <This, Value>(target: Getter<This, Value>, context: ClassGetterDecoratorContext<This, Value>) => Getter<This, Value>;
+
+/** @public */
+export declare const lazyAccessor: <This, Value>(init: Getter<This, Value>) => ({ get, set }: ClassAccessorDecoratorTarget<This, Value>, _context: ClassAccessorDecoratorContext<This, Value>) => ClassAccessorDecoratorResult<This, Value>;
+
+/** @public */
+export declare type Mix<Base extends Class<any, any, any>, Mixin extends Class<any, any>> = {
+    [k in keyof Base | keyof Mixin]: (k extends keyof Mixin ? Mixin[k] : k extends keyof Base ? Base[k] : never);
+} & (new (...args: ConstructorParameters<Mixin>) => InstanceType<Base> & InstanceType<Mixin>);
+
+/** @public */
+export declare type Mixed<Head extends Class, Tail extends Class[]> = [Head, ...Tail];
+
+/** @public */
+export declare type MixFactory = (base: Class<any, any>) => Class<any, any>;
+
+/** @public */
+export declare const Mixin: <Base extends Class<any, any, true>>(base: Base) => <Mixins extends MixFactory[]>(...mixins: Mixins) => Chain<Base, Returns<Mixins>>;
+
+/** @public */
+export declare type Reference<T = {}> = T & {
+    readonly type: ReferenceType;
+};
+
+/** @public */
+export declare class ReferenceBuckets<R extends Reference> extends Map<ReferenceType, Set<R>> {
+    #private;
+    get size(): number;
+    set size(value: number);
+    map<U>(mapper: (element: R) => U): U[];
+    contains(reference: R): Set<R> | undefined;
+    add(reference: R): void;
+    remove(reference: R): boolean;
+}
+
+/** @public */
+export declare type ReferenceType = number;
+
+/** @public */
+export declare const RefTypeEntity: ReferenceType;
+
+/** @public */
+export declare type Returns<Mixins extends any[]> = (Mixins extends [infer Last, ...infer Rest] ? Last extends MixFactory ? [ReturnType<Last>, ...Returns<Rest>] : [] : []);
+
+export { }

package/dist/index.js

@@ -0,0 +1,196 @@
+import { Eventual as e } from "@ankhzet/eventual";
+//#region src/Disposable.ts
+var t = Symbol.for("disposed"), n = class extends e {
+	_disposers;
+	dispose() {
+		let e = this._disposers;
+		if (this.dispatchEvent(t, this), e) {
+			this._disposers = void 0;
+			for (let t of e) t();
+		}
+	}
+	addDisposer(e) {
+		(this._disposers ||= []).push(e);
+	}
+	addControlledDisposer(e) {
+		return this.addDisposer(e), () => {
+			e &&= (this.removeDisposer(e), e(), void 0);
+		};
+	}
+	removeDisposer(e) {
+		if (!this._disposers) return;
+		let t = this._disposers.indexOf(e);
+		t >= 0 && this._disposers.splice(t, 1);
+	}
+	onDispose(e) {
+		return this.handleEvent(t, e, !0);
+	}
+	handleEvent(e, t, n) {
+		return this.addControlledDisposer(super.handleEvent(e, t, n));
+	}
+}, r = class extends n {
+	parent;
+	constructor(e) {
+		super(), this.parent = e;
+	}
+	static isClass(e) {
+		return (t) => t.constructor === e;
+	}
+}, i = Symbol.for("drive_component"), a = (e) => "isDriven" in e, o = class extends r {
+	_isDriven = !0;
+	get isDriven() {
+		return this._isDriven;
+	}
+	set isDriven(e) {
+		this._isDriven !== e && (this._isDriven = e, this.dispatchEvent(i, this));
+	}
+	onDrive(e) {
+		return this.handleEvent(i, e);
+	}
+}, s = 1, c = class extends Map {
+	#e = 0;
+	get size() {
+		return this.#e;
+	}
+	set size(e) {
+		this.#e = e;
+	}
+	map(e) {
+		let t = this.size, n = Array(t);
+		if (!t) return n;
+		let r = 0;
+		for (let t of this.values()) for (let i of t) n[r++] = e(i);
+		return n;
+	}
+	contains(e) {
+		let t = this.get(e.type);
+		if (t?.has(e)) return t;
+	}
+	add(e) {
+		let t = this.get(e.type);
+		if (t) {
+			if (t.has(e)) return;
+			t.add(e);
+		} else this.set(e.type, new Set([e]));
+		this.size++;
+	}
+	remove(e) {
+		let t = this.contains(e);
+		return t ? (t.delete(e), this.size--, !0) : !1;
+	}
+}, l = Symbol.for("E_COMPONENT"), u = (e) => !!(e.type & 1), d = class e extends o {
+	static GUID = 0;
+	static is = u;
+	uid = `${++e.GUID}`;
+	components;
+	disposers = /* @__PURE__ */ new Map();
+	driven;
+	componentsMap = /* @__PURE__ */ new WeakMap();
+	constructor(e, t) {
+		super(e), this.components = t?.length ? t.map((e) => e(this)).flat() : [], this.driven = [];
+		for (let e of this.components) this.registerComponent(e);
+	}
+	toString() {
+		return this.uid;
+	}
+	get type() {
+		return 1;
+	}
+	handleComponentDrive = (e) => {
+		let t = this.driven.indexOf(e);
+		e.isDriven ? t < 0 && this.driven.push(e) : t >= 0 && this.driven.splice(t, 1);
+	};
+	registerComponent(e) {
+		let t = () => e.dispose();
+		this.addDisposer(t);
+		let n = [() => this.removeDisposer(t)];
+		a(e) && (e.isDriven && this.driven.push(e), n.push(e.onDrive(this.handleComponentDrive), () => {
+			if (!e.isDriven) return;
+			let t = this.driven.indexOf(e);
+			t >= 0 && this.driven.splice(t, 1);
+		})), this.disposers.set(e, this.addControlledDisposer(() => {
+			for (let e of n) e();
+		}));
+	}
+	addComponent(e) {
+		this.components.includes(e) || (this.components.push(e), this.registerComponent(e), this.dispatchEvent(l, {
+			component: e,
+			added: !0
+		}));
+	}
+	removeComponent(e) {
+		let t = this.components.indexOf(e);
+		t >= 0 && (this.components.splice(t, 1), this.disposers.get(e)?.(), this.dispatchEvent(l, {
+			component: e,
+			added: !1
+		}));
+	}
+	findComponent(e) {
+		let t = this.componentsMap.get(e);
+		if (!t) {
+			let t = this.components.find(e);
+			return this.componentsMap.set(e, t), t;
+		}
+		return t;
+	}
+	findComponents(e) {
+		return this.components.filter(e);
+	}
+	onComponent(e) {
+		return this.handleEvent(l, e);
+	}
+	update(e) {
+		for (let t of this.driven) t.update(e);
+	}
+}, f = Symbol.for("pool_entity"), p = class extends n {
+	#e = new d(null);
+	constructor() {
+		super(), this.addDisposer(() => {
+			this.#e.dispose();
+		});
+	}
+	get uid() {
+		return this.#e.uid;
+	}
+	get entities() {
+		return this.#e.components;
+	}
+	add(e) {
+		this.#e.addComponent(e), this.dispatchEvent(f, {
+			entity: e,
+			added: !0
+		});
+	}
+	remove(e) {
+		this.#e.removeComponent(e), this.dispatchEvent(f, {
+			entity: e,
+			added: !1
+		});
+	}
+	update(e) {
+		this.#e.update(e);
+	}
+	onEntity(e) {
+		return this.handleEvent(f, e);
+	}
+}, m = (e, t) => function() {
+	let n = e.call(this);
+	return Object.defineProperty(this, t.name, {
+		enumerable: !t.private,
+		configurable: !0,
+		value: n
+	}), n;
+}, h = Symbol("INIT"), g = (e) => (({ get: t, set: n }, r) => ({
+	init() {
+		return h;
+	},
+	get() {
+		let r = t.call(this);
+		return r === h && (r = e.call(this), n.call(this, r)), r;
+	},
+	set: n
+})), _ = (e) => ((...t) => t.reduce((e, t) => t(e), e));
+//#endregion
+export { r as Component, n as DisposableEventSource, o as DynamicComponent, p as EntitiesPool, d as Entity, _ as Mixin, s as RefTypeEntity, c as ReferenceBuckets, a as isDynamicComponent, u as isEntityRef, m as lazy, g as lazyAccessor };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["#size","#pool"],"sources":["../src/Disposable.ts","../src/Component.ts","../src/DynamicComponent.ts","../src/Reference.ts","../src/ReferenceBuckets.ts","../src/Entity.ts","../src/EntitiesPool.ts","../src/lazy.ts","../src/lazyAccessor.ts","../src/Mixin.ts"],"sourcesContent":["import type { IEventSource, EventName, IEventHandler} from '@ankhzet/eventual';\nimport { Eventual } from '@ankhzet/eventual';\n\n/** @public */\nexport type Disposer = () => void;\n\nconst E_DISPOSED = Symbol.for('disposed');\n\n/** @public */\nexport interface DisposableInterface extends IEventSource {\n    dispose(): void;\n    addDisposer(d: Disposer): void;\n    addControlledDisposer(d: Disposer): Disposer;\n    removeDisposer(d: Disposer): void;\n    onDispose(handler: IEventHandler<this>): Disposer;\n}\n\n/** @public */\nexport class DisposableEventSource extends Eventual implements DisposableInterface {\n    private _disposers?: Disposer[];\n\n    public dispose(): void {\n        const disposers = this._disposers;\n\n        this.dispatchEvent(E_DISPOSED, this);\n\n        if (disposers) {\n            this._disposers = void 0;\n\n            for (const disposer of disposers) {\n                disposer();\n            }\n        }\n    }\n\n    public addDisposer(d: Disposer) {\n        (this._disposers || (this._disposers = [])).push(d);\n    }\n\n    public addControlledDisposer(d: Disposer): Disposer {\n        this.addDisposer(d);\n\n        return () => {\n            if (!d) {\n                return;\n            }\n\n            this.removeDisposer(d);\n            d();\n            (d as any) = void 0;\n        };\n    }\n\n    public removeDisposer(d: Disposer) {\n        if (!this._disposers) {\n            return;\n        }\n\n        const idx = this._disposers.indexOf(d);\n\n        if (idx >= 0) {\n            this._disposers.splice(idx, 1);\n        }\n    }\n\n    public onDispose(handler: IEventHandler<this>) {\n        return this.handleEvent(E_DISPOSED, handler, true);\n    }\n\n    /** @internal */\n    public handleEvent<D, N extends EventName>(type: N, handler: IEventHandler<D>, once?: boolean): Disposer {\n        return this.addControlledDisposer(super.handleEvent(type, handler, once));\n    }\n}\n","import type { DisposableInterface } from './Disposable';\nimport { DisposableEventSource } from './Disposable';\n\n/** @public */\nexport interface GCInterface<P = any> extends DisposableInterface {\n    parent: P;\n}\n\n/** @public */\nexport type ComponentConstructor<P, E> = {\n    new(parent: P, factories: ComponentsFactory<E, any>[], ...args: any[]): E;\n};\n\n/** @public */\nexport interface ComponentsFactory<P, C extends GCInterface<P>> {\n    (parent: P): C|C[];\n}\n\n/** @public */\nexport abstract class Component<P> extends DisposableEventSource implements GCInterface<P> {\n    public parent: P;\n\n    public constructor(parent: P) {\n        super();\n        this.parent = parent;\n    }\n\n    public static isClass<K extends { new (...args: any[]): any }>(klass: K) {\n        return (instance: any): instance is InstanceType<K> => (instance as any).constructor === klass;\n    }\n}\n","import type { IEventHandler } from '@ankhzet/eventual';\nimport type { Disposer } from './Disposable';\nimport type { GCInterface } from './Component';\nimport { Component } from './Component';\n\nconst E_DRIVE = Symbol.for('drive_component');\n\n/** @public */\nexport const isDynamicComponent = <C extends GCInterface>(c: C): c is (DGCInterface & C) => (\n    'isDriven' in c\n);\n\n/** @public */\nexport interface DGCInterface<P = any> extends GCInterface<P> {\n    isDriven: boolean;\n    update(delta: number): void;\n    onDrive(handler: IEventHandler<this>): Disposer;\n}\n\n/** @public */\nexport abstract class DynamicComponent<P> extends Component<P> implements DGCInterface<P> {\n    private _isDriven: boolean = true;\n\n    public get isDriven(): boolean {\n        return this._isDriven;\n    }\n\n    public set isDriven(value: boolean) {\n        if (this._isDriven === value) {\n            return;\n        }\n\n        this._isDriven = value;\n        this.dispatchEvent(E_DRIVE, this);\n    }\n\n    public onDrive(handler: IEventHandler<this>): Disposer {\n        return this.handleEvent(E_DRIVE, handler);\n    }\n\n    public abstract update(delta: number): void;\n}\n","/** @public */\nexport type ReferenceType = number;\n\n/** @public */\nexport type Reference<T = {}> = T & {\n    readonly type: ReferenceType;\n}\n\n/** @public */\nexport const RefTypeEntity: ReferenceType = 1 << 0;\n","import type { Reference, ReferenceType } from './Reference';\n\n/** @public */\nexport class ReferenceBuckets<R extends Reference> extends Map<ReferenceType, Set<R>> {\n    #size: number = 0;\n\n    public get size(): number {\n        return this.#size;\n    }\n\n    public set size(value: number) {\n        this.#size = value;\n    }\n\n    public map<U>(mapper: (element: R) => U): U[] {\n        const size = this.size;\n        const result: U[] = Array(size);\n\n        if (!size) {\n            return result;\n        }\n\n        let idx = 0;\n\n        for (const set of this.values()) {\n            for (const element of set) {\n                result[idx++] = mapper(element);\n            }\n        }\n\n        return result;\n    }\n\n    public contains(reference: R): Set<R> | undefined {\n        const bucket = this.get(reference.type);\n\n        if (bucket?.has(reference)) {\n            return bucket;\n        }\n    }\n\n    public add(reference: R): void {\n        const bucket = this.get(reference.type);\n\n        if (bucket) {\n            if (bucket.has(reference)) {\n                return;\n            }\n\n            bucket.add(reference);\n        } else {\n            this.set(reference.type, new Set([reference]));\n        }\n\n        this.size++;\n    }\n\n    public remove(reference: R): boolean {\n        const found = this.contains(reference);\n\n        if (found) {\n            found.delete(reference);\n            this.size--;\n\n            return true;\n        }\n\n        return false;\n    }\n}\n","import type { IEventHandler } from '@ankhzet/eventual';\nimport type { ComponentsFactory, GCInterface } from './Component';\nimport type { EntityInterface } from './EntityInterface';\nimport type { Reference, ReferenceType} from './Reference';\nimport type { Disposer } from './Disposable';\nimport type { DGCInterface} from './DynamicComponent';\nimport { RefTypeEntity } from './Reference';\nimport { DynamicComponent, isDynamicComponent } from './DynamicComponent';\n\nconst E_COMPONENT = Symbol.for('E_COMPONENT');\n\n/** @public */\nexport const isEntityRef = (ref: Reference): ref is Reference<EntityInterface> => !!(\n    ref.type & RefTypeEntity\n);\n\n/** @public */\nexport class Entity<P extends GCInterface|null = null>\n    extends DynamicComponent<P>\n    implements EntityInterface<P>, Reference<EntityInterface<P>>\n{\n    private static GUID: number = 0;\n    public static is = isEntityRef;\n\n    public readonly uid: string = `${++Entity.GUID}`;\n    public readonly components: GCInterface<this>[];\n    protected readonly disposers = new Map<GCInterface<this>, Disposer>();\n    protected readonly driven: DGCInterface<this>[];\n    private readonly componentsMap = new WeakMap();\n\n    public constructor(parent: P, factories?: ComponentsFactory<any, any>[]) {\n        super(parent);\n        this.components = factories?.length\n            ? factories.map((factory) => factory(this)).flat()\n            : []\n        ;\n        this.driven = [];\n\n        for (const component of this.components) {\n            this.registerComponent(component);\n        }\n    }\n\n    public toString() {\n        return this.uid;\n    }\n\n    public get type(): ReferenceType {\n        return RefTypeEntity;\n    }\n\n    private handleComponentDrive = (component: DGCInterface) => {\n        const has = this.driven.indexOf(component);\n\n        if (component.isDriven) {\n            if (has < 0) {\n                this.driven.push(component);\n            }\n        } else if (has >= 0) {\n            this.driven.splice(has, 1);\n        }\n    }\n\n    private registerComponent(component: GCInterface) {\n        const free = () => component.dispose();\n\n        this.addDisposer(free);\n\n        const disposers: Disposer[] = [() => this.removeDisposer(free)];\n\n        if (isDynamicComponent(component)) {\n            if (component.isDriven) {\n                this.driven.push(component);\n            }\n\n            disposers.push(\n                component.onDrive(this.handleComponentDrive),\n                () => {\n                    if (!component.isDriven) {\n                        return;\n                    }\n\n                    const index = this.driven.indexOf(component);\n\n                    if (index >= 0) {\n                        this.driven.splice(index, 1);\n                    }\n                },\n            );\n        }\n\n        this.disposers.set(component, this.addControlledDisposer(() => {\n            for (const disposer of disposers) {\n                disposer();\n            }\n        }));\n    }\n\n    public addComponent(component: GCInterface): void {\n        if (this.components.includes(component)) {\n            return;\n        }\n\n        this.components.push(component);\n        this.registerComponent(component);\n\n        this.dispatchEvent(E_COMPONENT, { component, added: true });\n    }\n\n    public removeComponent(component: GCInterface): void {\n        const index = this.components.indexOf(component);\n\n        if (index >= 0) {\n            this.components.splice(index, 1);\n            this.disposers.get(component)?.();\n\n            this.dispatchEvent(E_COMPONENT, { component, added: false });\n        }\n    }\n\n    public findComponent<T extends GCInterface>(predicate: (c: any) => c is T): T|undefined {\n        const has = this.componentsMap.get(predicate);\n\n        if (!has) {\n            const component = this.components.find(predicate);\n            this.componentsMap.set(predicate, component);\n\n            return component;\n        }\n\n        return has;\n    }\n\n    public findComponents<T extends GCInterface>(predicate: (c: any) => c is T): T[] {\n        return this.components.filter(predicate);\n    }\n\n    public onComponent(handler: IEventHandler<{ component: GCInterface; added: boolean }>): Disposer {\n        return this.handleEvent(E_COMPONENT, handler);\n    }\n\n    public update(delta: number) {\n        for (const component of this.driven) {\n            component.update(delta);\n        }\n    }\n}\n","import type { IEventHandler } from '@ankhzet/eventual';\nimport type { EntityInterface } from './EntityInterface';\nimport { Entity } from './Entity';\nimport { DisposableEventSource } from './Disposable';\n\nconst E_ENTITY = Symbol.for('pool_entity');\n\n/** @public */\nexport class EntitiesPool<E extends EntityInterface> extends DisposableEventSource {\n    #pool = new Entity(null);\n\n    public constructor() {\n        super();\n\n        this.addDisposer(() => {\n            this.#pool.dispose();\n        });\n    }\n\n    public get uid() {\n        return this.#pool.uid;\n    }\n\n    public get entities(): Iterable<E> {\n        return this.#pool.components as Iterable<E>;\n    }\n\n    public add(entity: E): void {\n        this.#pool.addComponent(entity);\n\n        this.dispatchEvent(E_ENTITY, {\n            entity,\n            added: true,\n        });\n    }\n\n    public remove(entity: E): void {\n        this.#pool.removeComponent(entity);\n\n        this.dispatchEvent(E_ENTITY, {\n            entity,\n            added: false,\n        });\n    }\n\n    public update(delta: number) {\n        this.#pool.update(delta);\n    }\n\n    public onEntity(handler: IEventHandler<{ entity: E; added: boolean }>) {\n        return this.handleEvent(E_ENTITY, handler);\n    }\n}\n","/** @public */\nexport type Getter<This, Value> = (this: This) => Value;\n\n/** @public */\nexport const lazy = <This, Value>(\n    target: Getter<This, Value>,\n    context: ClassGetterDecoratorContext<This, Value>,\n): Getter<This, Value> => {\n    return function (this: This): Value {\n        const value = target.call(this);\n\n        Object.defineProperty(this, context.name, {\n            enumerable: !context.private,\n            configurable: true,\n            value,\n        });\n\n        return value;\n    };\n};\n","import type { Getter } from './lazy';\n\nconst INIT = Symbol('INIT');\n\n/** @public */\nexport const lazyAccessor = <This, Value>(init: Getter<This, Value>) => (\n    (\n        { get, set }: ClassAccessorDecoratorTarget<This, Value>,\n        _context: ClassAccessorDecoratorContext<This, Value>,\n    ): ClassAccessorDecoratorResult<This, Value> => ({\n        init(): Value {\n            return INIT as Value;\n        },\n        get(this: This): Value {\n            let value = get.call(this);\n\n            if (value === INIT) {\n                value = init.call(this);\n\n                set.call(this, value);\n            }\n\n            return value;\n        },\n        set,\n    })\n);\n","/** @public */\nexport type Class<\n    T extends NonNullable<unknown> = any,\n    Args extends unknown[] = any[],\n    IsAbstract = false\n> = IsAbstract extends true ? abstract new(...args: Args) => T : new(...args: Args) => T;\n\n/** @public */\nexport type Mix<Base extends Class<any, any, any>, Mixin extends Class<any, any>> = {\n    [k in keyof Base | keyof Mixin]: (\n        k extends keyof Mixin\n            ? Mixin[k]\n            : k extends keyof Base\n                ? Base[k]\n                : never\n        );\n} & (new(...args: ConstructorParameters<Mixin>) => InstanceType<Base> & InstanceType<Mixin>);\n\n/** @public */\nexport type Mixed<Head extends Class, Tail extends Class[]> = [Head, ...Tail];\n\n/** @public */\nexport type Chain<In extends Class<any, any, any>, Rest extends any[]> = (\n    Rest extends Mixed<infer Head, infer Tail>\n        ? Chain<Mix<In, Head>, Tail>\n        : In\n);\n\n/** @public */\nexport type MixFactory = (base: Class<any, any>) => Class<any, any>;\n\n/** @public */\nexport type Returns<Mixins extends any[]> = (\n    Mixins extends [infer Last, ...infer Rest]\n        ? Last extends MixFactory\n            ? [ReturnType<Last>, ...Returns<Rest>]\n            : []\n        : []\n    );\n\n/** @public */\nexport const Mixin = <Base extends Class<any, any, true>>(base: Base) => (\n    <Mixins extends MixFactory[]>(...mixins: Mixins): Chain<Base, Returns<Mixins>> => {\n        return mixins.reduce((acc: Class<any, any>, mixin: MixFactory) => mixin(acc), base as any) as any;\n    }\n);\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ankhzet/gcl",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "author": "AnkhZet ankhzet@gmail.com",
   "type": "module",
   "main": "./src/index.ts",
@@ -9,7 +9,7 @@
     "package.json",
     "src/**/*.ts",
     "src/**/*.tsx",
-    "build",
+    "dist",
     "*.md"
   ],
   "exports": {
@@ -22,7 +22,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@ankhzet/eventual": "1.1.0"
+    "@ankhzet/eventual": "1.2.0"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.58.7"