@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.2

package/node_modules/@playcanvas/observer/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@playcanvas/observer",
+  "version": "1.7.1",
+  "author": "PlayCanvas <support@playcanvas.com>",
+  "homepage": "https://github.com/playcanvas/observer#readme",
+  "description": "Generic implementation of the observer pattern",
+  "keywords": [
+    "playcanvas",
+    "observer"
+  ],
+  "license": "MIT",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "type": "module",
+  "bugs": {
+    "url": "https://github.com/playcanvas/observer/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/playcanvas/observer.git"
+  },
+  "files": [
+    "dist/index.cjs",
+    "dist/index.js",
+    "dist/index.mjs",
+    "types",
+    "LICENSE",
+    "package.json",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@babel/core": "7.28.5",
+    "@babel/eslint-parser": "7.28.5",
+    "@babel/preset-env": "7.28.5",
+    "@playcanvas/eslint-config": "2.1.0",
+    "@rollup/plugin-babel": "6.1.0",
+    "@rollup/plugin-typescript": "12.3.0",
+    "@typescript-eslint/eslint-plugin": "8.52.0",
+    "@typescript-eslint/parser": "8.52.0",
+    "chai": "6.2.2",
+    "eslint": "9.39.2",
+    "globals": "17.0.0",
+    "mocha": "11.7.5",
+    "publint": "0.3.16",
+    "rollup": "4.55.1",
+    "tslib": "2.8.1",
+    "typedoc": "0.28.15",
+    "typedoc-plugin-mdn-links": "5.0.10",
+    "typedoc-plugin-missing-exports": "4.1.2",
+    "typescript": "5.9.3"
+  },
+  "scripts": {
+    "build": "rollup -c && npm run build:types",
+    "build:esm": "rollup -c --environment target:esm",
+    "build:umd": "rollup -c --environment target:umd",
+    "build:types": "tsc -p tsconfig.build.json",
+    "docs": "typedoc",
+    "lint": "eslint src test rollup.config.mjs eslint.config.mjs",
+    "lint:fix": "eslint src test rollup.config.mjs eslint.config.mjs --fix",
+    "publint": "publint",
+    "test": "mocha",
+    "type:check": "tsc --noEmit",
+    "watch": "rollup -c -w",
+    "watch:esm": "rollup -c --environment target:esm -w",
+    "watch:umd": "rollup -c --environment target:umd -w"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/node_modules/@playcanvas/observer/types/event-handle.d.ts

@@ -0,0 +1,41 @@
+import type { Events, HandleEvent } from './events';
+/**
+ * EventHandle manages the binding and unbinding of event listeners. It provides a convenient way
+ * to add, remove, and invoke event handlers associated with specific event names. Each EventHandle
+ * is linked to an 'owner' object, typically an instance of the Events class, allowing for elegant
+ * event management and chaining.
+ */
+declare class EventHandle {
+    private owner;
+    private name;
+    private fn;
+    /**
+     * Creates an instance of EventHandle.
+     *
+     * @param owner - Owner
+     * @param name - Name
+     * @param fn - Callback function
+     */
+    constructor(owner: Events, name: string, fn: HandleEvent);
+    /**
+     * Unbinds the event handle from the owner, effectively removing the event listener. After
+     * calling this method, the event handle will no longer trigger the callback function when the
+     * event is emitted.
+     */
+    unbind(): void;
+    /**
+     * Invokes the callback function associated with the event handle. This method directly
+     * triggers the event's callback without the event being emitted by the event system.
+     */
+    call(_events: Events, ..._args: any[]): void;
+    /**
+     * Registers a new event listener on the same owner as the EventHandle. This method allows
+     * chaining additional event listeners to the owner of this event handle.
+     *
+     * @param name - Name
+     * @param fn - Callback function
+     * @returns EventHandle
+     */
+    on(name: string, fn: HandleEvent): EventHandle;
+}
+export { EventHandle };

package/node_modules/@playcanvas/observer/types/events.d.ts

@@ -0,0 +1,162 @@
+import { EventHandle } from './event-handle';
+/**
+ * Callback used by {@link Events} and {@link EventHandle} functions. Note the callback is limited to 8 arguments.
+ *
+ * @param arg1 - First argument that is passed from caller.
+ * @param arg2 - Second argument that is passed from caller.
+ * @param arg3 - Third argument that is passed from caller.
+ * @param arg4 - Fourth argument that is passed from caller.
+ * @param arg5 - Fifth argument that is passed from caller.
+ * @param arg6 - Sixth argument that is passed from caller.
+ * @param arg7 - Seventh argument that is passed from caller.
+ * @param arg8 - Eighth argument that is passed from caller.
+ */
+export type HandleEvent = (arg1?: any, arg2?: any, arg3?: any, arg4?: any, arg5?: any, arg6?: any, arg7?: any, arg8?: any) => void;
+/**
+ * Base class for event handling, providing mechanisms to register, emit, and unbind events. This
+ * class supports adding event listeners, emitting events with up to 8 arguments, and managing
+ * multiple emitters.
+ *
+ * @example
+ * // Create an instance of the Events class
+ * const events = new Events();
+ *
+ * // Register an event listener
+ * events.on('testEvent', (arg1, arg2) => {
+ *     console.log('Event triggered with arguments:', arg1, arg2);
+ * });
+ *
+ * // Emit the event
+ * events.emit('testEvent', 'value1', 'value2');
+ *
+ * // Unbind the event listener
+ * events.unbind('testEvent');
+ */
+declare class Events {
+    private _additionalEmitters;
+    private _events;
+    private _suspendEvents;
+    /**
+     * Creates a new Events instance.
+     */
+    constructor();
+    /**
+     * Sets whether events are suspended. If true, the observer will not emit events when values
+     * are set.
+     */
+    set suspendEvents(value: boolean);
+    /**
+     * Gets whether events are suspended.
+     */
+    get suspendEvents(): boolean;
+    /**
+     * Registers an event listener for the specified event name. If the event is emitted,
+     * the callback function is executed with up to 8 arguments.
+     *
+     * @param name - The name of the event to listen for.
+     * @param fn - The callback function to be executed when the event is emitted.
+     * @returns An EventHandle object that can be used to unbind the event listener.
+     *
+     * @example
+     * // Register an event listener
+     * events.on('testEvent', (arg1, arg2) => {
+     *     console.log('Event triggered with arguments:', arg1, arg2);
+     * });
+     *
+     * // Emit the event
+     * events.emit('testEvent', 'value1', 'value2');
+     */
+    on(name: string, fn: HandleEvent): EventHandle;
+    /**
+     * Registers a one-time event listener for the specified event name. The callback function is
+     * executed the next time the event is emitted, and then automatically unbound.
+     *
+     * @param name - The name of the event to listen for.
+     * @param fn - The callback function to be executed once when the event is emitted.
+     * @returns An EventHandle object that can be used to unbind the event listener
+     * before it is triggered.
+     *
+     * @example
+     * // Register a one-time event listener
+     * events.once('testEvent', (arg1, arg2) => {
+     *     console.log('Event triggered once with arguments:', arg1, arg2);
+     * });
+     *
+     * // Emit the event
+     * events.emit('testEvent', 'value1', 'value2'); // The callback will be called and then unbound.
+     *
+     * // Emit the event again
+     * events.emit('testEvent', 'value1', 'value2'); // The callback will not be called this time.
+     */
+    once(name: string, fn: HandleEvent): EventHandle;
+    /**
+     * Emits the specified event, executing all registered listeners for that event with the
+     * provided arguments. If events are suspended, the emit operation will be ignored.
+     *
+     * @param name - The name of the event to emit.
+     * @param arg0 - The first argument to pass to the event listeners.
+     * @param arg1 - The second argument to pass to the event listeners.
+     * @param arg2 - The third argument to pass to the event listeners.
+     * @param arg3 - The fourth argument to pass to the event listeners.
+     * @param arg4 - The fifth argument to pass to the event listeners.
+     * @param arg5 - The sixth argument to pass to the event listeners.
+     * @param arg6 - The seventh argument to pass to the event listeners.
+     * @param arg7 - The eighth argument to pass to the event listeners.
+     * @returns The current instance for chaining.
+     *
+     * @example
+     * // Register an event listener
+     * events.on('testEvent', (arg1, arg2) => {
+     *     console.log('Event triggered with arguments:', arg1, arg2);
+     * });
+     *
+     * // Emit the event
+     * events.emit('testEvent', 'value1', 'value2');
+     *
+     * // Emit the event with more arguments
+     * events.emit('testEvent', 'value1', 'value2', 'value3', 'value4');
+     */
+    emit(name: string, arg0?: any, arg1?: any, arg2?: any, arg3?: any, arg4?: any, arg5?: any, arg6?: any, arg7?: any): this;
+    /**
+     * Unbinds an event listener for the specified event name. If a callback function is provided,
+     * only that specific listener is removed. If no callback is provided, all listeners for the
+     * event are removed. If no event name is provided, all listeners for all events are removed.
+     *
+     * @param name - The name of the event to unbind. If not provided, all events are
+     * unbound.
+     * @param fn - The specific callback function to remove. If not provided, all
+     * listeners for the event are removed.
+     * @returns The current instance for chaining.
+     *
+     * @example
+     * // Register an event listener
+     * const callback = (arg1, arg2) => {
+     *     console.log('Event triggered with arguments:', arg1, arg2);
+     * };
+     * events.on('testEvent', callback);
+     *
+     * // Unbind the specific event listener
+     * events.unbind('testEvent', callback);
+     *
+     * // Unbind all listeners for a specific event
+     * events.unbind('testEvent');
+     *
+     * // Unbind all listeners for all events
+     * events.unbind();
+     */
+    unbind(name?: string, fn?: HandleEvent): this;
+    /**
+     * Adds another emitter. Any events fired by this instance will also be fired on the additional
+     * emitter.
+     *
+     * @param emitter - The emitter
+     */
+    addEmitter(emitter: Events): void;
+    /**
+     * Removes emitter.
+     *
+     * @param emitter - The emitter
+     */
+    removeEmitter(emitter: Events): void;
+}
+export { Events };

package/node_modules/@playcanvas/observer/types/history.d.ts

@@ -0,0 +1,123 @@
+import { Events } from './events';
+/**
+ * Represents an action in the history.
+ */
+export type HistoryAction = {
+    /**
+     * The action name.
+     */
+    name: string;
+    /**
+     * The undo function.
+     */
+    undo: () => void;
+    /**
+     * The redo function.
+     */
+    redo: () => void;
+    /**
+     * Whether to combine with the previous action with the same name.
+     * The effect of combining is merely changing the redo function to be the redo function of this action.
+     * The original undo function is not modified.
+     */
+    combine: boolean;
+};
+/**
+ * Manages history actions for undo/redo operations. This class keeps track of actions that can be
+ * undone and redone, allowing for complex state management in applications such as editors, games,
+ * or any interactive applications where state changes need to be reversible.
+ *
+ * @example
+ * const history = new History();
+ *
+ * // Define an action
+ * const action = {
+ *   name: 'draw',
+ *   undo: () => { console.log('Undo draw'); },
+ *   redo: () => { console.log('Redo draw'); }
+ * };
+ *
+ * // Add the action to history
+ * history.add(action);
+ *
+ * // Perform undo
+ * history.undo();
+ *
+ * // Perform redo
+ * history.redo();
+ */
+declare class History extends Events {
+    private _executing;
+    private _actions;
+    private _currentActionIndex;
+    private _canUndo;
+    private _canRedo;
+    /**
+     * Adds a new history action to the stack. If the action has a combine flag and matches the
+     * current action's name, the redo function of the current action is updated. If actions have
+     * been undone before adding this new action, it removes all actions that come after the
+     * current action to maintain a consistent history.
+     *
+     * @param action - The action to add.
+     * @returns Returns `true` if the action is successfully added, `false` otherwise.
+     */
+    add(action: HistoryAction): boolean;
+    /**
+     * Adds a new history action and immediately executes its redo function.
+     *
+     * @param action - The action.
+     * @returns A promise that resolves once the redo function has been executed.
+     */
+    addAndExecute(action: HistoryAction): Promise<void>;
+    /**
+     * Undoes the last history action. This method retrieves the current action from the history
+     * stack and executes the action's undo function.
+     *
+     * @returns A promise that resolves once the undo function has been executed.
+     */
+    undo(): Promise<void>;
+    /**
+     * Redoes the next history action. This retrieves the next action from the history stack and
+     * executes the action's redo function.
+     *
+     * @returns A promise that resolves once the redo function has been executed.
+     */
+    redo(): Promise<void>;
+    /**
+     * Clears all history actions.
+     */
+    clear(): void;
+    /**
+     * The current history action.
+     */
+    get currentAction(): HistoryAction;
+    /**
+     * The last action committed to the history.
+     */
+    get lastAction(): HistoryAction;
+    /**
+     * Sets whether we can undo at this time.
+     */
+    set canUndo(value: boolean);
+    /**
+     * Gets whether we can undo at this time.
+     */
+    get canUndo(): boolean;
+    /**
+     * Sets whether we can redo at this time.
+     */
+    set canRedo(value: boolean);
+    /**
+     * Gets whether we can redo at this time.
+     */
+    get canRedo(): boolean;
+    /**
+     * Sets the number of async actions currently executing.
+     */
+    set executing(value: number);
+    /**
+     * Gets the number of async actions currently executing.
+     */
+    get executing(): number;
+}
+export { History };

package/node_modules/@playcanvas/observer/types/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The Observer module provides a robust implementation of the observer pattern, an essential
+ * mechanism for event handling and data binding in complex applications. It allows for creating
+ * observable objects that notify registered observers automatically whenever changes occur. This
+ * module is instrumental in developing reactive interfaces and facilitating communication between
+ * different parts of an application, enhancing modularity and responsiveness.
+ *
+ * @module Observer
+ */
+export * from './event-handle';
+export * from './events';
+export * from './history';
+export * from './observer';
+export * from './observer-history';
+export * from './observer-list';

package/node_modules/@playcanvas/observer/types/observer-history.d.ts

@@ -0,0 +1,32 @@
+import { Events } from './events';
+/**
+ * The ObserverHistory module provides a mechanism for tracking changes to an Observer object and
+ * storing them in a history stack.
+ */
+declare class ObserverHistory extends Events {
+    item: any;
+    private _history;
+    private _enabled;
+    private _prefix;
+    private _combine;
+    private _selfEvents;
+    /**
+     * @param args - Arguments
+     */
+    constructor(args?: {
+        item?: any;
+        history?: any;
+        enabled?: boolean;
+        prefix?: string;
+        combine?: boolean;
+    });
+    private _initialize;
+    destroy(): void;
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    set prefix(value: string);
+    get prefix(): string;
+    set combine(value: boolean);
+    get combine(): boolean;
+}
+export { ObserverHistory };

package/node_modules/@playcanvas/observer/types/observer-list.d.ts

@@ -0,0 +1,39 @@
+import { Events } from './events';
+/**
+ * The ObserverList class is a list of Observer objects.
+ */
+declare class ObserverList extends Events {
+    data: any[];
+    private _indexed;
+    sorted: ((arg0: any, arg1: any) => number) | null;
+    index: string | null;
+    /**
+     * @param options.sorted - Sorted
+     * @param options.index - Index
+     */
+    constructor(options?: {
+        sorted?: (arg0: any, arg1: any) => number;
+        index?: string;
+    });
+    get length(): number;
+    get(index: any): any;
+    set(index: any, value: any): void;
+    indexOf(item: any): any;
+    position(b: any, fn: (arg0: any, arg1: any) => any): number;
+    positionNextClosest(b: any, fn: ((arg0: any, arg1: any) => number)): number;
+    has(item: any): boolean;
+    add(item: any): number;
+    move(item: any, pos: number): void;
+    remove(item: any): void;
+    removeByKey(index: any): void;
+    removeBy(fn: (arg0: any) => any): void;
+    clear(): void;
+    forEach(fn: (arg0: any, arg1: any) => void): void;
+    find(fn: (arg0: any) => any): any[][];
+    findOne(fn: (arg0: any) => any): any[];
+    map(fn: (value: any, index: number, array: any[]) => any): any[];
+    sort(fn: (a: any, b: any) => number): void;
+    array(): any[];
+    json(): any[];
+}
+export { ObserverList };

package/node_modules/@playcanvas/observer/types/observer.d.ts

@@ -0,0 +1,157 @@
+import { Events } from './events';
+import { ObserverHistory } from './observer-history';
+/**
+ * The ObserverSync class is used to construct an interface for synchronizing changes from Observer
+ * to other services.
+ */
+export type ObserverSync = Events & {
+    write: (...args: any[]) => void;
+    enabled: boolean;
+};
+/**
+ * The Observer class is used to observe and manage changes to an object. It allows for tracking
+ * modifications to nested properties, emitting events on changes, and maintaining state
+ * consistency. This is particularly useful in applications where state management and change
+ * tracking are critical, such as in data-driven interfaces or collaborative applications.
+ *
+ * @example
+ * const data = {
+ *   name: 'John',
+ *   age: 30,
+ *   address: {
+ *     city: 'New York',
+ *     zip: '10001'
+ *   }
+ * };
+ *
+ * const observer = new Observer(data);
+ *
+ * observer.on('name:set', (newValue, oldValue) => {
+ *   console.log(`Name changed from ${oldValue} to ${newValue}`);
+ * });
+ *
+ * observer.set('name', 'Jane'); // Logs: Name changed from John to Jane
+ */
+declare class Observer extends Events {
+    private _destroyed;
+    private _path;
+    private _keys;
+    private _data;
+    private _pathsWithDuplicates;
+    private _parent;
+    private _parentPath;
+    private _parentField;
+    private _parentKey;
+    private _latestFn;
+    private _silent;
+    history: ObserverHistory;
+    sync: ObserverSync;
+    schema: any;
+    /**
+     * Creates a new Observer instance.
+     *
+     * @param data - The initial data to observe.
+     * @param options - Additional options for the observer.
+     */
+    constructor(data?: object, options?: {
+        parent?: Observer;
+        parentPath?: string;
+        parentField?: any;
+        parentKey?: any;
+        latestFn?: Function;
+        pathsWithDuplicates?: string[];
+    });
+    private static _splitPathsCache;
+    private static _splitPath;
+    silence(): [boolean, boolean];
+    silenceRestore(state: [boolean, boolean]): void;
+    private _prepare;
+    /**
+     * @param path - Path to the property in the object.
+     * @param value - Value to set.
+     * @param silent - If true, the change will not be recorded in history.
+     * @param remote - State value passed to the set event used to disable remote event emission.
+     * @param force - If true, the value will be set even if it is the same as the current value.
+     * @returns Returns true if the value was successfully set and false otherwise.
+     */
+    set(path: string, value: any, silent?: boolean, remote?: boolean, force?: boolean): boolean;
+    /**
+     * Query whether the object has the specified property.
+     *
+     * @param path - Path to the value.
+     * @returns Returns true if the value is present and false otherwise.
+     */
+    has(path: string): boolean;
+    /**
+     * @param path - Path to the value.
+     * @param raw - Retrieve the observer object without converting it to JSON.
+     * @returns The value at the specified path.
+     */
+    get(path: string, raw?: boolean): any;
+    getRaw(path: string): any;
+    private _equals;
+    /**
+     * @param path - Path to the value.
+     * @param silent - If true, the change will not be recorded in history.
+     * @param remote - State value passed to the set event used to disable remote event emission.
+     * @returns Returns true if the value was successfully unset and false otherwise.
+     */
+    unset(path: string, silent?: boolean, remote?: boolean): boolean;
+    /**
+     * @param path - Path to the value.
+     * @param ind - Index of the value.
+     * @param silent - If true, the remove event will not be emitted.
+     * @param remote - State value passed to the set event used to disable remote event emission.
+     * @returns Returns true if the value was successfully removed and false otherwise.
+     */
+    remove(path: string, ind: number, silent?: boolean, remote?: boolean): boolean;
+    /**
+     * @param path - Path to the value.
+     * @param value - Value to remove.
+     * @param silent - If true, the remove event will not be emitted.
+     * @param remote - State value passed to the set event used to disable remote event emission.
+     * @returns Returns true if the value was successfully removed and false otherwise.
+     */
+    removeValue(path: string, value: any, silent?: boolean, remote?: boolean): boolean;
+    /**
+     * @param path - Path to the value.
+     * @param value - Value to insert.
+     * @param ind - Index to insert the value at.
+     * @param silent - If true, the insert event will not be emitted.
+     * @param remote - State value passed to the set event used to disable remote event emission.
+     * @returns Returns true if the value was successfully inserted and false otherwise.
+     */
+    insert(path: string, value: any, ind?: number, silent?: boolean, remote?: boolean): boolean;
+    private _doInsert;
+    /**
+     * @param path - Path to the value.
+     * @param indOld - Index of the value to move.
+     * @param indNew - Index to move the value to.
+     * @param silent - If true, the move event will not be emitted.
+     * @param remote - State value passed to the set event used to disable remote event emission.
+     * @returns Returns true if the value was successfully moved and false otherwise.
+     */
+    move(path: string, indOld: number, indNew: number, silent?: boolean, remote?: boolean): boolean;
+    patch(data: Record<string, any>, removeMissingKeys?: boolean): void;
+    /**
+     * @param target - The object to JSONify.
+     * @returns The current state of the object tracked by the observer.
+     */
+    json(target?: any): Record<string, any>;
+    forEach(fn: Function, target?: any, path?: string): void;
+    /**
+     * Returns the latest observer instance. This is important when
+     * dealing with undo / redo where the observer might have been deleted
+     * and/or possibly re-created.
+     *
+     * @returns The latest instance of the observer.
+     */
+    latest(): Observer;
+    /**
+     * Destroys the observer instance.
+     */
+    destroy(): void;
+    set latestFn(value: Function);
+    get latestFn(): Function;
+}
+export { Observer };

package/node_modules/@playcanvas/observer/types/utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Determines whether two arrays are deeply equal. Two arrays are considered equal if they have the
+ * same length and corresponding elements are equal. This function also supports nested arrays,
+ * comparing them recursively.
+ *
+ * @param a - The first array to compare.
+ * @param b - The second array to compare.
+ * @returns Returns `true` if the arrays are deeply equal, otherwise `false`.
+ *
+ * @example
+ * arrayEquals([1, 2, 3], [1, 2, 3]); // true
+ * arrayEquals([1, 2, 3], [3, 2, 1]); // false
+ * arrayEquals([1, [2, 3]], [1, [2, 3]]); // true
+ * arrayEquals([1, [2, 3]], [1, [3, 2]]); // false
+ * arrayEquals([1, 2, 3], null); // false
+ * arrayEquals(null, null); // false
+ */
+declare const arrayEquals: (a: any[], b: any[]) => boolean;
+/**
+ * Creates a deep copy of an array, recursively copying any nested arrays.
+ * Non-array objects within the array are not deep copied (they remain references).
+ *
+ * @param arr - The array to copy.
+ * @returns A deep copy of the array with all nested arrays also copied.
+ *
+ * @example
+ * const original = [[1, 2], [3, 4]];
+ * const copy = deepCopyArray(original);
+ * copy[0][0] = 99;
+ * console.log(original[0][0]); // 1 (unchanged)
+ */
+declare const deepCopyArray: (arr: any[]) => any[];
+export { arrayEquals, deepCopyArray };