@block_factory/lib 0.0.5 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@block_factory/lib",
-  "version": "0.0.5",
+  "version": "0.0.8",
   "main": "index.js",
   "types": "index.d.ts",
   "description": "Typescript Library for Minecraft Bedrock Edition",
@@ -21,14 +21,20 @@
   },
   "homepage": "https://github.com/Block-Factory-Studio/bf-mcbr-library#readme",
   "dependencies": {
-    "@minecraft/server": "^2.4.0",
+    "@minecraft/server": "^2.5.0",
     "@minecraft/server-ui": "^2.0.0"
   },
   "devDependencies": {
-    "esbuild": "^0.25.9"
+    "esbuild": "^0.25.9",
+    "typedoc": "^0.28.17",
+    "typedoc-plugin-markdown": "^4.10.0"
+  },
+  "overrides": {
+    "minimatch": "^10.2.1"
   },
   "scripts": {
     "build": "node esbuild.config.mjs",
-    "build:types": "tsc -p tsconfig.types.json"
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:docs": "typedoc --options typedoc.json"
   }
 }

package/typedoc.json

@@ -0,0 +1,6 @@
+{
+  "entryPoints": ["./index.ts"],
+  "out": "docs",
+  "plugin": ["typedoc-plugin-markdown"],
+  "readme": "none"
+}

package/_module/Framework/EntityTasks.ts

@@ -1,203 +0,0 @@
-import {
-    Entity,
-    system,
-    ScriptEventCommandMessageAfterEvent,
-    ScriptEventCommandMessageAfterEventSignal,
-    world,
-    WorldLoadAfterEventSignal,
-    WorldLoadAfterEvent,
-    EntitySpawnAfterEventSignal,
-    EntityRemoveAfterEventSignal,
-    EntitySpawnAfterEvent,
-    EntityRemoveAfterEvent,
-    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 {
-    private PACK_ID: string | undefined;
-    private 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;");
-    }
-
-    public registerEntity(typeId: string | string[]): void {
-        if (Array.isArray(typeId)) typeId.forEach((t) => this.SEARCH_TYPES.add(t));
-        else this.SEARCH_TYPES.add(typeId);
-    }
-
-    public start(packId: string): void {
-        if (this._started) return;
-        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.scriptEventSignal.unsubscribe(this.processScriptEvents);
-            this.spawnEventSignal.unsubscribe(this.onEntitySpawned);
-            this.removeBeforeEventSignal.unsubscribe(this.onEntityRemovedBefore);
-            this.removeAfterEventSignal.unsubscribe(this.onEntityRemovedAfter);
-            this._wired = false;
-        }
-
-        this._started = false;
-    }
-
-    /* ------------------------------------------------------------------------ */
-    /* Event Wiring                                                             */
-    /* ------------------------------------------------------------------------ */
-
-    private onWorldLoad = (_event: WorldLoadAfterEvent): 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;
-        this.reloadEntityMemory();
-        this.loadEventSignal.unsubscribe(this.onWorldLoad);
-    };
-
-    private processScriptEvents = (event: ScriptEventCommandMessageAfterEvent): void => {
-        if (!event.sourceEntity) return;
-        if (event.id !== `${this.PACK_ID}:entity_emitter`) return;
-
-        let parms: any;
-        try {
-            parms = JSON.parse(event.message);
-        } catch (e) {
-            console.error(`BFLIB: entity_emitter JSON parse failed:`, e);
-            return;
-        }
-
-        onEntityEmission.emit({
-            iEntity: IEntityWrapper.wrap(event.sourceEntity),
-            parms,
-        });
-    };
-
-    /* ------------------------------------------------------------------------ */
-    /* Filters                                                                  */
-    /* ------------------------------------------------------------------------ */
-
-    private isValidType(typeId: string): boolean {
-        return this.SEARCH_TYPES.has(typeId);
-    }
-
-    private onEntitySpawned = (event: EntitySpawnAfterEvent): void => {
-        const entity = event.entity;
-        if (!this.isValidType(entity.typeId)) return;
-        this.saveEntityInMemory(entity);
-    };
-
-    private onEntityRemovedBefore = (event: EntityRemoveBeforeEvent): void => {
-        const entity = event.removedEntity;
-        if (!this.isValidType(entity.typeId)) return;
-        this.deleteEntityInMemory(entity);
-    };
-
-    private onEntityRemovedAfter = (_event: EntityRemoveAfterEvent): void => {
-        // 
-    };
-
-    /* ------------------------------------------------------------------------ */
-    /* Persistence                                                              */
-    /* ------------------------------------------------------------------------ */
-
-    private reloadEntityMemory(): void {
-        this.EM_INDEX.clear();
-        this.EM_KEYS.length = 0;
-
-        const raw = world.getDynamicProperty(this.GLOBAL_MEMORY_ID) as string | undefined;
-        if (!raw) return;
-
-        let parsed: string[];
-        try {
-            parsed = JSON.parse(raw) as string[];
-        } catch (e) {
-            console.error(`BFLIB: Failed to parse ${this.GLOBAL_MEMORY_ID}:`, e);
-            return;
-        }
-
-        for (const id of parsed) {
-            this.EM_KEYS.push(id);
-            const entity = world.getEntity(id);
-            if (entity) this.EM_INDEX.set(entity.id, entity);
-        }
-    }
-
-    private persistKeys(): void {
-        world.setDynamicProperty(this.GLOBAL_MEMORY_ID, JSON.stringify(this.EM_KEYS));
-    }
-
-    public saveEntityInMemory(entity: Entity): boolean {
-        if (this.EM_INDEX.has(entity.id)) return false;
-        this.EM_KEYS.push(entity.id);
-        this.EM_INDEX.set(entity.id, entity);
-        this.persistKeys();
-
-        return true;
-    }
-
-    public deleteEntityInMemory(entity: Entity): boolean {
-        const existed = this.EM_INDEX.delete(entity.id);
-        if (!existed) return false;
-
-        const idx = this.EM_KEYS.indexOf(entity.id);
-        if (idx !== -1) this.EM_KEYS.splice(idx, 1);
-
-        this.persistKeys();
-
-        return true;
-    }
-
-    public getEntitiesInMemory(): Entity[] {
-        return Array.from(this.EM_INDEX.values());
-    }
-}
-
-export const _EntityHandler_ = new EntityHandler();

package/_module/Framework/Threads.ts

@@ -1,72 +0,0 @@
-import { system, TicksPerSecond } from "@minecraft/server";
-import { Signal } from "../util/Signal";
-
-export type ThreadConfig = {
-    mainRate?: number; // interval ticks
-    lateRate?: number; // interval ticks
-};
-
-class Threads {
-    public readonly MAIN = new Signal<number>();
-    public readonly LATE = new Signal<void>();
-
-    private _mainRate = 0;
-    private _lateRate = TicksPerSecond;
-
-    private _MAIN_ID: number | undefined;
-    private _LATE_ID: number | undefined;
-
-    private _delta = this.createDeltaTimer();
-    private _started = false;
-
-    public configure(cfg: ThreadConfig) {
-        if (this._started) throw new Error("BFLIB: _THREAD_ already started; configure before start().");
-        if (cfg.mainRate !== undefined) this._mainRate = cfg.mainRate;
-        if (cfg.lateRate !== undefined) this._lateRate = cfg.lateRate;
-    }
-
-    public start() {
-        if (this._started) return; // idempotent
-        this._started = true;
-
-        this._MAIN_ID = system.runInterval(() => {
-            if (this.MAIN.count <= 0) return;
-            try {
-                const delta = this._delta();
-                this.MAIN.emit(delta);
-            } catch (e) {
-                console.error(`ERROR: _THREAD_.MAIN:${this._MAIN_ID} |`, e);
-            }
-        }, this._mainRate);
-
-        this._LATE_ID = system.runInterval(() => {
-            if (this.LATE.count <= 0) return;
-            try {
-                this.LATE.emit();
-            } catch (e) {
-                console.error(`ERROR: _THREAD_.LATE:${this._LATE_ID} |`, e);
-            }
-        }, this._lateRate);
-    }
-
-    public stop() {
-        if (this._MAIN_ID !== undefined) system.clearRun(this._MAIN_ID);
-        if (this._LATE_ID !== undefined) system.clearRun(this._LATE_ID);
-        this._MAIN_ID = undefined;
-        this._LATE_ID = undefined;
-        this._started = false;
-        this._delta = this.createDeltaTimer(); // reset delta timing
-    }
-
-    private createDeltaTimer() {
-        let last = Date.now();
-        return () => {
-            const now = Date.now();
-            const delta = (now - last) / 1000;
-            last = now;
-            return delta;
-        };
-    }
-}
-
-export const _THREAD_ = new Threads();

package/_module/Framework/_INIT.ts

@@ -1,39 +0,0 @@
-let IS_INITIALIZED: boolean = false
-let PACK_ID: string | undefined = undefined
-
-/* -------------------------------------------------------------------------- */
-/* Public API                                                                 */
-/* -------------------------------------------------------------------------- */
-
-/**
- * Initializes the Block Factory framework.
- *
- * This **must be called exactly once** before using any backend systems
- * such as threads, entity tasks, or event routing.
- *
- * @param packId - Unique identifier for the active pack instance.
- *
- * @throws Error if the framework has already been initialized.
- *
- * @example
- * ```ts
- * _INITIALIZE_BF_FRAMEWORK_("bf:utility_tools");
- * ```
- */
-export function _INITIALIZE_BF_FRAMEWORK_(packId: string): void {
-    if (IS_INITIALIZED) throw Error(`CONFLICT WARNING: ${PACK_ID} already initialized.`);
-    PACK_ID = packId; IS_INITIALIZED = true;
-    console.log("Block Factory Framework Loaded");
-}
-
-/* -------------------------------------------------------------------------- */
-/* Internal API                                                               */
-/* -------------------------------------------------------------------------- */
-
-export function getPackId(): string | undefined {
-    return PACK_ID;
-}
-
-export function isInitalized(): boolean {
-    return IS_INITIALIZED;
-}

package/_module/Types.ts

@@ -1,10 +0,0 @@
-export type Sound = {
-    id: string,
-    length: number
-}
-
-export type Animation = {
-    id: string,
-    length: number,
-    loop?: boolean,
-}

package/_module/util/System.ts

@@ -1,21 +0,0 @@
-export namespace System {
-    export const ProxyConstructor = ((_instance: any, source: any) => {
-        return new Proxy(_instance, {
-            get: (target, prop) => {
-                if (prop in target) return (target as any)[prop];
-                const v = (source as any)[prop];
-                return typeof v === "function" ? v.bind(source) : v;
-            },
-
-            set: (target, prop, value) => {
-                if (prop in target) { (target as any)[prop] = value; return true; }
-                (source as any)[prop] = value;
-                return true;
-            },
-
-            has: (target, prop) => prop in target || prop in source,
-            ownKeys: () => [...Reflect.ownKeys(source), ...Reflect.ownKeys(_instance)],
-            getOwnPropertyDescriptor: (_t, prop) => Object.getOwnPropertyDescriptor((prop in _instance ? _instance : source) as any, prop)
-        }) as any;
-    })
-}