@block_factory/lib 0.0.2 → 0.0.3

package/index.d.ts

@@ -3,10 +3,29 @@ import { Signal } from "./util/Signal";
 import { Vec2, Vec3 } from "./util/Vector";
 import { RawText } from "./util/RawText";
 import { Command } from "./util/Command";
-import { Form } from "./util/Form";
-import { ActionFormCtor, IButtonOptions, IActionFormResponse, IActionFormData } from "./util/FormAction";
+import { System } from "./util/System";
 
-export { MathUtils, Signal, Vec2, Vec3, RawText, Command, Form, ActionFormCtor, IButtonOptions, IActionFormResponse, IActionFormData }
+import { IForm, IFormValue } from "./util/Forms/Form";
+import { ActionFormCtor, IButtonOptions, IActionFormResponse, IActionFormData } from "./util/Forms/FormAction";
+import { IModalFormResponse,ITextFieldOptions, IDropdownOptions, ISliderOptions, IToggleOptions, IModalFormData } from "./util/Forms/FormModal";
+import { IMessageFormData, IMessageFormResponse } from "./util/Forms/FormMessage";
+import { IFormRegistration, RegisterForm } from "./util/Forms/FormRegistry";
+
+import { Inventory, ContainerWrapper } from "./util/Wrapper/Container";
+import { IEntity, IEntityWrapper } from "./util/Wrapper/IEntity";
+import { IPlayer, IPlayerWrapper } from "./util/Wrapper/IPlayer";
+
+import { _THREAD_ } from "./sys/Threads";
+
+export { 
+    MathUtils, Signal, Vec2, Vec3, RawText, Command, System,
+    IForm, IFormValue,
+    ActionFormCtor, IButtonOptions, IActionFormResponse, IActionFormData,
+    IModalFormResponse, ITextFieldOptions, IDropdownOptions, ISliderOptions, IToggleOptions, IModalFormData,
+    IMessageFormData, IMessageFormResponse,
+    IFormRegistration, RegisterForm,
+    Inventory, ContainerWrapper, IEntity, IEntityWrapper, IPlayer, IPlayerWrapper, _THREAD_
+}
 
 export declare const BlockFactory: {
     MathUtils: typeof MathUtils;
@@ -15,6 +34,14 @@ export declare const BlockFactory: {
     Vec3: typeof Vec3;
     RawText: typeof RawText;
     Command: typeof Command;
-    Form: typeof Form;
+    System: typeof System;
+    IForm: typeof IForm;
     IActionFormData: typeof IActionFormData;
+    IModalFormData: typeof IModalFormData;
+    IMessageFormData: typeof IMessageFormData;
+    RegisterForm: typeof RegisterForm;
+    ContainerWrapper: typeof ContainerWrapper
+    IEntityWrapper: typeof IEntityWrapper
+    IPlayerWrapper: typeof IPlayerWrapper
+    _THREAD_: typeof _THREAD_;
 };

package/index.js

@@ -77,31 +77,23 @@ var Signal = class {
   constructor() {
     __publicField(this, "listeners", /* @__PURE__ */ new Set());
   }
-  /** Connect a listener */
+  get count() {
+    return this.listeners.size;
+  }
   connect(callback) {
     this.listeners.add(callback);
   }
-  /** Disconnect a listener */
   disconnect(callback) {
-    if (callback) {
-      this.listeners.delete(callback);
-      return true;
-    } else {
-      this.listeners.clear();
-      return false;
-    }
+    return this.listeners.delete(callback);
   }
-  /** Connect a listener that runs only once */
-  once(callback) {
-    const wrapper = (data) => {
-      this.disconnect(wrapper);
-      callback(data);
-    };
-    this.connect(wrapper);
+  clear() {
+    this.listeners.clear();
+  }
+  isConnected(callback) {
+    return this.listeners.has(callback);
   }
-  /** Emit signal to all listeners */
   emit(data) {
-    for (const cb of [...this.listeners]) {
+    for (const cb of Array.from(this.listeners)) {
       cb(data);
     }
   }
@@ -508,24 +500,60 @@ system.beforeEvents.startup.subscribe(
   }
 );
 
-// util/Form.ts
-var _Form = class _Form {
+// util/System.ts
+var System;
+((System2) => {
+  System2.ProxyConstructor = ((_instance, source) => {
+    return new Proxy(_instance, {
+      get: (target, prop) => {
+        if (prop in target) return target[prop];
+        const v = source[prop];
+        return typeof v === "function" ? v.bind(source) : v;
+      },
+      set: (target, prop, value) => {
+        if (prop in target) {
+          target[prop] = value;
+          return true;
+        }
+        source[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, prop)
+    });
+  });
+})(System || (System = {}));
+
+// util/Forms/Form.ts
+import { world } from "@minecraft/server";
+import { uiManager } from "@minecraft/server-ui";
+var _IForm = class _IForm {
   static isOccupied(player) {
-    return _Form.occupiedPlayers.has(player.id);
+    return _IForm.occupiedPlayers.has(player.id);
+  }
+  static closeForms(player) {
+    uiManager.closeAllForms(player);
+  }
+  static closeOccupiedForms() {
+    for (const playerId of _IForm.occupiedPlayers) {
+      const player = world.getEntity(playerId);
+      if (player) uiManager.closeAllForms(player);
+    }
   }
   setOccupied(player, occupied) {
-    if (occupied) _Form.occupiedPlayers.add(player.id);
-    else _Form.occupiedPlayers.delete(player.id);
+    if (occupied) _IForm.occupiedPlayers.add(player.id);
+    else _IForm.occupiedPlayers.delete(player.id);
   }
 };
-__publicField(_Form, "occupiedPlayers", /* @__PURE__ */ new Set());
-__publicField(_Form, "returnText", "Back");
-var Form = _Form;
+__publicField(_IForm, "occupiedPlayers", /* @__PURE__ */ new Set());
+__publicField(_IForm, "returnText", "Back");
+var IForm = _IForm;
 
-// util/FormAction.ts
+// util/Forms/FormAction.ts
 import { ActionFormData } from "@minecraft/server-ui";
 var RETURN_ID = "d7213196-4cb6-4199-a40b-22fbf2d944ef";
-var IActionFormData = class extends Form {
+var IActionFormData = class extends IForm {
   constructor() {
     super(...arguments);
     __publicField(this, "form", new ActionFormData());
@@ -568,7 +596,7 @@ var IActionFormData = class extends Form {
     return this;
   }
   async show(player) {
-    if (Form.isOccupied(player)) {
+    if (IForm.isOccupied(player)) {
       throw new Error(`Player ${player.id} is already occupied by form: ${this._id}`);
     }
     this.setOccupied(player, true);
@@ -595,7 +623,7 @@ var IActionFormData = class extends Form {
     this._nextButtonIndex = 0;
     this.build(player);
     if (returnStack.length > 0) {
-      this.form.button(Form.returnText);
+      this.form.button(IForm.returnText);
       this._buttons.set(this._nextButtonIndex, {
         id: RETURN_ID,
         subForm: returnStack[returnStack.length - 1],
@@ -628,6 +656,302 @@ var IActionFormData = class extends Form {
   }
 };
 
+// util/Forms/FormModal.ts
+import {
+  ModalFormData
+} from "@minecraft/server-ui";
+var IModalFormData = class extends IForm {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "form", new ModalFormData());
+    __publicField(this, "_id", "untitled");
+    __publicField(this, "_widgetMeta", []);
+  }
+  title(titleText) {
+    this.form.title(titleText);
+    this._id = typeof titleText === "string" ? titleText : JSON.stringify(titleText);
+    return this;
+  }
+  divider() {
+    this.form.divider();
+    return this;
+  }
+  header(text) {
+    this.form.header(text);
+    return this;
+  }
+  label(text) {
+    this.form.label(text);
+    return this;
+  }
+  textField(label, options) {
+    const opts = { defaultValue: options.defaultValue };
+    this.form.textField(label, options.placeholder, opts);
+    this._widgetMeta.push({ type: "textField", id: options.id });
+    return this;
+  }
+  dropdown(label, options) {
+    const opts = { defaultValueIndex: options.defaultValueIndex };
+    this.form.dropdown(label, options.choices, opts);
+    this._widgetMeta.push({ type: "dropdown", id: options.id });
+    return this;
+  }
+  slider(label, options) {
+    const opts = {
+      defaultValue: options.defaultValue,
+      valueStep: options.step
+    };
+    this.form.slider(label, options.min, options.max, opts);
+    this._widgetMeta.push({ type: "slider", id: options.id });
+    return this;
+  }
+  toggle(label, options) {
+    const opts = { defaultValue: options.defaultValue };
+    this.form.toggle(label, opts);
+    this._widgetMeta.push({ type: "toggle", id: options.id });
+    return this;
+  }
+  async show(player) {
+    if (IForm.isOccupied(player)) {
+      throw new Error(`Player ${player.id} is already occupied by form: ${this._id}`);
+    }
+    this.setOccupied(player, true);
+    try {
+      return await this._showInternal(player);
+    } finally {
+      this.setOccupied(player, false);
+    }
+  }
+  _wrapResponse(res, values) {
+    return {
+      canceled: res.canceled,
+      cancelationReason: res.cancelationReason,
+      formValues: res.formValues,
+      widget: values
+    };
+  }
+  _mapValues(formValues) {
+    if (!formValues) return void 0;
+    const out = /* @__PURE__ */ new Map();
+    for (let i = 0; i < formValues.length; i++) {
+      const meta = this._widgetMeta[i];
+      if (!meta) continue;
+      out.set(meta.id, formValues[i]);
+    }
+    return out;
+  }
+  async _showInternal(player) {
+    this.form = new ModalFormData();
+    this._widgetMeta = [];
+    this.build(player);
+    const res = await this.form.show(player);
+    if (res.canceled) {
+      const wrapped2 = this._wrapResponse(res);
+      this.onCancel?.(player, wrapped2);
+      return wrapped2;
+    }
+    const values = this._mapValues(res.formValues);
+    const wrapped = this._wrapResponse(res, values);
+    this.onSubmit(player, wrapped);
+    return wrapped;
+  }
+};
+
+// util/Forms/FormMessage.ts
+import {
+  MessageFormData
+} from "@minecraft/server-ui";
+var IMessageFormData = class extends IForm {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "form", new MessageFormData());
+    __publicField(this, "_id", "untitled");
+  }
+  title(titleText) {
+    this.form.title(titleText);
+    this._id = typeof titleText === "string" ? titleText : JSON.stringify(titleText);
+    return this;
+  }
+  body(bodyText) {
+    this.form.body(bodyText);
+    return this;
+  }
+  button0(text, id = 0) {
+    this.form.button1(text);
+    return this;
+  }
+  button1(text, id = 1) {
+    this.form.button2(text);
+    return this;
+  }
+  async show(player) {
+    if (IForm.isOccupied(player)) {
+      throw new Error(
+        `Player ${player.id} is already occupied by form: ${this._id}`
+      );
+    }
+    this.setOccupied(player, true);
+    try {
+      return await this._showInternal(player);
+    } finally {
+      this.setOccupied(player, false);
+    }
+  }
+  async _showInternal(player) {
+    this.form = new MessageFormData();
+    this.build(player);
+    const res = await this.form.show(player);
+    if (res.canceled || res.selection === void 0) {
+      this.onCancel?.(player, res);
+      return res;
+    }
+    this.onSubmit(player, res);
+    return res;
+  }
+};
+
+// util/Forms/FormRegistry.ts
+import { Player as Player2, world as world2 } from "@minecraft/server";
+var registeredForms = [];
+function RegisterForm(itemId) {
+  return function(formCtor) {
+    const i = registeredForms.findIndex((r) => r.itemId === itemId);
+    if (i !== -1) registeredForms[i] = { itemId, formCtor };
+    else registeredForms.push({ itemId, formCtor });
+  };
+}
+function getFormForItem(itemId) {
+  return registeredForms.find((r) => r.itemId === itemId)?.formCtor;
+}
+world2.afterEvents.itemUse.subscribe((event) => {
+  const player = event.source;
+  if (!(player instanceof Player2)) return;
+  const item = event.itemStack;
+  if (!item) return;
+  const formCtor = getFormForItem(item.typeId);
+  if (!formCtor) return;
+  const form = new formCtor();
+  form.show(player).catch((e) => {
+    player.sendMessage(`\xA7cForm error: ${String(e)}`);
+  });
+});
+
+// util/Wrapper/Container.ts
+var ContainerWrapper = class _ContainerWrapper {
+  constructor(source) {
+    __publicField(this, "source");
+    this.source = source;
+    return System.ProxyConstructor(this, source);
+  }
+  static wrap(source) {
+    return new _ContainerWrapper(source);
+  }
+  //======================== Interal ========================
+  reduce(slot, amount = 1) {
+    let itemStack = this.source.getItem(slot);
+    let currentAmount = itemStack?.amount || 0;
+    currentAmount -= amount;
+    if (itemStack != void 0 && currentAmount > 0) {
+      const newItemStack = itemStack;
+      newItemStack.amount = currentAmount;
+      itemStack = newItemStack;
+    } else itemStack = void 0;
+    this.source.setItem(slot, itemStack);
+  }
+};
+
+// util/Wrapper/IEntity.ts
+import { EntityInventoryComponent } from "@minecraft/server";
+var IEntityWrapper = class _IEntityWrapper {
+  constructor(source) {
+    __publicField(this, "source");
+    //======================== Interal ========================
+    __publicField(this, "isAlive", false);
+    this.source = source;
+    return System.ProxyConstructor(this, source);
+  }
+  static wrap(source) {
+    return new _IEntityWrapper(source);
+  }
+  get inventory() {
+    const i = this.source.getComponent(
+      EntityInventoryComponent.componentId
+    );
+    return ContainerWrapper.wrap(i.container);
+  }
+  test() {
+  }
+};
+
+// util/Wrapper/IPlayer.ts
+import { EntityInventoryComponent as EntityInventoryComponent2 } from "@minecraft/server";
+var IPlayerWrapper = class _IPlayerWrapper {
+  constructor(source) {
+    __publicField(this, "source");
+    //======================== Interal ========================
+    __publicField(this, "isAlive", false);
+    this.source = source;
+    return System.ProxyConstructor(this, source);
+  }
+  static wrap(player) {
+    return new _IPlayerWrapper(player);
+  }
+  get inventory() {
+    const i = this.source.getComponent(
+      EntityInventoryComponent2.componentId
+    );
+    return ContainerWrapper.wrap(i.container);
+  }
+  test() {
+    this.source.sendMessage(`${this.source.name} was tested`);
+  }
+};
+
+// sys/Threads.ts
+import { system as system2, TicksPerSecond } from "@minecraft/server";
+var Threads = class _Threads {
+  constructor() {
+    __publicField(this, "MAIN", new Signal());
+    __publicField(this, "LATE", new Signal());
+    __publicField(this, "MAIN_INTERVAL_RATE", 0);
+    __publicField(this, "LATE_INTERVAL_RATE", TicksPerSecond);
+    __publicField(this, "_MAIN_ID");
+    __publicField(this, "_LATE_ID");
+    __publicField(this, "_delta", this.createDeltaTimer());
+    this._MAIN_ID = system2.runInterval(() => {
+      if (this.MAIN.count <= 0) return;
+      try {
+        const delta = this._delta();
+        this.MAIN.emit(delta);
+      } catch (error) {
+        throw Error(`ERROR: _THREAD_.MAIN:${this._MAIN_ID} | ${error}`);
+      }
+    }, this.MAIN_INTERVAL_RATE);
+    this._LATE_ID = system2.runInterval(() => {
+      if (this.LATE.count <= 0) return;
+      try {
+        this.LATE.emit();
+      } catch (error) {
+        throw Error(`ERROR: _THREAD_.LATE:${this._LATE_ID} | ${error}`);
+      }
+    }, this.LATE_INTERVAL_RATE);
+  }
+  static create() {
+    return new _Threads();
+  }
+  createDeltaTimer() {
+    let last = Date.now();
+    return function nextDelta() {
+      const now = Date.now();
+      const delta = (now - last) / 1e3;
+      last = now;
+      return delta;
+    };
+  }
+};
+var _THREAD_ = Threads.create();
+_THREAD_.MAIN_INTERVAL_RATE = 10;
+
 // index.ts
 var BlockFactory;
 ((BlockFactory2) => {
@@ -637,17 +961,33 @@ var BlockFactory;
   Vec3;
   RawText;
   Command;
-  Form;
+  System;
+  IForm;
   IActionFormData;
+  IModalFormData;
+  IMessageFormData;
+  RegisterForm;
+  ContainerWrapper;
+  IEntityWrapper;
+  IPlayerWrapper;
+  _THREAD_;
 })(BlockFactory || (BlockFactory = {}));
 export {
   BlockFactory,
   Command,
-  Form,
+  ContainerWrapper,
   IActionFormData,
+  IEntityWrapper,
+  IForm,
+  IMessageFormData,
+  IModalFormData,
+  IPlayerWrapper,
   MathUtils,
   RawText,
+  RegisterForm,
   Signal,
+  System,
   Vec2,
-  Vec3
+  Vec3,
+  _THREAD_
 };

package/index.ts

@@ -3,11 +3,30 @@ import { Signal } from "./util/Signal";
 import { Vec2, Vec3 } from "./util/Vector";
 import { RawText } from "./util/RawText";
 import { Command } from "./util/Command";
-import { Form } from "./util/Form";
-import { ActionFormCtor, IButtonOptions, IActionFormResponse, IActionFormData } from "./util/FormAction";
+import { System } from "./util/System";
 
-export { MathUtils, Signal, Vec2, Vec3, RawText, Command, Form, ActionFormCtor, IButtonOptions, IActionFormResponse, IActionFormData };
+import { IForm, IFormValue } from "./util/Forms/Form";
+import { ActionFormCtor, IButtonOptions, IActionFormResponse, IActionFormData } from "./util/Forms/FormAction";
+import { IModalFormResponse, ITextFieldOptions, IDropdownOptions, ISliderOptions, IToggleOptions, IModalFormData } from "./util/Forms/FormModal";
+import { IMessageFormData, IMessageFormResponse } from "./util/Forms/FormMessage";
+import { IFormRegistration, RegisterForm } from "./util/Forms/FormRegistry";
 
+import { Inventory, ContainerWrapper } from "./util/Wrapper/Container";
+import { IEntity, IEntityWrapper } from "./util/Wrapper/IEntity";
+import { IPlayer, IPlayerWrapper } from "./util/Wrapper/IPlayer";
+
+import { _THREAD_ } from "./sys/Threads";
+
+export {
+    MathUtils, Signal, Vec2, Vec3, RawText, Command, System,
+    IForm, IFormValue,
+    ActionFormCtor, IButtonOptions, IActionFormResponse, IActionFormData,
+    IModalFormResponse, ITextFieldOptions, IDropdownOptions, ISliderOptions, IToggleOptions, IModalFormData,
+    IMessageFormData, IMessageFormResponse,
+    IFormRegistration, RegisterForm,
+    Inventory, ContainerWrapper, IEntity, IEntityWrapper, IPlayer, IPlayerWrapper,
+    _THREAD_
+};
 
 export namespace BlockFactory {
     MathUtils;
@@ -16,6 +35,14 @@ export namespace BlockFactory {
     Vec3;
     RawText;
     Command;
-    Form;
+    System;
+    IForm;
     IActionFormData;
+    IModalFormData;
+    IMessageFormData;
+    RegisterForm;
+    ContainerWrapper;
+    IEntityWrapper;
+    IPlayerWrapper
+    _THREAD_;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@block_factory/lib",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "main": "index.js",
   "types": "index.d.ts",
   "description": "Typescript Library for Minecraft Bedrock Edition",
@@ -27,6 +27,7 @@
     "esbuild": "^0.27.2"
   },
   "scripts": {
-    "build": "node esbuild.config.mjs"
+    "build": "node esbuild.config.mjs",
+    "build:types": "tsc -p tsconfig.types.json"
   }
 }

package/sys/Threads.d.ts

@@ -0,0 +1,16 @@
+import { Signal } from "../util/Signal";
+declare class Threads {
+    static create(): Threads;
+    readonly MAIN: Signal<number>;
+    readonly LATE: Signal<void>;
+    MAIN_INTERVAL_RATE: number;
+    LATE_INTERVAL_RATE: number;
+    private _MAIN_ID;
+    private _LATE_ID;
+    private _delta;
+    private constructor();
+    private createDeltaTimer;
+}
+export declare const _THREAD_: Threads;
+export {};
+//# sourceMappingURL=Threads.d.ts.map

package/sys/Threads.ts

@@ -0,0 +1,43 @@
+import { system, TicksPerSecond } from "@minecraft/server";
+import { Signal } from "../util/Signal";
+
+class Threads {
+    public static create(): Threads { return new Threads() }
+    public readonly MAIN = new Signal<number>();
+    public readonly LATE = new Signal();
+    public MAIN_INTERVAL_RATE: number = 0;
+    public LATE_INTERVAL_RATE: number = TicksPerSecond;
+
+    private _MAIN_ID: number;
+    private _LATE_ID: number;
+    private _delta = this.createDeltaTimer();
+
+    private constructor() {
+        this._MAIN_ID = system.runInterval(() => {
+            if (this.MAIN.count <= 0) return;
+            try { const delta = this._delta(); this.MAIN.emit(delta) }
+            catch (error) {
+                throw Error(`ERROR: _THREAD_.MAIN:${this._MAIN_ID} | ${error}`)
+            }
+        }, this.MAIN_INTERVAL_RATE);
+
+        this._LATE_ID = system.runInterval(() => {
+            if (this.LATE.count <= 0) return;
+            try { this.LATE.emit() }
+            catch (error) { throw Error(`ERROR: _THREAD_.LATE:${this._LATE_ID} | ${error}`) }
+        }, this.LATE_INTERVAL_RATE);
+    }
+
+    private createDeltaTimer() {
+        let last = Date.now();
+
+        return function nextDelta(): number {
+            const now = Date.now();
+            const delta = (now - last) / 1000; // seconds
+            last = now;
+            return delta;
+        };
+    }
+}
+
+export const _THREAD_ = Threads.create();

package/tsconfig.types.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "emitDeclarationOnly": true,
+    "noEmit": false,
+    "outDir": "dist",
+    "rootDir": ".",
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/util/Forms/Form.d.ts

@@ -0,0 +1,16 @@
+import { Player, RawMessage } from "@minecraft/server";
+
+export declare type IFormValue =
+    | string
+    | boolean
+    | number
+    | undefined;
+
+export declare abstract class IForm {
+    static returnText: RawMessage | string;
+    static isOccupied(player: Player): boolean;
+    static closeForms(player: Player): void;
+    static closeOccupiedForms(): void;
+    protected setOccupied(player: Player, occupied: boolean): void;
+    protected abstract build(player: Player): void;
+}