@block_factory/lib 0.0.1 → 0.0.3

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

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

@@ -0,0 +1,9 @@
+import { Container } from "@minecraft/server";
+export type Inventory = ContainerWrapper & Container;
+export declare class ContainerWrapper {
+    readonly source: Container;
+    private constructor();
+    static wrap(source: Container): Inventory;
+    reduce(slot: number, amount?: number): void;
+}
+//# sourceMappingURL=Container.d.ts.map

package/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);
+    }
+
+}

package/util/Wrapper/IEntity.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from "@minecraft/server";
+import { Inventory } from "./Container";
+export type IEntity = IEntityWrapper & Entity;
+export declare class IEntityWrapper {
+    readonly source: Entity;
+    private constructor();
+    static wrap(source: Entity): IEntity;
+    isAlive: boolean;
+    get inventory(): Inventory;
+    test(): void;
+}
+//# sourceMappingURL=IEntity.d.ts.map

package/util/Wrapper/IEntity.ts

@@ -0,0 +1,34 @@
+import { Entity, EntityInventoryComponent } from "@minecraft/server";
+import { ContainerWrapper, Inventory } from "./Container";
+import { System } from "../System";
+
+export type IEntity = IEntityWrapper & Entity;
+
+export class IEntityWrapper {
+    public readonly source: Entity;
+
+    private constructor(source: Entity) {
+        this.source = source;
+        return System.ProxyConstructor(this, source);
+    }
+
+    public static wrap(source: Entity): IEntity {
+        return new IEntityWrapper(source) as IEntity;
+    }
+
+    //======================== Interal ========================
+    public isAlive: boolean = false;
+
+    public get inventory(): Inventory {
+        const i = this.source.getComponent(
+            EntityInventoryComponent.componentId
+        ) as EntityInventoryComponent;
+
+        return ContainerWrapper.wrap(i.container);
+    }
+
+    public test(): void {
+        //this.source.sendMessage(`${this.source.name} was tested`);
+    }
+
+}

package/util/Wrapper/IPlayer.d.ts

@@ -0,0 +1,12 @@
+import { Player } from "@minecraft/server";
+import { Inventory } from "./Container";
+export type IPlayer = IPlayerWrapper & Player;
+export declare class IPlayerWrapper {
+    readonly source: Player;
+    private constructor();
+    static wrap(player: Player): IPlayer;
+    isAlive: boolean;
+    get inventory(): Inventory;
+    test(): void;
+}
+//# sourceMappingURL=IPlayer.d.ts.map

package/util/Wrapper/IPlayer.ts

@@ -0,0 +1,34 @@
+import { EntityInventoryComponent, Player } from "@minecraft/server";
+import { ContainerWrapper, Inventory } from "./Container";
+import { System } from "../System";
+
+export type IPlayer = IPlayerWrapper & Player;
+
+export class IPlayerWrapper {
+    public readonly source: Player;
+
+    private constructor(source: Player) {
+        this.source = source;
+        return System.ProxyConstructor(this, source);
+    }
+
+    public static wrap(player: Player): IPlayer {
+        return new IPlayerWrapper(player) as IPlayer;
+    }
+
+    //======================== Interal ========================
+    public isAlive: boolean = false;
+
+    public get inventory(): Inventory {
+        const i = this.source.getComponent(
+            EntityInventoryComponent.componentId
+        ) as EntityInventoryComponent;
+
+        return ContainerWrapper.wrap(i.container);
+    }
+
+    public test(): void {
+        this.source.sendMessage(`${this.source.name} was tested`);
+    }
+
+}

package/util/Form.d.ts

@@ -1,75 +0,0 @@
-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

package/util/Form.ts

@@ -1,246 +0,0 @@
-/*  
-**************************************************
- 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++;
-        }
-    }
-}