@block_factory/lib 0.0.1 → 0.0.3

package/index.d.ts

@@ -3,8 +3,29 @@ import { Signal } from "./util/Signal";
 import { Vec2, Vec3 } from "./util/Vector";
 import { RawText } from "./util/RawText";
 import { Command } from "./util/Command";
+import { System } from "./util/System";
 
-export { MathUtils, Signal, Vec2, Vec3, RawText, Command }
+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;
@@ -13,4 +34,14 @@ export declare const BlockFactory: {
     Vec3: typeof Vec3;
     RawText: typeof RawText;
     Command: typeof Command;
+    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);
     }
   }
@@ -480,8 +472,11 @@ var Command;
 ((Command2) => {
   class ICustomCommand {
     constructor() {
+      /** Whether cheats must be enabled */
       __publicField(this, "cheatsRequired");
+      /** Required command parameters */
       __publicField(this, "mandatoryParameters");
+      /** Optional command parameters */
       __publicField(this, "optionalParameters");
     }
   }
@@ -505,6 +500,458 @@ system.beforeEvents.startup.subscribe(
   }
 );
 
+// 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 _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) _IForm.occupiedPlayers.add(player.id);
+    else _IForm.occupiedPlayers.delete(player.id);
+  }
+};
+__publicField(_IForm, "occupiedPlayers", /* @__PURE__ */ new Set());
+__publicField(_IForm, "returnText", "Back");
+var IForm = _IForm;
+
+// util/Forms/FormAction.ts
+import { ActionFormData } from "@minecraft/server-ui";
+var RETURN_ID = "d7213196-4cb6-4199-a40b-22fbf2d944ef";
+var IActionFormData = class extends IForm {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "form", new ActionFormData());
+    __publicField(this, "_buttons", /* @__PURE__ */ new Map());
+    __publicField(this, "_nextButtonIndex", 0);
+    __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;
+  }
+  divider() {
+    this.form.divider();
+    return this;
+  }
+  header(text) {
+    this.form.header(text);
+    return this;
+  }
+  label(text) {
+    this.form.label(text);
+    return this;
+  }
+  button(text, options = {}) {
+    if (options.iconPath) this.form.button(text, options.iconPath);
+    else this.form.button(text);
+    const id = options.id ?? this._nextButtonIndex;
+    const allowReturn = options.allowReturn ?? true;
+    this._buttons.set(this._nextButtonIndex, {
+      id,
+      subForm: options.subForm,
+      allowReturn
+    });
+    this._nextButtonIndex++;
+    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 _showChained(player, returnStack) {
+    return await this._showInternal(player, returnStack);
+  }
+  _wrapResponse(response, id) {
+    return {
+      canceled: response.canceled,
+      cancelationReason: response.cancelationReason,
+      selection: response.selection,
+      id
+    };
+  }
+  async _showInternal(player, returnStack) {
+    this.form = new ActionFormData();
+    this._buttons.clear();
+    this._nextButtonIndex = 0;
+    this.build(player);
+    if (returnStack.length > 0) {
+      this.form.button(IForm.returnText);
+      this._buttons.set(this._nextButtonIndex, {
+        id: RETURN_ID,
+        subForm: returnStack[returnStack.length - 1],
+        allowReturn: true
+      });
+      this._nextButtonIndex++;
+    }
+    const response = await this.form.show(player);
+    if (response.canceled) {
+      const wrapped2 = this._wrapResponse(response, void 0);
+      this.onCancel?.(player, wrapped2);
+      return wrapped2;
+    }
+    const meta = response.selection !== void 0 ? this._buttons.get(response.selection) : void 0;
+    if (meta?.id === RETURN_ID && meta.subForm) {
+      const prevCtor = returnStack[returnStack.length - 1];
+      const newStack = returnStack.slice(0, -1);
+      const prev = new prevCtor();
+      return await prev._showChained(player, newStack);
+    }
+    const wrapped = this._wrapResponse(response, meta?.id);
+    this.onSubmit(player, wrapped);
+    if (meta?.subForm) {
+      const next = new meta.subForm();
+      const allowReturn = meta.allowReturn ?? true;
+      const nextStack = allowReturn ? [...returnStack, this.constructor] : [...returnStack];
+      return await next._showChained(player, nextStack);
+    }
+    return wrapped;
+  }
+};
+
+// 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) => {
@@ -514,13 +961,33 @@ var BlockFactory;
   Vec3;
   RawText;
   Command;
+  System;
+  IForm;
+  IActionFormData;
+  IModalFormData;
+  IMessageFormData;
+  RegisterForm;
+  ContainerWrapper;
+  IEntityWrapper;
+  IPlayerWrapper;
+  _THREAD_;
 })(BlockFactory || (BlockFactory = {}));
 export {
   BlockFactory,
   Command,
+  ContainerWrapper,
+  IActionFormData,
+  IEntityWrapper,
+  IForm,
+  IMessageFormData,
+  IModalFormData,
+  IPlayerWrapper,
   MathUtils,
   RawText,
+  RegisterForm,
   Signal,
+  System,
   Vec2,
-  Vec3
+  Vec3,
+  _THREAD_
 };

package/index.ts

@@ -3,8 +3,30 @@ import { Signal } from "./util/Signal";
 import { Vec2, Vec3 } from "./util/Vector";
 import { RawText } from "./util/RawText";
 import { Command } from "./util/Command";
+import { System } from "./util/System";
 
-export { MathUtils, Signal, Vec2, Vec3, RawText, Command }
+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;
@@ -13,4 +35,14 @@ export namespace BlockFactory {
     Vec3;
     RawText;
     Command;
+    System;
+    IForm;
+    IActionFormData;
+    IModalFormData;
+    IMessageFormData;
+    RegisterForm;
+    ContainerWrapper;
+    IEntityWrapper;
+    IPlayerWrapper
+    _THREAD_;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@block_factory/lib",
-  "version": "0.0.1",
+  "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