@block_factory/lib 0.0.2 → 0.0.3

package/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/{FormAction.d.ts → Forms/FormAction.d.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, FormCancelationReason } from "@minecraft/server-ui";
 
@@ -18,7 +18,7 @@ export declare interface IActionFormResponse {
     readonly id?: string | number;
 }
 
-export declare abstract class IActionFormData extends Form {
+export declare abstract class IActionFormData extends IForm {
     protected form: ActionFormData;
 
     protected abstract build(player: Player): void;

package/util/{FormAction.ts → 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/util/Forms/FormMessage.d.ts

@@ -0,0 +1,30 @@
+import { IForm } from "./Form";
+import { Player, RawMessage } from "@minecraft/server";
+import { MessageFormData, MessageFormResponse } from "@minecraft/server-ui";
+
+export declare abstract class IMessageFormData extends IForm {
+    protected form: MessageFormData;
+
+    private _id: string;
+
+    protected abstract build(player: Player): void;
+
+    protected abstract onSubmit(
+        player: Player,
+        response: MessageFormResponse
+    ): void;
+
+    protected onCancel?(player: Player, response: MessageFormResponse): void;
+
+    title(titleText: RawMessage | string): this;
+
+    body(bodyText: RawMessage | string): this;
+
+    button0(text: RawMessage | string, id?: string | number): this;
+
+    button1(text: RawMessage | string, id?: string | number): this;
+
+    show(player: Player): Promise<MessageFormResponse>;
+
+    private _showInternal(player: Player): Promise<MessageFormResponse>;
+}

package/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/util/Forms/FormModal.d.ts

@@ -0,0 +1,57 @@
+import { IForm, IFormValue } from "./Form";
+import { Player, RawMessage } from "@minecraft/server";
+import { ModalFormData, FormCancelationReason } from "@minecraft/server-ui";
+
+export declare interface IModalFormResponse {
+    readonly cancelationReason?: FormCancelationReason;
+    readonly canceled: boolean;
+    readonly formValues?: IFormValue[];
+    readonly widget?: Map<string, IFormValue>;
+}
+
+export declare interface ITextFieldOptions {
+    id: string;
+    placeholder: string | RawMessage;
+    defaultValue?: string;
+}
+
+export declare interface IDropdownOptions {
+    id: string;
+    choices: string[];
+    defaultValueIndex?: number;
+}
+
+export declare interface ISliderOptions {
+    id: string;
+    min: number;
+    max: number;
+    step: number;
+    defaultValue?: number;
+}
+
+export declare interface IToggleOptions {
+    id: string;
+    defaultValue?: boolean;
+}
+
+export declare abstract class IModalFormData extends IForm {
+    protected form: ModalFormData;
+
+    protected abstract build(player: Player): void;
+
+    protected abstract onSubmit(player: Player, response: IModalFormResponse): void;
+
+    protected onCancel?(player: Player, response: IModalFormResponse): void;
+
+    title(titleText: RawMessage | string): this;
+    divider(): this;
+    header(text: RawMessage | string): this;
+    label(text: RawMessage | string): this;
+
+    textField(label: string | RawMessage, options: ITextFieldOptions): this;
+    dropdown(label: string | RawMessage, options: IDropdownOptions): this;
+    slider(label: string | RawMessage, options: ISliderOptions): this;
+    toggle(label: string | RawMessage, options: IToggleOptions): this;
+
+    show(player: Player): Promise<IModalFormResponse>;
+}

package/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/util/Forms/FormRegistry.d.ts

@@ -0,0 +1,26 @@
+import { IActionFormData } from "./FormAction";
+import { IModalFormData } from "./FormModal";
+import { IMessageFormData } from "./FormMessage";
+
+export type AnyShowableForm =
+    | IActionFormData
+    | IModalFormData
+    | IMessageFormData;
+
+export type AnyShowableCtor = new () => AnyShowableForm;
+
+export interface IFormRegistration {
+    itemId: string;
+    formCtor: AnyShowableCtor;
+}
+
+/**
+ * Decorator factory used to bind a form class to an itemId.
+ *
+ * Usage:
+ *   @RegisterForm("minecraft:stick")
+ *   export class MyForm extends IMessageFormData {}
+ */
+export declare function RegisterForm(
+    itemId: string
+): <T extends AnyShowableCtor>(formCtor: T) => void;

package/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/util/Signal.d.ts

@@ -1,9 +1,13 @@
 export type Callback<T = void> = (data: T) => void;
+
 export declare class Signal<T = void> {
-    private listeners;
+    private readonly listeners;
+
+    readonly count: number;
+
     connect(callback: Callback<T>): void;
-    disconnect(callback?: Callback<T>): boolean;
-    once(callback: Callback<T>): void;
+    disconnect(callback: Callback<T>): boolean;
+    clear(): void;
+    isConnected(callback: Callback<T>): boolean;
     emit(data: T): void;
 }
-//# sourceMappingURL=Signal.d.ts.map

package/util/Signal.ts

@@ -1,72 +1,30 @@
-export type Callback<T = void> = (data: T) => void;
-
-/**
- * Signal class for event handling.
- * Allows connecting, disconnecting, and emitting events to listeners.
- *
- * @template T - Type of data passed to listeners.
- *
- * @example
- * ```typescript
- * import { Signal } from "./_lib/signal";
- *
- * interface ExampleEvent {
- *   n: number;
- *   s: string;
- *   b: boolean;
- * }
- *
- * class TestObject {
- *   example = new Signal<ExampleEvent>();
- * }
- *
- * const tstObject = new TestObject();
- * tstObject.example.connect(({n, s, b}) => console.warn(`n: ${n}, s: ${s}, b: ${b}`));
- *
- * for (let i = 0; i < 4; i++) {
- *   let n: number = 1;
- *   let s: string = "example";
- *   let b: boolean = true;
- *   tstObject.example.emit({n, s, b});
- *   if (i === 3) { // Disconnect after 4th emit
- *     tstObject.example.disconnect();
- *     tstObject.example.emit({n, s, b});
- *   }
- * }
- * ```
- */
+export type Callback<T> = (data: T) => void;
 
 export class Signal<T = void> {
-    private listeners: Set<Callback<T>> = new Set();
+    private readonly listeners = new Set<Callback<T>>();
+
+    public get count(): number {
+        return this.listeners.size;
+    }
 
-    /** Connect a listener */
     public connect(callback: Callback<T>): void {
         this.listeners.add(callback);
     }
 
-    /** Disconnect a listener */
-    public disconnect(callback?: Callback<T>): boolean {
-        if (callback) {
-            this.listeners.delete(callback);
-            return true;
-        } else {
-            this.listeners.clear();
-            return false;
-        }
+    public disconnect(callback: Callback<T>): boolean {
+        return this.listeners.delete(callback);
+    }
+
+    public clear(): void {
+        this.listeners.clear();
     }
 
-    /** Connect a listener that runs only once */
-    public once(callback: Callback<T>) {
-        const wrapper: Callback<T> = (data) => {
-            this.disconnect(wrapper);
-            callback(data);
-        };
-        this.connect(wrapper);
+    public isConnected(callback: Callback<T>): boolean {
+        return this.listeners.has(callback);
     }
 
-    /** Emit signal to all listeners */
-    public emit(data: T) {
-        for (const cb of [...this.listeners]) {
+    public emit(data: T): void {
+        for (const cb of Array.from(this.listeners)) {
             cb(data);
         }
     }

package/util/System.d.ts

@@ -0,0 +1,4 @@
+export declare namespace System {
+    const ProxyConstructor: (_instance: any, source: any) => any;
+}
+//# sourceMappingURL=System.d.ts.map