@block_factory/lib 0.0.1 → 0.0.2

package/index.d.ts

@@ -3,8 +3,10 @@ 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";
 
-export { MathUtils, Signal, Vec2, Vec3, RawText, Command }
+export { MathUtils, Signal, Vec2, Vec3, RawText, Command, Form, ActionFormCtor, IButtonOptions, IActionFormResponse, IActionFormData }
 
 export declare const BlockFactory: {
     MathUtils: typeof MathUtils;
@@ -13,4 +15,6 @@ export declare const BlockFactory: {
     Vec3: typeof Vec3;
     RawText: typeof RawText;
     Command: typeof Command;
+    Form: typeof Form;
+    IActionFormData: typeof IActionFormData;
 };

package/index.js

@@ -480,8 +480,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 +508,126 @@ system.beforeEvents.startup.subscribe(
   }
 );
 
+// util/Form.ts
+var _Form = class _Form {
+  static isOccupied(player) {
+    return _Form.occupiedPlayers.has(player.id);
+  }
+  setOccupied(player, occupied) {
+    if (occupied) _Form.occupiedPlayers.add(player.id);
+    else _Form.occupiedPlayers.delete(player.id);
+  }
+};
+__publicField(_Form, "occupiedPlayers", /* @__PURE__ */ new Set());
+__publicField(_Form, "returnText", "Back");
+var Form = _Form;
+
+// util/FormAction.ts
+import { ActionFormData } from "@minecraft/server-ui";
+var RETURN_ID = "d7213196-4cb6-4199-a40b-22fbf2d944ef";
+var IActionFormData = class extends Form {
+  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 (Form.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(Form.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;
+  }
+};
+
 // index.ts
 var BlockFactory;
 ((BlockFactory2) => {
@@ -514,10 +637,14 @@ var BlockFactory;
   Vec3;
   RawText;
   Command;
+  Form;
+  IActionFormData;
 })(BlockFactory || (BlockFactory = {}));
 export {
   BlockFactory,
   Command,
+  Form,
+  IActionFormData,
   MathUtils,
   RawText,
   Signal,

package/index.ts

@@ -3,8 +3,11 @@ 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";
+
+export { MathUtils, Signal, Vec2, Vec3, RawText, Command, Form, ActionFormCtor, IButtonOptions, IActionFormResponse, IActionFormData };
 
-export { MathUtils, Signal, Vec2, Vec3, RawText, Command }
 
 export namespace BlockFactory {
     MathUtils;
@@ -13,4 +16,6 @@ export namespace BlockFactory {
     Vec3;
     RawText;
     Command;
+    Form;
+    IActionFormData;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@block_factory/lib",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "index.js",
   "types": "index.d.ts",
   "description": "Typescript Library for Minecraft Bedrock Edition",

package/util/Form.d.ts

@@ -1,75 +1,10 @@
-import { Player, RawMessage } from "@minecraft/server";
-import { ActionFormResponse, ModalFormResponse } from "@minecraft/server-ui";
-declare class Form {
-    readonly isOccupied: (player: Player) => boolean;
-}
-export interface Button {
-    indexId: string | number;
-    text: string | RawMessage;
-    iconPath?: string;
-}
-export interface FormActionData {
-    response: ActionFormResponse;
-    indexId?: string | number;
-}
-export declare class ActionForm extends Form {
-    private readonly actionForm;
-    private buttonMap;
-    private buttons;
-    private titleText;
-    private bodyText;
-    title(title: string | RawMessage): void;
-    body(body: string | RawMessage): void;
-    button(indexId: string, text: string | RawMessage, iconPath?: string): void;
-    showForm(player: Player): Promise<FormActionData>;
-    private generateButtons;
-}
-export interface TextField {
-    indexId: string;
-    label: string | RawMessage;
-    placeholder: string | RawMessage;
-    defaultValue?: string;
-}
-export interface Dropdown {
-    indexId: string;
-    label: string | RawMessage;
-    options: string[];
-    defaultValueIndex?: number;
-}
-export interface Slider {
-    indexId: string;
-    label: string | RawMessage;
-    min: number;
-    max: number;
-    step: number;
-    defaultValue?: number;
-}
-export interface Toggle {
-    indexId: string;
-    label: string | RawMessage;
-    defaultValue?: boolean;
-}
-export type FormValue = string | boolean | number | undefined;
-export interface FormModalData {
-    response: ModalFormResponse;
-    indexMap?: Map<string, FormValue>;
-}
-export declare class ModalForm extends Form {
-    private readonly modalForm;
-    private widgitMap;
-    private indexMap;
-    private widgets;
-    title(title: string | RawMessage): void;
-    label(label: string | RawMessage): void;
-    header(header: string | RawMessage): void;
-    divider(): void;
-    textField(indexId: string, label: string | RawMessage, placeholder: string | RawMessage, defaultValue?: string): void;
-    dropdown(indexId: string, label: string | RawMessage, options: string[], defaultValueIndex?: number): void;
-    slider(indexId: string, label: string | RawMessage, min: number, max: number, step: number, defaultValue?: number): void;
-    toggle(indexId: string, label: string | RawMessage, defaultValue?: boolean): void;
-    showForm(player: Player): Promise<FormModalData>;
-    private processWidgets;
-    private processValues;
-}
-export {};
-//# sourceMappingURL=Form.d.ts.map
+import { Player, RawMessage } from "@minecraft/server";
+
+export declare abstract class Form {
+    private static readonly occupiedPlayers: Set<string>;
+    static returnText: RawMessage | string;
+
+    static isOccupied(player: Player): boolean;
+
+    protected setOccupied(player: Player, occupied: boolean): void;
+}

package/util/Form.ts

@@ -1,246 +1,15 @@
-/*  
-**************************************************
- Copyright (c) Block Factory - All rights reserved.
-**************************************************
- Author: Donthedev <https://github.com/voxeldon> 
-**************************************************
-*/
 import { Player, RawMessage } from "@minecraft/server";
-import { ActionFormData, ActionFormResponse, ModalFormData, ModalFormDataDropdownOptions, ModalFormDataSliderOptions, ModalFormDataTextFieldOptions, ModalFormDataToggleOptions, ModalFormResponse } from "@minecraft/server-ui";
 
-const occupiedPlayers: Set<string> = new Set();
+export abstract class Form {
+    private static readonly occupiedPlayers: Set<string> = new Set();
+    public static returnText: RawMessage | string = "Back";
 
-class Form {
-    public readonly isOccupied = ((player: Player): boolean => {
-        return occupiedPlayers.has(player.id);
-    })
-}
-
-export interface Button {
-    indexId: string | number;
-    text: string | RawMessage;
-    iconPath?: string;
-}
-
-export interface FormActionData {
-    response: ActionFormResponse;
-    indexId?: string | number;
-}
-
-export class ActionForm extends Form {
-    private readonly actionForm: ActionFormData = new ActionFormData();
-    private buttonMap: Map<number, string | number> = new Map<number, string | number>();
-    private buttons: Button[] = [];
-    private titleText: string | RawMessage | undefined;
-    private bodyText: string | RawMessage | undefined;
-
-    public title(title: string | RawMessage): void {
-        this.titleText = title;
-    }
-
-    public body(body: string | RawMessage): void {
-        this.bodyText = body;
-    }
-
-    public button(indexId: string, text: string | RawMessage, iconPath?: string): void {
-        this.buttons.push({ indexId, text, iconPath });
-    }
-
-    public async showForm(player: Player): Promise<FormActionData> {
-        if (this.titleText === undefined || this.bodyText === undefined) {
-            throw Error('Title and body must be set before showing the form');
-        }
-        this.actionForm.title(this.titleText);
-        this.actionForm.body(this.bodyText);
-        this.generateButtons();
-
-        occupiedPlayers.add(player.id);
-
-        const response: ActionFormResponse = await this.actionForm.show(player).finally(() => {
-            occupiedPlayers.delete(player.id);
-        });
-
-        const return_data: FormActionData = {
-            response: response,
-            indexId: undefined
-        };
-        if (response.selection !== undefined && response.selection !== null) {
-            const selection: string | number | undefined = this.buttonMap.get(response.selection);
-            return_data.indexId = selection;
-        }
-
-        return return_data;
-    }
-
-    private generateButtons() {
-        let buttonIndex: number = 0;
-        this.buttons.forEach(button => {
-            if (button.iconPath) {
-                this.actionForm.button(button.text, button.iconPath);
-            } else {
-                this.actionForm.button(button.text);
-            }
-            this.buttonMap.set(buttonIndex, button.indexId);
-            buttonIndex++;
-        });
-    }
-}
-
-enum WidgetType {
-    TextField = 'textField',
-    Dropdown = 'dropdown',
-    Slider = 'slider',
-    Toggle = 'toggle'
-}
-
-interface Widget {
-    typeId: string,
-    widget: any
-};
-
-export interface TextField {
-    indexId: string,
-    label: string | RawMessage,
-    placeholder: string | RawMessage,
-    defaultValue?: string
-}
-
-export interface Dropdown {
-    indexId: string,
-    label: string | RawMessage,
-    options: string[],
-    defaultValueIndex?: number
-}
-
-export interface Slider {
-    indexId: string,
-    label: string | RawMessage,
-    min: number,
-    max: number,
-    step: number,
-    defaultValue?: number
-}
-
-export interface Toggle {
-    indexId: string,
-    label: string | RawMessage,
-    defaultValue?: boolean
-}
-
-export type FormValue = string | boolean | number | undefined;
-
-export interface FormModalData {
-    response: ModalFormResponse;
-    indexMap?: Map<string, FormValue>;
-}
-
-export class ModalForm extends Form {
-    private readonly modalForm: ModalFormData = new ModalFormData();
-    private widgitMap: Map<number, string> = new Map<number, string>();
-    private indexMap: Map<string, FormValue> = new Map<string, FormValue>();
-    private widgets: Widget[] = [];
-
-    public title(title: string | RawMessage): void {
-        this.modalForm.title(title);
-    }
-
-    public label(label: string | RawMessage): void {
-        this.modalForm.label(label);
-    }
-
-    public header(header: string | RawMessage): void {
-        this.modalForm.header(header);
-    }
-
-    public divider(): void {
-        this.modalForm.divider();
-    }
-
-    public textField(indexId: string, label: string | RawMessage, placeholder: string | RawMessage, defaultValue?: string): void {
-        this.widgets.push({ typeId: WidgetType.TextField, widget: { indexId, label, placeholder, defaultValue } });
-    }
-    public dropdown(indexId: string, label: string | RawMessage, options: string[], defaultValueIndex?: number): void {
-        this.widgets.push({ typeId: WidgetType.Dropdown, widget: { indexId, label, options, defaultValueIndex } });
-    }
-
-    public slider(indexId: string, label: string | RawMessage, min: number, max: number, step: number, defaultValue?: number): void {
-        this.widgets.push({ typeId: WidgetType.Slider, widget: { indexId, label, min, max, step, defaultValue } });
-    }
-
-    public toggle(indexId: string, label: string | RawMessage, defaultValue?: boolean): void {
-        this.widgets.push({ typeId: WidgetType.Toggle, widget: { indexId, label, defaultValue } });
-    }
-
-    public async showForm(player: Player): Promise<FormModalData> {
-        this.processWidgets();
-        occupiedPlayers.add(player.id);
-
-        const response: ModalFormResponse = await this.modalForm.show(player).finally(() => {
-            occupiedPlayers.delete(player.id);
-        });
-
-        const return_data: FormModalData = {
-            response: response,
-            indexMap: undefined
-        }
-
-        if (response.formValues !== null && response.formValues !== undefined) {
-            this.processValues(response.formValues);
-            return_data.indexMap = this.indexMap;
-        }
-
-        return return_data;
-    }
-
-    private processWidgets(): void {
-        let widgitIndex: number = 0;
-
-        for (const widget of this.widgets) {
-            if (widget.typeId === WidgetType.TextField) {
-                const textField: TextField = widget.widget;
-                const options: ModalFormDataTextFieldOptions = {
-                    defaultValue: textField?.defaultValue
-                };
-                this.modalForm.textField(textField.label, textField.placeholder, options);
-                this.widgitMap.set(widgitIndex, textField.indexId);
-            }
-            else if (widget.typeId === WidgetType.Dropdown) {
-                const dropdown: Dropdown = widget.widget;
-                const options: ModalFormDataDropdownOptions = {
-                    defaultValueIndex: dropdown?.defaultValueIndex
-                };
-                this.modalForm.dropdown(dropdown.label, dropdown.options, options);
-                this.widgitMap.set(widgitIndex, dropdown.indexId);
-
-            }
-            else if (widget.typeId === WidgetType.Slider) {
-                const slider: Slider = widget.widget;
-                const options: ModalFormDataSliderOptions = {
-                    defaultValue: slider?.defaultValue,
-                    valueStep: slider.step
-                };
-                this.modalForm.slider(slider.label, slider.min, slider.max, options);
-                this.widgitMap.set(widgitIndex, slider.indexId);
-            }
-            else if (widget.typeId === WidgetType.Toggle) {
-                const toggle: Toggle = widget.widget;
-                const options: ModalFormDataToggleOptions = {
-                    defaultValue: toggle?.defaultValue
-                }
-                this.modalForm.toggle(toggle.label, options);
-                this.widgitMap.set(widgitIndex, toggle.indexId);
-            }
-            widgitIndex += 1;
-        }
+    public static isOccupied(player: Player): boolean {
+        return Form.occupiedPlayers.has(player.id);
     }
 
-    private processValues(formValues: FormValue[]): void {
-        let widgitIndex: number = 0;
-        for (const i of formValues) {
-            const value: FormValue = i?.valueOf();
-            const indexId: string | undefined = this.widgitMap.get(widgitIndex);
-            if (indexId) this.indexMap.set(indexId, value);
-            widgitIndex++;
-        }
+    protected setOccupied(player: Player, occupied: boolean): void {
+        if (occupied) Form.occupiedPlayers.add(player.id);
+        else Form.occupiedPlayers.delete(player.id);
     }
 }

package/util/FormAction.d.ts

@@ -0,0 +1,41 @@
+import { Form } from "@block_factory/lib/util/Form";
+import { Player, RawMessage } from "@minecraft/server";
+import { ActionFormData, FormCancelationReason } from "@minecraft/server-ui";
+
+export declare type ActionFormCtor<T extends IActionFormData = IActionFormData> = new () => T;
+
+export declare interface IButtonOptions {
+    id?: string | number;
+    iconPath?: string;
+    subForm?: ActionFormCtor;
+    allowReturn?: boolean;
+}
+
+export declare interface IActionFormResponse {
+    readonly cancelationReason?: FormCancelationReason;
+    readonly canceled: boolean;
+    readonly selection?: number;
+    readonly id?: string | number;
+}
+
+export declare abstract class IActionFormData extends Form {
+    protected form: ActionFormData;
+
+    protected abstract build(player: Player): void;
+
+    protected abstract onSubmit(player: Player, response: IActionFormResponse): void;
+
+    protected onCancel?(player: Player, response: IActionFormResponse): void;
+
+    title(titleText: RawMessage | string): this;
+    body(bodyText: RawMessage | string): this;
+    divider(): this;
+    header(text: RawMessage | string): this;
+    label(text: RawMessage | string): this;
+
+    button(text: RawMessage | string, options?: IButtonOptions): this;
+
+    show(player: Player): Promise<IActionFormResponse>;
+
+    protected _showChained(player: Player, returnStack: ActionFormCtor[]): Promise<IActionFormResponse>;
+}

package/util/FormAction.ts

@@ -0,0 +1,207 @@
+import { Form } from "@block_factory/lib/util/Form";
+import { Player, RawMessage } from "@minecraft/server";
+import { ActionFormData, ActionFormResponse, FormCancelationReason } from "@minecraft/server-ui";
+
+const RETURN_ID = "d7213196-4cb6-4199-a40b-22fbf2d944ef";
+
+/**
+ * Constructor type for ActionForm classes.
+ * Used for sub-form navigation and chaining.
+ */
+export type ActionFormCtor<T extends IActionFormData = IActionFormData> = new () => T;
+
+/**
+ * Options used when adding a button to an ActionForm.
+ */
+export interface IButtonOptions {
+    /**
+     * Logical identifier returned in the form response.
+     * If omitted, the numeric button index is used.
+     */
+    id?: string | number;
+
+    /**
+     * Optional icon path from a resource pack.
+     */
+    iconPath?: string;
+
+    /**
+     * Form class to open when this button is selected.
+     */
+    subForm?: ActionFormCtor;
+
+    /**
+     * Whether the sub-form is allowed to return to this form.
+     * Defaults to true.
+     */
+    allowReturn?: boolean;
+}
+
+type ButtonMeta = {
+    id: string | number;
+    subForm?: ActionFormCtor;
+    allowReturn: boolean;
+};
+
+/**
+ * Normalized response object returned by IActionFormData.
+ */
+export interface IActionFormResponse {
+    /**
+     * Reason the form was canceled, if applicable.
+     */
+    readonly cancelationReason?: FormCancelationReason;
+
+    /**
+     * Whether the form was canceled by the player.
+     */
+    readonly canceled: boolean;
+
+    /**
+     * Raw button index selected by the player.
+     */
+    readonly selection?: number;
+
+    /**
+     * Logical button id associated with the selection.
+     */
+    readonly id?: string | number;
+}
+
+/**
+ * Abstract base class for ActionForm-based menus.
+ *
+ * Provides:
+ * - Button id mapping
+ * - Occupied player handling
+ * - Sub-form chaining with automatic Back navigation
+ * - Normalized response objects
+ */
+export abstract class IActionFormData extends Form {
+    protected form: ActionFormData = new ActionFormData();
+
+    private _buttons = new Map<number, ButtonMeta>();
+    private _nextButtonIndex = 0;
+    private _id: string = "untitled";
+
+    protected abstract build(player: Player): void;
+
+    protected abstract onSubmit( player: Player, response: IActionFormResponse): void;
+
+    protected onCancel?(player: Player, response: IActionFormResponse): 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 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 button(text: RawMessage | string, options: IButtonOptions = {}): this {
+        if (options.iconPath) this.form.button(text, options.iconPath);
+        else this.form.button(text);
+
+        const id: string | number = options.id ?? this._nextButtonIndex;
+        const allowReturn = options.allowReturn ?? true;
+
+        this._buttons.set(this._nextButtonIndex, {
+            id,
+            subForm: options.subForm,
+            allowReturn,
+        });
+
+        this._nextButtonIndex++;
+        return this;
+    }
+
+    public async show(player: Player): Promise<IActionFormResponse> {
+        if (Form.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);
+        }
+    }
+
+    protected async _showChained(player: Player,returnStack: ActionFormCtor[]): Promise<IActionFormResponse> {
+        return await this._showInternal(player, returnStack);
+    }
+
+    private _wrapResponse(response: ActionFormResponse,id?: string | number): IActionFormResponse {
+        return {
+            canceled: response.canceled,
+            cancelationReason: response.cancelationReason,
+            selection: response.selection,
+            id,
+        };
+    }
+
+    private async _showInternal(player: Player, returnStack: ActionFormCtor[]): Promise<IActionFormResponse> {
+
+        this.form = new ActionFormData();
+
+        this._buttons.clear();
+        this._nextButtonIndex = 0;
+
+        this.build(player);
+
+        if (returnStack.length > 0) {
+            this.form.button(Form.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 wrapped = this._wrapResponse(response, undefined);
+            this.onCancel?.(player, wrapped);
+            return wrapped;
+        }
+
+        const meta =
+            response.selection !== undefined
+                ? this._buttons.get(response.selection)
+                : undefined;
+
+        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 as ActionFormCtor]
+                : [...returnStack];
+
+            return await next._showChained(player, nextStack);
+        }
+
+        return wrapped;
+    }
+}

package/util/_Form.ts

@@ -0,0 +1,246 @@
+/*  
+**************************************************
+ Copyright (c) Block Factory - All rights reserved.
+**************************************************
+ Author: Donthedev <https://github.com/voxeldon> 
+**************************************************
+*/
+import { Player, RawMessage } from "@minecraft/server";
+import { ActionFormData, ActionFormResponse, ModalFormData, ModalFormDataDropdownOptions, ModalFormDataSliderOptions, ModalFormDataTextFieldOptions, ModalFormDataToggleOptions, ModalFormResponse } from "@minecraft/server-ui";
+
+const occupiedPlayers: Set<string> = new Set();
+
+class Form {
+    public readonly isOccupied = ((player: Player): boolean => {
+        return occupiedPlayers.has(player.id);
+    })
+}
+
+export interface Button {
+    indexId: string | number;
+    text: string | RawMessage;
+    iconPath?: string;
+}
+
+export interface FormActionData {
+    response: ActionFormResponse;
+    indexId?: string | number;
+}
+
+export class ActionForm extends Form {
+    private readonly actionForm: ActionFormData = new ActionFormData();
+    private buttonMap: Map<number, string | number> = new Map<number, string | number>();
+    private buttons: Button[] = [];
+    private titleText: string | RawMessage | undefined;
+    private bodyText: string | RawMessage | undefined;
+
+    public title(title: string | RawMessage): void {
+        this.titleText = title;
+    }
+
+    public body(body: string | RawMessage): void {
+        this.bodyText = body;
+    }
+
+    public button(indexId: string, text: string | RawMessage, iconPath?: string): void {
+        this.buttons.push({ indexId, text, iconPath });
+    }
+
+    public async showForm(player: Player): Promise<FormActionData> {
+        if (this.titleText === undefined || this.bodyText === undefined) {
+            throw Error('Title and body must be set before showing the form');
+        }
+        this.actionForm.title(this.titleText);
+        this.actionForm.body(this.bodyText);
+        this.generateButtons();
+
+        occupiedPlayers.add(player.id);
+
+        const response: ActionFormResponse = await this.actionForm.show(player).finally(() => {
+            occupiedPlayers.delete(player.id);
+        });
+
+        const return_data: FormActionData = {
+            response: response,
+            indexId: undefined
+        };
+        if (response.selection !== undefined && response.selection !== null) {
+            const selection: string | number | undefined = this.buttonMap.get(response.selection);
+            return_data.indexId = selection;
+        }
+
+        return return_data;
+    }
+
+    private generateButtons() {
+        let buttonIndex: number = 0;
+        this.buttons.forEach(button => {
+            if (button.iconPath) {
+                this.actionForm.button(button.text, button.iconPath);
+            } else {
+                this.actionForm.button(button.text);
+            }
+            this.buttonMap.set(buttonIndex, button.indexId);
+            buttonIndex++;
+        });
+    }
+}
+
+enum WidgetType {
+    TextField = 'textField',
+    Dropdown = 'dropdown',
+    Slider = 'slider',
+    Toggle = 'toggle'
+}
+
+interface Widget {
+    typeId: string,
+    widget: any
+};
+
+export interface TextField {
+    indexId: string,
+    label: string | RawMessage,
+    placeholder: string | RawMessage,
+    defaultValue?: string
+}
+
+export interface Dropdown {
+    indexId: string,
+    label: string | RawMessage,
+    options: string[],
+    defaultValueIndex?: number
+}
+
+export interface Slider {
+    indexId: string,
+    label: string | RawMessage,
+    min: number,
+    max: number,
+    step: number,
+    defaultValue?: number
+}
+
+export interface Toggle {
+    indexId: string,
+    label: string | RawMessage,
+    defaultValue?: boolean
+}
+
+export type FormValue = string | boolean | number | undefined;
+
+export interface FormModalData {
+    response: ModalFormResponse;
+    indexMap?: Map<string, FormValue>;
+}
+
+export class ModalForm extends Form {
+    private readonly modalForm: ModalFormData = new ModalFormData();
+    private widgitMap: Map<number, string> = new Map<number, string>();
+    private indexMap: Map<string, FormValue> = new Map<string, FormValue>();
+    private widgets: Widget[] = [];
+
+    public title(title: string | RawMessage): void {
+        this.modalForm.title(title);
+    }
+
+    public label(label: string | RawMessage): void {
+        this.modalForm.label(label);
+    }
+
+    public header(header: string | RawMessage): void {
+        this.modalForm.header(header);
+    }
+
+    public divider(): void {
+        this.modalForm.divider();
+    }
+
+    public textField(indexId: string, label: string | RawMessage, placeholder: string | RawMessage, defaultValue?: string): void {
+        this.widgets.push({ typeId: WidgetType.TextField, widget: { indexId, label, placeholder, defaultValue } });
+    }
+    public dropdown(indexId: string, label: string | RawMessage, options: string[], defaultValueIndex?: number): void {
+        this.widgets.push({ typeId: WidgetType.Dropdown, widget: { indexId, label, options, defaultValueIndex } });
+    }
+
+    public slider(indexId: string, label: string | RawMessage, min: number, max: number, step: number, defaultValue?: number): void {
+        this.widgets.push({ typeId: WidgetType.Slider, widget: { indexId, label, min, max, step, defaultValue } });
+    }
+
+    public toggle(indexId: string, label: string | RawMessage, defaultValue?: boolean): void {
+        this.widgets.push({ typeId: WidgetType.Toggle, widget: { indexId, label, defaultValue } });
+    }
+
+    public async showForm(player: Player): Promise<FormModalData> {
+        this.processWidgets();
+        occupiedPlayers.add(player.id);
+
+        const response: ModalFormResponse = await this.modalForm.show(player).finally(() => {
+            occupiedPlayers.delete(player.id);
+        });
+
+        const return_data: FormModalData = {
+            response: response,
+            indexMap: undefined
+        }
+
+        if (response.formValues !== null && response.formValues !== undefined) {
+            this.processValues(response.formValues);
+            return_data.indexMap = this.indexMap;
+        }
+
+        return return_data;
+    }
+
+    private processWidgets(): void {
+        let widgitIndex: number = 0;
+
+        for (const widget of this.widgets) {
+            if (widget.typeId === WidgetType.TextField) {
+                const textField: TextField = widget.widget;
+                const options: ModalFormDataTextFieldOptions = {
+                    defaultValue: textField?.defaultValue
+                };
+                this.modalForm.textField(textField.label, textField.placeholder, options);
+                this.widgitMap.set(widgitIndex, textField.indexId);
+            }
+            else if (widget.typeId === WidgetType.Dropdown) {
+                const dropdown: Dropdown = widget.widget;
+                const options: ModalFormDataDropdownOptions = {
+                    defaultValueIndex: dropdown?.defaultValueIndex
+                };
+                this.modalForm.dropdown(dropdown.label, dropdown.options, options);
+                this.widgitMap.set(widgitIndex, dropdown.indexId);
+
+            }
+            else if (widget.typeId === WidgetType.Slider) {
+                const slider: Slider = widget.widget;
+                const options: ModalFormDataSliderOptions = {
+                    defaultValue: slider?.defaultValue,
+                    valueStep: slider.step
+                };
+                this.modalForm.slider(slider.label, slider.min, slider.max, options);
+                this.widgitMap.set(widgitIndex, slider.indexId);
+            }
+            else if (widget.typeId === WidgetType.Toggle) {
+                const toggle: Toggle = widget.widget;
+                const options: ModalFormDataToggleOptions = {
+                    defaultValue: toggle?.defaultValue
+                }
+                this.modalForm.toggle(toggle.label, options);
+                this.widgitMap.set(widgitIndex, toggle.indexId);
+            }
+            widgitIndex += 1;
+        }
+    }
+
+    private processValues(formValues: FormValue[]): void {
+        let widgitIndex: number = 0;
+        for (const i of formValues) {
+            const value: FormValue = i?.valueOf();
+            const indexId: string | undefined = this.widgitMap.get(widgitIndex);
+            if (indexId) this.indexMap.set(indexId, value);
+            widgitIndex++;
+        }
+    }
+}