@block_factory/lib 0.0.2 → 0.0.4

package/_module/BlockFactory.ts

@@ -0,0 +1,18 @@
+export { MathUtils } from "./util/Math";
+export { Signal } from "./util/Signal";
+export { Vec2, Vec3 } from "./util/Vector";
+export { RawText } from "./util/RawText";
+export { Command } from "./util/Command";
+export { System } from "./util/System";
+
+export { IForm, IFormValue } from "./util/Forms/Form";
+export { ActionFormCtor, type IButtonOptions, type IActionFormResponse, type IActionFormData } from "./util/Forms/FormAction";
+export { type IModalFormResponse, type ITextFieldOptions, type IDropdownOptions, type ISliderOptions, type IToggleOptions, type IModalFormData } from "./util/Forms/FormModal";
+export { type IMessageFormData, type IMessageFormResponse } from "./util/Forms/FormMessage";
+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 { _THREAD_ } from "./sys/Threads";

package/_module/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/_module/util/Forms/Form.ts

@@ -0,0 +1,31 @@
+import { Player, RawMessage, world } from "@minecraft/server";
+import { uiManager } from "@minecraft/server-ui";
+
+export declare type IFormValue = string | boolean | number | undefined;
+
+export abstract class IForm {
+    private static readonly occupiedPlayers: Set<string> = new Set();
+    public static returnText: RawMessage | string = "Back";
+
+    public static isOccupied(player: Player): boolean {
+        return IForm.occupiedPlayers.has(player.id);
+    }
+
+    public static closeForms(player: Player): void {
+        uiManager.closeAllForms(player);
+    }
+
+    public static closeOccupiedForms(): void {
+        for (const playerId of IForm.occupiedPlayers) {
+            const player = world.getEntity(playerId) as Player | undefined;
+            if (player) uiManager.closeAllForms(player);
+        }
+    }
+
+    protected setOccupied(player: Player, occupied: boolean): void {
+        if (occupied) IForm.occupiedPlayers.add(player.id);
+        else IForm.occupiedPlayers.delete(player.id);
+    }
+
+    protected abstract build(player: Player): void;
+}

package/{util → _module/util/Forms}/FormAction.ts

@@ -1,4 +1,4 @@
-import { Form } from "@block_factory/lib/util/Form";
+import { IForm } from "./Form";
 import { Player, RawMessage } from "@minecraft/server";
 import { ActionFormData, ActionFormResponse, FormCancelationReason } from "@minecraft/server-ui";
 
@@ -47,24 +47,13 @@ type ButtonMeta = {
  * Normalized response object returned by IActionFormData.
  */
 export interface IActionFormResponse {
-    /**
-     * Reason the form was canceled, if applicable.
-     */
+    /**Reason the form was canceled, if applicable.*/
     readonly cancelationReason?: FormCancelationReason;
-
-    /**
-     * Whether the form was canceled by the player.
-     */
+    /** Whether the form was canceled by the player.*/
     readonly canceled: boolean;
-
-    /**
-     * Raw button index selected by the player.
-     */
+    /**Raw button index selected by the player.*/
     readonly selection?: number;
-
-    /**
-     * Logical button id associated with the selection.
-     */
+    /**Logical button id associated with the selection.*/
     readonly id?: string | number;
 }
 
@@ -77,7 +66,7 @@ export interface IActionFormResponse {
  * - Sub-form chaining with automatic Back navigation
  * - Normalized response objects
  */
-export abstract class IActionFormData extends Form {
+export abstract class IActionFormData extends IForm {
     protected form: ActionFormData = new ActionFormData();
 
     private _buttons = new Map<number, ButtonMeta>();
@@ -86,7 +75,7 @@ export abstract class IActionFormData extends Form {
 
     protected abstract build(player: Player): void;
 
-    protected abstract onSubmit( player: Player, response: IActionFormResponse): void;
+    protected abstract onSubmit(player: Player, response: IActionFormResponse): void;
 
     protected onCancel?(player: Player, response: IActionFormResponse): void;
 
@@ -96,13 +85,13 @@ export abstract class IActionFormData extends Form {
         return this;
     }
 
-    public body(bodyText: RawMessage | string): this { this.form.body(bodyText); return this;}
+    public body(bodyText: RawMessage | string): this { this.form.body(bodyText); return this; }
 
-    public divider(): this { this.form.divider(); return this;}
+    public divider(): this { this.form.divider(); return this; }
 
-    public header(text: RawMessage | string): this { this.form.header(text); return this;}
+    public header(text: RawMessage | string): this { this.form.header(text); return this; }
 
-    public label(text: RawMessage | string): this { this.form.label(text); return this;}
+    public label(text: RawMessage | string): this { this.form.label(text); return this; }
 
     public button(text: RawMessage | string, options: IButtonOptions = {}): this {
         if (options.iconPath) this.form.button(text, options.iconPath);
@@ -122,7 +111,7 @@ export abstract class IActionFormData extends Form {
     }
 
     public async show(player: Player): Promise<IActionFormResponse> {
-        if (Form.isOccupied(player)) {
+        if (IForm.isOccupied(player)) {
             throw new Error(`Player ${player.id} is already occupied by form: ${this._id}`);
         }
 
@@ -135,11 +124,11 @@ export abstract class IActionFormData extends Form {
         }
     }
 
-    protected async _showChained(player: Player,returnStack: ActionFormCtor[]): Promise<IActionFormResponse> {
+    protected async _showChained(player: Player, returnStack: ActionFormCtor[]): Promise<IActionFormResponse> {
         return await this._showInternal(player, returnStack);
     }
 
-    private _wrapResponse(response: ActionFormResponse,id?: string | number): IActionFormResponse {
+    private _wrapResponse(response: ActionFormResponse, id?: string | number): IActionFormResponse {
         return {
             canceled: response.canceled,
             cancelationReason: response.cancelationReason,
@@ -158,7 +147,7 @@ export abstract class IActionFormData extends Form {
         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],

package/_module/util/Forms/FormMessage.ts

@@ -0,0 +1,87 @@
+import { IForm } from "./Form";
+import { Player, RawMessage } from "@minecraft/server";
+import {
+    MessageFormData,
+    MessageFormResponse,
+} from "@minecraft/server-ui";
+
+/**
+ * Abstract base class for MessageFormData.
+ *
+ * Provides:
+ * - occupied player handling
+ */
+
+export type IMessageFormResponse = MessageFormResponse; // re-export wrapper for consistency
+
+export abstract class IMessageFormData extends IForm {
+    protected form: MessageFormData = new MessageFormData();
+
+    private _id: string = "untitled";
+
+    protected abstract build(player: Player): void;
+
+    protected abstract onSubmit(
+        player: Player,
+        response: IMessageFormResponse
+    ): void;
+
+    protected onCancel?(player: Player, response: IMessageFormResponse): void;
+
+    public title(titleText: RawMessage | string): this {
+        this.form.title(titleText);
+        this._id =
+            typeof titleText === "string"
+                ? titleText
+                : JSON.stringify(titleText);
+        return this;
+    }
+
+    public body(bodyText: RawMessage | string): this {
+        this.form.body(bodyText);
+        return this;
+    }
+    public button0(text: RawMessage | string,id: string | number = 0): this {
+        this.form.button1(text);
+        return this;
+    }
+
+    public button1(text: RawMessage | string,id: string | number = 1): this {
+        this.form.button2(text);
+        return this;
+    }
+
+    public async show(player: Player): Promise<IMessageFormResponse> {
+        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);
+        }
+    }
+
+    private async _showInternal(
+        player: Player
+    ): Promise<IMessageFormResponse> {
+        this.form = new MessageFormData();
+
+        this.build(player);
+
+        const res = await this.form.show(player);
+
+        if (res.canceled || res.selection === undefined) {
+            this.onCancel?.(player, res);
+            return res;
+        }
+
+        this.onSubmit(player, res);
+        return res;
+    }
+}

package/_module/util/Forms/FormModal.ts

@@ -0,0 +1,183 @@
+import { IForm } from "./Form";
+import { Player, RawMessage } from "@minecraft/server";
+import {
+    ModalFormData,
+    ModalFormResponse,
+    FormCancelationReason,
+    ModalFormDataDropdownOptions,
+    ModalFormDataSliderOptions,
+    ModalFormDataTextFieldOptions,
+    ModalFormDataToggleOptions,
+} from "@minecraft/server-ui";
+
+export type FormValue = string | boolean | number | undefined;
+
+/** Normalized response for Modal forms */
+export interface IModalFormResponse {
+    /**Reason the form was canceled, if applicable.*/
+    readonly cancelationReason?: FormCancelationReason;
+    /** Whether the form was canceled by the player.*/
+    readonly canceled: boolean;
+    /** Raw values array from the form */
+    readonly formValues?: FormValue[];
+    /** Mapped values by widget id */
+    readonly widget?: Map<string, FormValue>;
+}
+
+/** Options for each widget type */
+export interface ITextFieldOptions {
+    id: string;
+    placeholder: string | RawMessage;
+    defaultValue?: string;
+}
+export interface IDropdownOptions {
+    id: string;
+    choices: string[];
+    defaultValueIndex?: number;
+}
+export interface ISliderOptions {
+    id: string;
+    min: number;
+    max: number;
+    step: number;
+    defaultValue?: number;
+}
+export interface IToggleOptions {
+    id: string;
+    defaultValue?: boolean;
+}
+
+type WidgetMeta =
+    | { type: "textField"; id: string }
+    | { type: "dropdown"; id: string }
+    | { type: "slider"; id: string }
+    | { type: "toggle"; id: string };
+
+/**
+ * Abstract base class for ModalFormData-based menus.
+ *
+ * Provides:
+ * - Occupied player handling
+ * - Widget id mapping into a Map<string, FormValue>
+ * - Normalized response object
+ */
+export abstract class IModalFormData extends IForm {
+    protected form: ModalFormData = new ModalFormData();
+
+    private _id: string = "untitled";
+    private _widgetMeta: WidgetMeta[] = [];
+
+    protected abstract build(player: Player): void;
+
+    protected abstract onSubmit(player: Player, response: IModalFormResponse): void;
+
+    protected onCancel?(player: Player, response: IModalFormResponse): void;
+
+    public title(titleText: RawMessage | string): this {
+        this.form.title(titleText);
+        this._id = typeof titleText === "string" ? titleText : JSON.stringify(titleText);
+        return this;
+    }
+
+    public divider(): this {
+        this.form.divider();
+        return this;
+    }
+
+    public header(text: RawMessage | string): this {
+        this.form.header(text);
+        return this;
+    }
+
+    public label(text: RawMessage | string): this {
+        this.form.label(text);
+        return this;
+    }
+
+    public textField(label: string | RawMessage, options: ITextFieldOptions): this {
+        const opts: ModalFormDataTextFieldOptions = { defaultValue: options.defaultValue };
+        this.form.textField(label, options.placeholder, opts);
+        this._widgetMeta.push({ type: "textField", id: options.id });
+        return this;
+    }
+
+    public dropdown(label: string | RawMessage, options: IDropdownOptions): this {
+        const opts: ModalFormDataDropdownOptions = { defaultValueIndex: options.defaultValueIndex };
+        this.form.dropdown(label, options.choices, opts);
+        this._widgetMeta.push({ type: "dropdown", id: options.id });
+        return this;
+    }
+
+    public slider(label: string | RawMessage, options: ISliderOptions): this {
+        const opts: ModalFormDataSliderOptions = {
+            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;
+    }
+
+    public toggle(label: string | RawMessage, options: IToggleOptions): this {
+        const opts: ModalFormDataToggleOptions = { defaultValue: options.defaultValue };
+        this.form.toggle(label, opts);
+        this._widgetMeta.push({ type: "toggle", id: options.id });
+        return this;
+    }
+
+    public async show(player: Player): Promise<IModalFormResponse> {
+        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);
+        }
+    }
+
+    private _wrapResponse(res: ModalFormResponse, values?: Map<string, FormValue>): IModalFormResponse {
+        return {
+            canceled: res.canceled,
+            cancelationReason: res.cancelationReason,
+            formValues: res.formValues as FormValue[] | undefined,
+            widget: values,
+        };
+    }
+
+    private _mapValues(formValues: FormValue[] | undefined): Map<string, FormValue> | undefined {
+        if (!formValues) return undefined;
+
+        const out = new Map<string, FormValue>();
+        for (let i = 0; i < formValues.length; i++) {
+            const meta = this._widgetMeta[i];
+            if (!meta) continue;
+            out.set(meta.id, formValues[i]);
+        }
+        return out;
+    }
+
+    private async _showInternal(player: Player): Promise<IModalFormResponse> {
+        this.form = new ModalFormData();
+        this._widgetMeta = [];
+
+        this.build(player);
+
+        const res = await this.form.show(player);
+
+        if (res.canceled) {
+            const wrapped = this._wrapResponse(res);
+            this.onCancel?.(player, wrapped);
+            return wrapped;
+        }
+
+        const values = this._mapValues(res.formValues as FormValue[] | undefined);
+        const wrapped = this._wrapResponse(res, values);
+
+        this.onSubmit(player, wrapped);
+        return wrapped;
+    }
+}

package/_module/util/Forms/FormRegistry.ts

@@ -0,0 +1,43 @@
+import { ItemUseAfterEvent, Player, world } from "@minecraft/server";
+import { IActionFormData } from "./FormAction";
+import { IModalFormData } from "./FormModal";
+import { IMessageFormData } from "./FormMessage";
+
+type AnyShowableForm = IActionFormData | IModalFormData | IMessageFormData;
+type AnyShowableCtor = new () => AnyShowableForm;
+
+export interface IFormRegistration {
+    itemId: string;
+    formCtor: AnyShowableCtor;
+}
+
+const registeredForms: IFormRegistration[] = [];
+
+export function RegisterForm(itemId: string) {
+    return function <T extends AnyShowableCtor>(formCtor: T): void {
+        const i = registeredForms.findIndex(r => r.itemId === itemId);
+        if (i !== -1) registeredForms[i] = { itemId, formCtor };
+        else registeredForms.push({ itemId, formCtor });
+    };
+}
+
+function getFormForItem(itemId: string): AnyShowableCtor | undefined {
+    return registeredForms.find(r => r.itemId === itemId)?.formCtor;
+}
+
+world.afterEvents.itemUse.subscribe((event: ItemUseAfterEvent) => {
+    const player = event.source;
+    if (!(player instanceof Player)) 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(`§cForm error: ${String(e)}`);
+    });
+});

package/_module/util/RawText.ts

@@ -0,0 +1,75 @@
+import { RawMessage } from '@minecraft/server';
+
+/**
+ * Utility helpers for building rawtext messages.
+ */
+export class RawText {
+    /**
+     * Creates a simple text component.
+     * @param value - The text value.
+     * @returns Text component object.
+     */
+    public static text(value: string): RawMessage {
+        return { text: value };
+    }
+
+    /**
+     * Creates a translation component with optional 'with' parameters.
+     * @param key - The translation key.
+     * @param params - The optional parameters for translation.
+     * @returns Translation component object.
+     */
+    public static translate(key: string, ...params: string[]): RawMessage {
+        return {
+            translate: key,
+            with: params.length ? params : undefined
+        };
+    }
+
+    /**
+     * Creates a score component.
+     * @param name - The entity's name whose score is being displayed.
+     * @param objective - The name of the score objective.
+     * @returns Score component object.
+     */
+    public static score(name: string, objective: string): RawMessage {
+        return { score: { name, objective } };
+    }
+
+    /**
+     * Wraps various text components into a rawtext structure.
+     * @param rawText - The raw text components.
+     * @returns Raw text object.
+     */
+    public static message(...rawText: RawMessage[]): RawMessage {
+        return { rawtext: rawText };
+    }
+
+    /**
+     * Common formatting and color codes.
+     */
+    public static FORMAT = {
+        DarkRed: "§4",
+        Red: "§c",
+        Gold: "§6",
+        Yellow: "§e",
+        Green: "§2",
+        Lime: "§a",
+        Aqua: "§b",
+        Cyan: "§3",
+        DarkBlue: "§1",
+        Blue: "§9",
+        Magenta: "§d",
+        Purple: "§5",
+        White: "§f",
+        Gray: "§7",
+        DarkGray: "§8",
+        Black: "§0",
+        Obfuscated: "§k",
+        Bold: "§l",
+        StrikeThrough: "§m",
+        Italic: "§o",
+        Reset: "§r",
+        NewLine: "\n"
+    }
+}

package/_module/util/Signal.ts

@@ -0,0 +1,31 @@
+export type Callback<T> = (data: T) => void;
+
+export class Signal<T = void> {
+    private readonly listeners = new Set<Callback<T>>();
+
+    public get count(): number {
+        return this.listeners.size;
+    }
+
+    public connect(callback: Callback<T>): void {
+        this.listeners.add(callback);
+    }
+
+    public disconnect(callback: Callback<T>): boolean {
+        return this.listeners.delete(callback);
+    }
+
+    public clear(): void {
+        this.listeners.clear();
+    }
+
+    public isConnected(callback: Callback<T>): boolean {
+        return this.listeners.has(callback);
+    }
+
+    public emit(data: T): void {
+        for (const cb of Array.from(this.listeners)) {
+            cb(data);
+        }
+    }
+}

package/_module/util/System.ts

@@ -0,0 +1,21 @@
+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;
+    })
+}

package/_module/util/Wrapper/Container.ts

@@ -0,0 +1,34 @@
+import { Container, ItemStack} from "@minecraft/server";
+import { System } from "../System";
+
+export type Inventory = ContainerWrapper & Container;
+
+export class ContainerWrapper {
+   public readonly source: Container;
+
+    private constructor(source: Container) {
+        this.source = source;
+        return System.ProxyConstructor(this, source);
+    }
+
+    public static wrap(source: Container): Inventory {
+        return new ContainerWrapper(source) as Inventory;
+    }
+
+    //======================== Interal ========================
+    public reduce(slot: number, amount: number = 1) {
+        let itemStack: ItemStack | undefined = this.source.getItem(slot);
+        let currentAmount: number = itemStack?.amount || 0;
+        currentAmount -= amount;
+        
+        if (itemStack != undefined && currentAmount > 0) {
+            const newItemStack: ItemStack = itemStack;
+            newItemStack.amount = currentAmount;
+            itemStack = newItemStack
+
+        } else itemStack = undefined;
+
+        this.source.setItem(slot, itemStack);
+    }
+
+}