@block_factory/lib 0.0.5 → 0.0.6

package/_module/BlockFactory.ts

@@ -1,5 +1,3 @@
-export { _INITIALIZE_BF_FRAMEWORK_ } from "@block_factory/lib/_module/Framework/_INIT";
-
 export { MathUtils } from "./util/Math";
 export { Signal } from "./util/Signal";
 export { Vec2, Vec3 } from "./util/Vector";
@@ -17,6 +15,7 @@ export { Inventory, ContainerWrapper } from "./util/Wrapper/Container";
 export { type IEntity, IEntityWrapper } from "./util/Wrapper/IEntity";
 export { type IPlayer, IPlayerWrapper } from "./util/Wrapper/IPlayer";
 
-export { type Sound, type Animation } from "./Types";
-export { _THREAD_ } from "@block_factory/lib/_module/Framework/Threads";
-export { _EntityHandler_,  type EntityEmissionEvent, onEntityEmission } from "@block_factory/lib/_module/Framework/EntityTasks";
+export { Thread } from "./Framework/Threads";
+export { PlayerHandler } from "./Framework/PlayerTasks";
+export { EntityHandler,  type EntityEmissionEvent } from "./Framework/EntityTasks";
+export { ItemHandler, type ItemRegistration, type OnItemHeldEvent, type OnItemUnheldEvent, type WhileHoldingItemEvent } from "./Framework/ItemTasks";

package/_module/Framework/EntityTasks.ts

@@ -1,59 +1,30 @@
-import {
-    Entity,
-    system,
-    ScriptEventCommandMessageAfterEvent,
-    ScriptEventCommandMessageAfterEventSignal,
-    world,
-    WorldLoadAfterEventSignal,
-    WorldLoadAfterEvent,
-    EntitySpawnAfterEventSignal,
-    EntityRemoveAfterEventSignal,
-    EntitySpawnAfterEvent,
-    EntityRemoveAfterEvent,
-    EntityRemoveBeforeEvent,
-    EntityRemoveBeforeEventSignal,
-} from "@minecraft/server";
+import { Entity, system, ScriptEventCommandMessageAfterEvent, ScriptEventCommandMessageAfterEventSignal, world, WorldLoadAfterEventSignal, WorldLoadAfterEvent, EntitySpawnAfterEventSignal, EntitySpawnAfterEvent, EntityRemoveBeforeEvent, EntityRemoveBeforeEventSignal } from "@minecraft/server";
 
 import { Signal } from "../util/Signal";
 import { IEntityWrapper, IEntity } from "../util/Wrapper/IEntity";
 
-/* -------------------------------------------------------------------------- */
-/* Public API                                                                 */
-/* -------------------------------------------------------------------------- */
-
 export type EntityEmissionEvent = {
     iEntity: IEntity;
     parms: any;
 };
 
-export const onEntityEmission = new Signal<EntityEmissionEvent>();
-
-/* -------------------------------------------------------------------------- */
-/* Singleton                                                                  */
-/* -------------------------------------------------------------------------- */
-
-
-
-class EntityHandler {
+class SingletonEntityHandler {
     private PACK_ID: string | undefined;
-    private GLOBAL_MEMORY_ID = "GLB_MEM.ENTITY";
+    
+    public readonly onEntityEmission = new Signal<EntityEmissionEvent>();
+    private readonly GLOBAL_MEMORY_ID = "GLB_MEM.ENTITY";
 
     private readonly scriptEventSignal: ScriptEventCommandMessageAfterEventSignal = system.afterEvents.scriptEventReceive;
     private readonly loadEventSignal: WorldLoadAfterEventSignal = world.afterEvents.worldLoad;
     private readonly spawnEventSignal: EntitySpawnAfterEventSignal = world.afterEvents.entitySpawn;
-    private readonly removeAfterEventSignal: EntityRemoveAfterEventSignal = world.afterEvents.entityRemove;
     private readonly removeBeforeEventSignal: EntityRemoveBeforeEventSignal = world.beforeEvents.entityRemove;
 
     private readonly EM_INDEX = new Map<string, Entity>();
     private readonly EM_KEYS: string[] = [];
     private readonly SEARCH_TYPES = new Set<string>();
 
-    private _started = false;
-    private _wired = false;
-
-    public configure(): void {
-        if (this._started) throw new Error("BFLIB: EntityHandler already started;");
-    }
+    private _started: boolean = false;
+    private _wired: boolean = false;
 
     public registerEntity(typeId: string | string[]): void {
         if (Array.isArray(typeId)) typeId.forEach((t) => this.SEARCH_TYPES.add(t));
@@ -61,10 +32,9 @@ class EntityHandler {
     }
 
     public start(packId: string): void {
-        if (this._started) return;
+        if (this._started) throw new Error("BFLIB: EntityHandler already started;");
         this._started = true;
         this.PACK_ID = packId;
-
         this.loadEventSignal.subscribe(this.onWorldLoad);
     }
 
@@ -76,7 +46,6 @@ class EntityHandler {
             this.scriptEventSignal.unsubscribe(this.processScriptEvents);
             this.spawnEventSignal.unsubscribe(this.onEntitySpawned);
             this.removeBeforeEventSignal.unsubscribe(this.onEntityRemovedBefore);
-            this.removeAfterEventSignal.unsubscribe(this.onEntityRemovedAfter);
             this._wired = false;
         }
 
@@ -87,14 +56,12 @@ class EntityHandler {
     /* Event Wiring                                                             */
     /* ------------------------------------------------------------------------ */
 
-    private onWorldLoad = (_event: WorldLoadAfterEvent): void => {
-
+    private onWorldLoad = (): void => {
         this.scriptEventSignal.subscribe(this.processScriptEvents);
 
         if (this.SEARCH_TYPES.size > 0) {
             this.spawnEventSignal.subscribe(this.onEntitySpawned);
             this.removeBeforeEventSignal.subscribe(this.onEntityRemovedBefore);
-            this.removeAfterEventSignal.subscribe(this.onEntityRemovedAfter);
         }
 
         this._wired = true;
@@ -114,10 +81,7 @@ class EntityHandler {
             return;
         }
 
-        onEntityEmission.emit({
-            iEntity: IEntityWrapper.wrap(event.sourceEntity),
-            parms,
-        });
+        this.onEntityEmission.emit({ iEntity: IEntityWrapper.wrap(event.sourceEntity), parms });
     };
 
     /* ------------------------------------------------------------------------ */
@@ -125,6 +89,7 @@ class EntityHandler {
     /* ------------------------------------------------------------------------ */
 
     private isValidType(typeId: string): boolean {
+        if (this.PACK_ID && !typeId.startsWith(this.PACK_ID)) return false;
         return this.SEARCH_TYPES.has(typeId);
     }
 
@@ -140,10 +105,6 @@ class EntityHandler {
         this.deleteEntityInMemory(entity);
     };
 
-    private onEntityRemovedAfter = (_event: EntityRemoveAfterEvent): void => {
-        // 
-    };
-
     /* ------------------------------------------------------------------------ */
     /* Persistence                                                              */
     /* ------------------------------------------------------------------------ */
@@ -200,4 +161,4 @@ class EntityHandler {
     }
 }
 
-export const _EntityHandler_ = new EntityHandler();
+export const EntityHandler = new SingletonEntityHandler();

package/_module/Framework/ItemTasks.ts

@@ -0,0 +1,157 @@
+import { Signal } from "../util/Signal.js";
+import { ItemCompleteUseAfterEvent, ItemCompleteUseAfterEventSignal, ItemReleaseUseAfterEvent, ItemReleaseUseAfterEventSignal, ItemStack, ItemStartUseAfterEvent, ItemStartUseAfterEventSignal, ItemStartUseOnAfterEvent, ItemStartUseOnAfterEventSignal, ItemStopUseAfterEvent, ItemStopUseAfterEventSignal, ItemStopUseOnAfterEvent, ItemStopUseOnAfterEventSignal, ItemUseAfterEvent, ItemUseAfterEventSignal, ItemUseBeforeEvent, ItemUseBeforeEventSignal, Player, PlayerHotbarSelectedSlotChangeAfterEvent, PlayerHotbarSelectedSlotChangeAfterEventSignal, PlayerInventoryItemChangeAfterEvent, PlayerInventoryItemChangeAfterEventSignal, system, world, WorldLoadAfterEvent, WorldLoadAfterEventSignal } from "@minecraft/server";
+
+export type ItemRegistration = {
+    typeId: string;
+    emitWhileHolding?: boolean
+    emitOnUse?: boolean;
+}
+
+export type WhileHoldingItemEvent = { player: Player; itemStack: ItemStack };
+export type OnItemHeldEvent = { player: Player; itemStack: ItemStack };
+export type OnItemUnheldEvent = { player: Player; itemStack: ItemStack | undefined };
+export type OnItemUsedEvent = { player: Player; itemStack: ItemStack };
+
+interface HoldData {
+    instanceId: number;
+    itemStack: ItemStack;
+}
+
+class SingletonItemHandler {
+    private PACK_ID: string | undefined;
+
+    public readonly whileHoldingItemEvent = new Signal<WhileHoldingItemEvent>();
+    public readonly onItemHeldEvent = new Signal<OnItemHeldEvent>();
+    public readonly onItemUnheldEvent = new Signal<OnItemUnheldEvent>();
+    public readonly onItemUsedEvent = new Signal<OnItemUsedEvent>();
+
+    private readonly loadEventSignal: WorldLoadAfterEventSignal = world.afterEvents.worldLoad;
+    private readonly useBeforeSignal: ItemUseBeforeEventSignal = world.beforeEvents.itemUse;
+    private readonly useAfterSignal: ItemUseAfterEventSignal = world.afterEvents.itemUse;
+    private readonly completeUseSignal: ItemCompleteUseAfterEventSignal = world.afterEvents.itemCompleteUse;
+    private readonly releaseUseSignal: ItemReleaseUseAfterEventSignal = world.afterEvents.itemReleaseUse;
+    private readonly startUseSignal: ItemStartUseAfterEventSignal = world.afterEvents.itemStartUse;
+    private readonly startUseOnSignal: ItemStartUseOnAfterEventSignal = world.afterEvents.itemStartUseOn;
+    private readonly stopUseSignal: ItemStopUseAfterEventSignal = world.afterEvents.itemStopUse;
+    private readonly stopUseOnSignal: ItemStopUseOnAfterEventSignal = world.afterEvents.itemStopUseOn;
+    private readonly inventoryItemChangeSignal: PlayerInventoryItemChangeAfterEventSignal = world.afterEvents.playerInventoryItemChange;
+    private readonly hotbarChangeSignal: PlayerHotbarSelectedSlotChangeAfterEventSignal = world.afterEvents.playerHotbarSelectedSlotChange;
+
+    private readonly IM_INDEX = new Map<string, ItemRegistration>();
+    private readonly HOLD_INDEX: Map<string, HoldData> = new Map<string, HoldData>();
+
+    private _started = false;
+    private _wired = false;
+
+    public registerItem(itemRegistration: ItemRegistration | ItemRegistration[]): void {
+        if (Array.isArray(itemRegistration)) itemRegistration.forEach(i => this.IM_INDEX.set(i.typeId, i));
+        else this.IM_INDEX.set(itemRegistration.typeId, itemRegistration);
+    }
+
+    public start(packId: string): void {
+        if (this._started) throw new Error("BFLIB: ItemHandler already started;");
+        this._started = true;
+        this.PACK_ID = packId;
+        this.loadEventSignal.subscribe(this.onWorldLoad);
+    }
+
+    public stop(): void {
+        if (!this._started) return;
+
+        this.loadEventSignal.unsubscribe(this.onWorldLoad);
+
+        if (this._wired) {
+            this.useBeforeSignal.unsubscribe(this.onUseBefore);
+            this.useAfterSignal.unsubscribe(this.onUseAfter);
+            this.completeUseSignal.unsubscribe(this.onCompleteUse);
+            this.releaseUseSignal.unsubscribe(this.onReleaseUse);
+            this.startUseSignal.unsubscribe(this.onStartUse);
+            this.startUseOnSignal.unsubscribe(this.onStartUseOn);
+            this.stopUseSignal.unsubscribe(this.onStopUse);
+            this.stopUseOnSignal.unsubscribe(this.onStopUseOn);
+            this.hotbarChangeSignal.unsubscribe(this.onHotbarChange);
+            this.inventoryItemChangeSignal.unsubscribe(this.onInventoryItemChange);
+
+            this._wired = false;
+        }
+
+        this._started = false;
+    }
+
+
+    private onWorldLoad = (): void => {
+        if (this.IM_INDEX.size > 0) {
+            this.useBeforeSignal.subscribe(this.onUseBefore);
+            this.useAfterSignal.subscribe(this.onUseAfter);
+            this.completeUseSignal.subscribe(this.onCompleteUse);
+            this.releaseUseSignal.subscribe(this.onReleaseUse);
+            this.startUseSignal.subscribe(this.onStartUse);
+            this.startUseOnSignal.subscribe(this.onStartUseOn);
+            this.stopUseSignal.subscribe(this.onStopUse);
+            this.stopUseOnSignal.subscribe(this.onStopUseOn);
+            this.hotbarChangeSignal.subscribe(this.onHotbarChange);
+            this.inventoryItemChangeSignal.subscribe(this.onInventoryItemChange);
+
+            this._wired = true;
+        }
+
+        this.loadEventSignal.unsubscribe(this.onWorldLoad);
+    };
+
+
+    private onUseBefore = (event: ItemUseBeforeEvent): void => {
+        const itemStack: ItemStack = event.itemStack;
+        if (!this.isValidType(itemStack.typeId)) return;
+        const i: ItemRegistration | undefined = this.IM_INDEX.get(itemStack.typeId);
+        if (!i || !i.emitOnUse) return;
+        const runId: number = system.run(() => {
+            try { this.onItemUsedEvent.emit({ player: event.source, itemStack: event.itemStack }) }
+            catch (error) { throw new Error(`${error}`) }
+            finally { system.clearRun(runId) }
+        })
+
+    };
+    private onUseAfter = (_event: ItemUseAfterEvent): void => { };
+    private onCompleteUse = (_event: ItemCompleteUseAfterEvent): void => { };
+    private onReleaseUse = (_event: ItemReleaseUseAfterEvent): void => { };
+    private onStartUse = (_event: ItemStartUseAfterEvent): void => { };
+    private onStartUseOn = (_event: ItemStartUseOnAfterEvent): void => { };
+    private onStopUse = (_event: ItemStopUseAfterEvent): void => { };
+    private onStopUseOn = (_event: ItemStopUseOnAfterEvent): void => { };
+    private onInventoryItemChange = (_event: PlayerInventoryItemChangeAfterEvent): void => { };
+
+    private onHotbarChange = (event: PlayerHotbarSelectedSlotChangeAfterEvent): void => {
+        const itemStack: ItemStack | undefined = event.itemStack;
+        if (this.HOLD_INDEX.has(event.player.id)) this.releaseHold(event.player);
+        if (!itemStack || (itemStack && !this.isValidType(itemStack.typeId))) return;
+        this.setNewHold(itemStack, event.player);
+    };
+
+    private setNewHold(itemStack: ItemStack, player: Player) {
+        this.onItemHeldEvent.emit({ player: player, itemStack: itemStack });
+
+        const i: ItemRegistration | undefined = this.IM_INDEX.get(itemStack.typeId);
+        let instanceId: number = -1
+        if (i && i.emitWhileHolding) {
+            instanceId = system.runInterval(() => {
+                this.whileHoldingItemEvent.emit({ player: player, itemStack: itemStack });
+            })
+        }
+        this.HOLD_INDEX.set(player.id, { instanceId: instanceId, itemStack: itemStack });
+    }
+
+    private releaseHold(player: Player) {
+        const holdData: HoldData | undefined = this.HOLD_INDEX.get(player.id);
+        if (!holdData) return;
+        this.onItemUnheldEvent.emit({ player: player, itemStack: holdData.itemStack });
+        if (holdData.instanceId !== -1) system.clearRun(holdData.instanceId);
+        this.HOLD_INDEX.delete(player.id);
+    }
+
+    private isValidType(typeId: string): boolean {
+        if (this.PACK_ID && !typeId.startsWith(this.PACK_ID)) return false;
+        return this.IM_INDEX.has(typeId);
+    }
+}
+
+export const ItemHandler = new SingletonItemHandler();

package/_module/Framework/PlayerTasks.ts

@@ -0,0 +1,125 @@
+import { IPlayerWrapper, IPlayer } from "../util/Wrapper/IPlayer";
+import { ButtonState, InputButton, Player, PlayerButtonInputAfterEvent, PlayerButtonInputAfterEventSignal, PlayerLeaveBeforeEvent, PlayerLeaveBeforeEventSignal, PlayerSpawnAfterEvent, PlayerSpawnAfterEventSignal, world, WorldLoadAfterEvent, WorldLoadAfterEventSignal } from "@minecraft/server";
+
+class SingletonPlayerHandler {
+    private readonly GLOBAL_MEMORY_ID = "GLB_MEM.PLAYER";
+
+    private readonly loadEventSignal: WorldLoadAfterEventSignal = world.afterEvents.worldLoad;
+    private readonly playerSpawnSignal: PlayerSpawnAfterEventSignal = world.afterEvents.playerSpawn;
+    private readonly playerLeaveBeforeSignal: PlayerLeaveBeforeEventSignal = world.beforeEvents.playerLeave;
+    private readonly buttonInputSignal: PlayerButtonInputAfterEventSignal = world.afterEvents.playerButtonInput;
+
+    private readonly PR_INDEX = new Map<string, Player>();
+    private readonly PR_KEYS: string[] = [];
+
+    private _started: boolean = false;
+    private _wired: boolean = false;
+
+    public start(): void {
+        if (this._started) throw new Error("BFLIB: PlayerHandler already started;");
+        this._started = true;
+        this.onSystemLoad();
+        this.loadEventSignal.subscribe(this.onWorldLoad);
+        this.buttonInputSignal.subscribe(this.onButtonPress);
+    }
+
+    public stop(): void {
+        if (!this._started) return;
+        if (this._wired) {
+            this.playerSpawnSignal.unsubscribe(this.onPlayerSpawned);
+            this.playerLeaveBeforeSignal.unsubscribe(this.onPlayerLeaveBefore);
+            this.buttonInputSignal.unsubscribe(this.onButtonPress);
+            this._wired = false;
+        }
+        this._started = false;
+    }
+
+    private onWorldLoad = (): void => {
+        this.reloadPlayerMemory();
+        this.loadEventSignal.unsubscribe(this.onWorldLoad);
+    };
+
+    private onSystemLoad(): void {
+        this.playerSpawnSignal.subscribe(this.onPlayerSpawned);
+        this.playerLeaveBeforeSignal.subscribe(this.onPlayerLeaveBefore);
+        this._wired = true;
+    }
+
+    private onPlayerSpawned = (event: PlayerSpawnAfterEvent): void => {
+        if (!event) return;
+        if (this.hasPlayer(event.player.id)) return;
+        this.savePlayerInMemory(event.player);
+    };
+
+    private onPlayerLeaveBefore = (event: PlayerLeaveBeforeEvent): void => {
+        if (!this.hasPlayer(event.player.id)) return;
+        this.deletePlayerInMemory(event.player);
+    };
+
+    private onButtonPress = (event: PlayerButtonInputAfterEvent): void => {
+        if (event.button === InputButton.Jump) {
+
+        }
+        else if (event.button === InputButton.Sneak) {
+
+        }
+        console.warn(`Player ${event.player.name} pressed button ${InputButton[event.button]}: ${ButtonState[event.newButtonState]}`);
+    };
+
+    public hasPlayer(playerId: string): boolean {
+        return this.PR_INDEX.has(playerId);
+    }
+
+    /* ------------------------------------------------------------------------ */
+    /* Persistence                                                              */
+    /* ------------------------------------------------------------------------ */
+
+    private reloadPlayerMemory(): void {
+        this.PR_INDEX.clear();
+        this.PR_KEYS.length = 0;
+
+        const players: Player[] = world.getAllPlayers();
+        for (const player of players) {
+            this.PR_INDEX.set(player.id, player);
+            this.PR_KEYS.push(player.id);
+        }
+    }
+
+
+
+    private persistKeys(): void {
+        world.setDynamicProperty(this.GLOBAL_MEMORY_ID, JSON.stringify(this.PR_KEYS));
+    }
+
+    public savePlayerInMemory(player: Player): boolean {
+        if (this.PR_INDEX.has(player.id)) return false;
+        this.PR_KEYS.push(player.id);
+        this.PR_INDEX.set(player.id, player);
+        this.persistKeys();
+
+        return true;
+    }
+
+    public deletePlayerInMemory(player: Player): boolean {
+        const existed = this.PR_INDEX.delete(player.id);
+        if (!existed) return false;
+
+        const idx = this.PR_KEYS.indexOf(player.id);
+        if (idx !== -1) this.PR_KEYS.splice(idx, 1);
+
+        this.persistKeys();
+
+        return true;
+    }
+
+    public getPlayersInMemory(): Player[] {
+        return Array.from(this.PR_INDEX.values());
+    }
+
+    public getIPlayersInMemory(): IPlayer[] {
+        return Array.from(this.PR_INDEX.values())
+            .map(player => IPlayerWrapper.wrap(player));
+    }
+}
+
+export const PlayerHandler = new SingletonPlayerHandler();

package/_module/Framework/Threads.ts

@@ -6,7 +6,7 @@ export type ThreadConfig = {
     lateRate?: number; // interval ticks
 };
 
-class Threads {
+class SingletonThreadManager {
     public readonly MAIN = new Signal<number>();
     public readonly LATE = new Signal<void>();
 
@@ -69,4 +69,4 @@ class Threads {
     }
 }
 
-export const _THREAD_ = new Threads();
+export const Thread = new SingletonThreadManager();

package/_module/util/Signal.ts

@@ -1,33 +1,97 @@
-export type Callback<T> = (data: T) => void;
+/**
+ * Function signature for signal subscription callbacks.
+ *
+ * @template T Payload type emitted by the signal
+ */
+export type SubscriptionCallback<T> = (data: T) => void;
 
+/**
+ * Lightweight signal / event dispatcher inspired by Godot's signal system.
+ *
+ * Signals allow decoupled communication by emitting typed payloads to
+ * subscribed listeners.
+ *
+ * @template T Payload type (use `void` for no data)
+ */
 export class Signal<T = void> {
-    private readonly listeners = new Set<Callback<T>>();
+    /**
+     * Registered signal listeners.
+     */
+    private readonly listeners = new Set<SubscriptionCallback<T>>();
 
+    /**
+     * Number of currently subscribed listeners.
+     */
     public get count(): number {
         return this.listeners.size;
     }
 
-    public connect(callback: Callback<T>): void {
+    /**
+     * Subscribes a callback to this signal.
+     *
+     * The callback will be invoked every time the signal is emitted
+     * until it is explicitly unsubscribed or the signal is cleared.
+     *
+     * @param callback Function invoked on signal emission
+     */
+    public subscribe(callback: SubscriptionCallback<T>): void {
         this.listeners.add(callback);
     }
 
-    public disconnect(callback: Callback<T>): boolean {
+    /**
+     * Unsubscribes a previously registered callback.
+     *
+     * @param callback Callback to remove
+     * @returns `true` if the callback was removed, `false` otherwise
+     */
+    public unsubscribe(callback: SubscriptionCallback<T>): boolean {
         return this.listeners.delete(callback);
     }
 
+    /**
+     * Removes all subscribed listeners from this signal.
+     */
     public clear(): void {
         this.listeners.clear();
     }
 
-    public isConnected(callback: Callback<T>): boolean {
+    /**
+     * Checks whether a callback is currently subscribed.
+     *
+     * @param callback Callback to test
+     * @returns `true` if the callback is subscribed
+     */
+    public isSubscribed(callback: SubscriptionCallback<T>): boolean {
         return this.listeners.has(callback);
     }
 
+    /**
+     * Emits the signal immediately, invoking all subscribed callbacks.
+     *
+     * Listener errors are caught and logged to prevent a single failure
+     * from interrupting signal propagation.
+     *
+     * @param data Payload to pass to listeners
+     */
     public emit(data: T): void {
         for (const callback of Array.from(this.listeners)) {
-            try { callback(data) } catch (err) {
-                console.error("BFLIB: Signal listener error:", err);
+            try {
+                callback(data);
+            } catch (err) {
+                console.error("BFLIB: Subscription listener error:", err);
             }
         }
     }
+
+    /**
+     * Emits the signal asynchronously on the microtask queue.
+     *
+     * Useful for deferring execution to avoid re-entrancy issues
+     * or emitting during unsafe execution phases.
+     *
+     * @param data Payload to pass to listeners
+     */
+    public emitDeferred(data: T): void {
+        queueMicrotask(() => this.emit(data));
+    }
 }

package/_module/util/Wrapper/IEntity.ts

@@ -1,7 +1,7 @@
 import { Entity, EntityInventoryComponent, PlayAnimationOptions, system, TicksPerSecond } from "@minecraft/server";
 import { ContainerWrapper, Inventory } from "./Container";
 import { System } from "../System";
-import { Animation } from "../../Types";
+import { Animation } from "../../DataTypes";
 
 export type IEntity = IEntityWrapper & Entity;
 

package/_module/util/Wrapper/IPlayer.ts

@@ -1,7 +1,7 @@
 import { EntityInventoryComponent, PlayAnimationOptions, Player, PlayerSoundOptions, system, TicksPerSecond } from "@minecraft/server";
 import { ContainerWrapper, Inventory } from "./Container";
 import { System } from "../System";
-import { Animation, Sound } from "../../Types";
+import { Animation, Sound } from "../../DataTypes";
 
 export type IPlayer = IPlayerWrapper & Player;
 

package/_types/_module/BlockFactory.d.ts

@@ -1,4 +1,3 @@
-export { _INITIALIZE_BF_FRAMEWORK_ } from "@block_factory/lib/_module/Framework/_INIT";
 export { MathUtils } from "./util/Math";
 export { Signal } from "./util/Signal";
 export { Vec2, Vec3 } from "./util/Vector";
@@ -13,7 +12,8 @@ export { type IFormRegistration, RegisterForm } from "./util/Forms/FormRegistry"
 export { Inventory, ContainerWrapper } from "./util/Wrapper/Container";
 export { type IEntity, IEntityWrapper } from "./util/Wrapper/IEntity";
 export { type IPlayer, IPlayerWrapper } from "./util/Wrapper/IPlayer";
-export { type Sound, type Animation } from "./Types";
-export { _THREAD_ } from "@block_factory/lib/_module/Framework/Threads";
-export { _EntityHandler_, type EntityEmissionEvent, onEntityEmission } from "@block_factory/lib/_module/Framework/EntityTasks";
+export { Thread } from "./Framework/Threads";
+export { PlayerHandler } from "./Framework/PlayerTasks";
+export { EntityHandler, type EntityEmissionEvent } from "./Framework/EntityTasks";
+export { ItemHandler, type ItemRegistration, type OnItemHeldEvent, type OnItemUnheldEvent, type WhileHoldingItemEvent } from "./Framework/ItemTasks";
 //# sourceMappingURL=BlockFactory.d.ts.map

package/_types/_module/BlockFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlockFactory.d.ts","sourceRoot":"","sources":["../../_module/BlockFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AAEvF,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,mBAAmB,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC9H,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC/K,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAC5F,OAAO,EAAE,KAAK,iBAAiB,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEjF,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,EAAE,KAAK,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,KAAK,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAEtE,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,8CAA8C,CAAC;AACxE,OAAO,EAAE,eAAe,EAAG,KAAK,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC"}
+{"version":3,"file":"BlockFactory.d.ts","sourceRoot":"","sources":["../../_module/BlockFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,mBAAmB,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC9H,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC/K,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAC5F,OAAO,EAAE,KAAK,iBAAiB,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEjF,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,EAAE,KAAK,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,KAAK,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAEtE,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAG,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnF,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,KAAK,iBAAiB,EAAE,KAAK,qBAAqB,EAAE,MAAM,uBAAuB,CAAC"}

package/_types/_module/DataTypes.d.ts

@@ -0,0 +1,10 @@
+export type Sound = {
+    id: string;
+    length: number;
+};
+export type Animation = {
+    id: string;
+    length: number;
+    loop?: boolean;
+};
+//# sourceMappingURL=DataTypes.d.ts.map

package/_types/_module/DataTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataTypes.d.ts","sourceRoot":"","sources":["../../_module/DataTypes.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;CAClB,CAAA"}

package/_types/_module/Framework/EntityTasks.d.ts

@@ -5,36 +5,33 @@ export type EntityEmissionEvent = {
     iEntity: IEntity;
     parms: any;
 };
-export declare const onEntityEmission: Signal<EntityEmissionEvent>;
-declare class EntityHandler {
+declare class SingletonEntityHandler {
+    onEntityEmission: Signal<EntityEmissionEvent>;
     private PACK_ID;
     private GLOBAL_MEMORY_ID;
     private readonly scriptEventSignal;
     private readonly loadEventSignal;
     private readonly spawnEventSignal;
-    private readonly removeAfterEventSignal;
     private readonly removeBeforeEventSignal;
     private readonly EM_INDEX;
     private readonly EM_KEYS;
     private readonly SEARCH_TYPES;
     private _started;
     private _wired;
-    configure(): void;
     registerEntity(typeId: string | string[]): void;
-    start(): void;
+    start(packId: string): void;
     stop(): void;
     private onWorldLoad;
     private processScriptEvents;
     private isValidType;
     private onEntitySpawned;
     private onEntityRemovedBefore;
-    private onEntityRemovedAfter;
     private reloadEntityMemory;
     private persistKeys;
     saveEntityInMemory(entity: Entity): boolean;
     deleteEntityInMemory(entity: Entity): boolean;
     getEntitiesInMemory(): Entity[];
 }
-export declare const _EntityHandler_: EntityHandler;
+export declare const EntityHandler: SingletonEntityHandler;
 export {};
 //# sourceMappingURL=EntityTasks.d.ts.map