@woosh/meep-engine 2.165.6 → 2.165.7

package/src/core/events/signal/Signal.d.ts

@@ -1,57 +1,210 @@
-export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any, G = any, H = any> {
-    add(listener: () => any, thisArg?: any): void
-    add(listener: (a: A) => any, thisArg?: any): void
-    add(listener: (a: A, b: B) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
-
-    addOne(listener: () => any, thisArg?: any): void
-    addOne(listener: (a: A) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
-
-    remove(listener: () => any, thisArg?: any): void
-    remove(listener: (a: A) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
-
-    send0(): void
-
-    send1(a: A): void
-
-    send2(a: A, b: B): void
-
-    send3(a: A, b: B, c: C): void
-
-    send4(a: A, b: B, c: C, d: D): void
-
-    send6(a: A, b: B, c: C, d: D, e: E, f: F): void
-
-    send8(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H): void
-
-    /**
-     * Prefer strongly typed dispatch methods instead (send0, send1 etc)
-     */
-    dispatch(...params: any[]): void
-
-    promise(): Promise<[A, B, C, D, E, F, G, H]>
-
-    /**
-     * @deprecated
-     */
-    removeAll(): void
-}
+/**
+ * Signal is a type of event bus. You can subscribe to events using {@link add} method and dispatch using sendN method where N is the number of arguments you wish to pass.
+ * Signal is different from a normal event bus in that 1 signal corresponds to 1 event type. For example, in HTML you have `addEventListener` which lets you subscribe to any kind of event, let's use "mousedown" as a reference.
+ * Using a Signal you would instead have a signal corresponding to "mousedown" and dispatch this signal only for this event.
+ * @example
+ *  const mouseDown = new Signal<MouseEvent>();
+ *  mouseDown.send1(myMouseEvent);
+ */
+export class Signal {
+    /**
+     * Map is used to speed up lookup when removing handlers in case of large number of listeners.
+     * @private
+     * @type {Map<function,SignalHandler>}
+     */
+    private handlers;
+    /**
+     * Internal flag bitmask
+     * @private
+     * @type {number}
+     */
+    private flags;
+    /**
+     * Used to track dispatches, handlers that have the same generation ID as the signal will not be dispatched
+     * @type {number}
+     */
+    generation: number;
+    /**
+     *
+     * @param {boolean} v
+     */
+    set silent(arg: boolean);
+    /**
+     *
+     * @returns {boolean}
+     */
+    get silent(): boolean;
+    /**
+     *
+     * @param {number|SignalFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag: number | {
+        Silent: number;
+    }): void;
+    /**
+     *
+     * @param {number|SignalFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag: number | {
+        Silent: number;
+    }): void;
+    /**
+     *
+     * @param {number|SignalFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag: number | {
+        Silent: number;
+    }, value: boolean): void;
+    /**
+     *
+     * @param {number|SignalFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag: number | {
+        Silent: number;
+    }): boolean;
+    /**
+     * Checks if a given signal handler is present or not
+     * @param {function} handler
+     * @param {*} [thisArg] if not present, will not be considered
+     * @returns {boolean}
+     */
+    contains(handler: Function, thisArg?: any): boolean;
+    mute(): void;
+    unmute(): void;
+    /**
+     * Tells if there are any handlers attached to the signal or not
+     * @returns {boolean}
+     */
+    hasHandlers(): boolean;
+    /**
+     * Handler will only be run once, it will be removed automatically after the first execution
+     * @param {function} h
+     * @param {*} [context]
+     */
+    addOne(h: Function, context?: any): void;
+    /**
+     *
+     * @param {function} h
+     * @param {*} [context]
+     */
+    add(h: Function, context?: any): void;
+    /**
+     *
+     * @param {function} h
+     * @param {*} [thisArg] if supplied, will match handlers with a specific context only
+     * @returns {boolean} true if a handler was removed, false otherwise
+     */
+    remove(h: Function, thisArg?: any): boolean;
+    /**
+     * **UNSAFE**
+     *
+     * Remove all handlers.
+     * Please note that this will remove even all handlers, irrespective of where they were added from. If another script is attaching to the same signal, using this method will potentially break that code.
+     * For most use cases, prefer to use {@link remove} method instead, or make use of {@link SignalBinding} if you need to keep track of multiple handlers
+     * NOTE: Consider this method to be unsafe, only use it when you understand the implications
+     * @deprecated
+     */
+    removeAll(): void;
+    /**
+     * Utility method, useful in asynchronous programming.
+     * Will resolve at the next {@link dispatch}/{@link send0}/etc.
+     * @return {Promise<[]>}
+     * @see addOne
+     *
+     * @example
+     *      const s = new Signal<number,number>();
+     *
+     *      // ...
+     *      const [x,y] = await s.promise(); // will trigger at the next dispatch
+     *
+     *      // ... then somewhere else
+     *      s.send2(7,-3);
+     */
+    promise(): Promise<[]>;
+    /**
+     * NOTE: because of polymorphic call-site nature of this method, it's always better for performance to use monomorphic methods like `send0`, `send1` etc.
+     * @param {...*} args
+     */
+    dispatch(...args: any[]): void;
+    /**
+     * dispatch without a value.
+     * Allows JS engine to optimize for monomorphic call sites
+     */
+    send0(...args: any[]): void;
+    /**
+     * dispatch with a single value.
+     * Allows JS engine to optimize for monomorphic call sites
+     * @param {*} arg
+     */
+    send1(arg: any, ...args: any[]): void;
+    /**
+     *
+     * @param {*} a
+     * @param {*} b
+     */
+    send2(a: any, b: any, ...args: any[]): void;
+    /**
+     *
+     * @param {*} a
+     * @param {*} b
+     * @param {*} c
+     */
+    send3(a: any, b: any, c: any, ...args: any[]): void;
+    /**
+     *
+     * @param {*} a
+     * @param {*} b
+     * @param {*} c
+     * @param {*} d
+     */
+    send4(a: any, b: any, c: any, d: any, ...args: any[]): void;
+    /**
+     *
+     * @param {*} a
+     * @param {*} b
+     * @param {*} c
+     * @param {*} d
+     * @param {*} e
+     */
+    send5(a: any, b: any, c: any, d: any, e: any, ...args: any[]): void;
+    /**
+     *
+     * @param {*} a
+     * @param {*} b
+     * @param {*} c
+     * @param {*} d
+     * @param {*} e
+     * @param {*} f
+     */
+    send6(a: any, b: any, c: any, d: any, e: any, f: any, ...args: any[]): void;
+    /**
+     *
+     * @param {*} a
+     * @param {*} b
+     * @param {*} c
+     * @param {*} d
+     * @param {*} e
+     * @param {*} f
+     * @param {*} g
+     * @param {*} h
+     */
+    send8(a: any, b: any, c: any, d: any, e: any, f: any, g: any, h: any, ...args: any[]): void;
+    /**
+     *
+     * @param {Signal} other
+     * @returns {Signal} merged signal combining events from this and other
+     */
+    merge(other: Signal): Signal;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isSignal: boolean;
+    #private;
+}
+export default Signal;
+//# sourceMappingURL=Signal.d.ts.map

package/src/core/events/signal/signal_filter.d.ts

@@ -2,7 +2,7 @@
  * @param {function(*):boolean} predicate
  */
 export function signal_filter(predicate: (arg0: any) => boolean): {
-    signal: Signal<any, any, any, any, any, any, any, any>;
+    signal: Signal;
     handler: (...args: any[]) => void;
 };
 import Signal from "./Signal.js";

package/src/core/fsm/simple/SimpleStateMachine.d.ts

@@ -1,27 +1,83 @@
-import {SimpleStateMachineDescription} from "./SimpleStateMachineDescription";
-
-export class SimpleStateMachine {
-    get description(): SimpleStateMachineDescription
-
-    constructor(d: SimpleStateMachineDescription)
-
-    addEventHandlerStateEntry(state: number, handler: (old_state: number, current_state: number) => any, thisArg?: any): void
-
-    removeEventHandlerStateEntry(state: number, handler: (old_state: number, current_state: number) => any, thisArg?: any): void
-
-    addEventHandlerStateExit(state: number, handler: (old_state: number, current_state: number) => any, thisArg?: any): void
-
-    removeEventHandlerStateExit(state: number, handler: (old_state: number, current_state: number) => any, thisArg?: any): void
-
-
-    setState(s: number): void
-
-    getState(): number
-
-    /**
-     * @throws if no path could be found to target state
-     */
-    navigateTo(target: number): void
-
-    advance<T>(input: T, preStateChangeHook?: (target: number, input: T) => any): boolean
-}
+export class SimpleStateMachine {
+    /**
+     *
+     * @param {SimpleStateMachineDescription} description
+     */
+    constructor(description: SimpleStateMachineDescription);
+    /**
+     * Current state, -1 indicated "unset"
+     * @type {number}
+     * @private
+     */
+    private __state;
+    /**
+     *
+     * @type {SignalHandler[]}
+     * @private
+     */
+    private __eventHandlersStateEntry;
+    /**
+     *
+     * @type {SignalHandler[]}
+     * @private
+     */
+    private __eventHandlersStateExit;
+    /**
+     *
+     * @type {SimpleStateMachineDescription}
+     */
+    description: SimpleStateMachineDescription;
+    /**
+     *
+     * @param {number} state
+     * @param {function} handler
+     * @param {*} [thisArg]
+     */
+    addEventHandlerStateEntry(state: number, handler: Function, thisArg?: any): void;
+    /**
+     *
+     * @param {number} state
+     * @param {function} handler
+     * @param {*} [thisArg]
+     */
+    removeEventHandlerStateEntry(state: number, handler: Function, thisArg?: any): boolean;
+    /**
+     *
+     * @param {number} state
+     * @param {function} handler
+     * @param {*} [thisArg]
+     */
+    addEventHandlerStateExit(state: number, handler: Function, thisArg?: any): void;
+    /**
+     *
+     * @param {number} state
+     * @param {function} handler
+     * @param {*} [thisArg]
+     */
+    removeEventHandlerStateExit(state: number, handler: Function, thisArg?: any): boolean;
+    /**
+     *
+     * @param {number} s
+     */
+    setState(s: number): void;
+    /**
+     *
+     * @returns {number}
+     */
+    getState(): number;
+    /**
+     * Performs navigation to target state via the shortest path
+     * @throws {Error} if no path could be found to target state
+     * @param {number} target
+     */
+    navigateTo(target: number): void;
+    /**
+     * @template X
+     * @param {X} [input] value will be fed into selector
+     * @param {function} [preStateChangeHook]
+     * @return {boolean}
+     */
+    advance<X>(input?: X, preStateChangeHook?: Function): boolean;
+}
+import { SimpleStateMachineDescription } from "./SimpleStateMachineDescription.js";
+//# sourceMappingURL=SimpleStateMachine.d.ts.map

package/src/core/fsm/simple/SimpleStateMachineDescription.d.ts

@@ -1,21 +1,90 @@
-export class SimpleStateMachineDescription {
-
-    traverseStates(visitor: (state: number) => any, thisArg?: any): void
-
-    stateExists(s: number): boolean
-
-    edgeExists(a: number, b: number): boolean
-
-    createState(id?: number): number
-
-    createEdge(a: number, b: number): void
-
-    setAction<T>(state: number, logic: (input: T) => number): void
-
-    getOutgoingStates(state: number): number[]
-
-    getIncomingStates(state: number): number[]
-
-    findPath(start: number, goal: number): number[] | null
-
-}
+/**
+ * Definition/Structure of a state machine. Used together with {@link SimpleStateMachine}.
+ * @example
+ *  const def = new SimpleStateMachineDescription();
+ *  const state_a = def.createState();
+ *  const state_b = def.createState();
+ *
+ *  def.createEdge(state_a, state_b);
+ */
+export class SimpleStateMachineDescription {
+    /**
+     *
+     * @type {BitSet}
+     * @private
+     */
+    private __states;
+    /**
+     *
+     * @type {number[][]}
+     * @private
+     */
+    private __edges;
+    /**
+     * @template T
+     * @type {(function(T):number)[]}
+     * @private
+     */
+    private __actions;
+    /**
+     *
+     * @param {function(state:number)} visitor
+     * @param {*} [thisArg]
+     */
+    traverseStates(visitor: any, thisArg?: any): void;
+    /**
+     *
+     * @param {number} s
+     * @returns {boolean}
+     */
+    stateExists(s: number): boolean;
+    /**
+     *
+     * @param {number} a
+     * @param {number} b
+     * @returns {boolean}
+     */
+    edgeExists(a: number, b: number): boolean;
+    /**
+     * @param {number} [id]
+     * @returns {number}
+     */
+    createState(id?: number): number;
+    /**
+     *
+     * @param {number} a
+     * @param {number} b
+     */
+    createEdge(a: number, b: number): void;
+    /**
+     * @template T
+     * @param {number} state
+     * @param {function(T):number} logic
+     */
+    setAction<T>(state: number, logic: (arg0: T) => number): void;
+    /**
+     *
+     * @param {number} state
+     * @returns {number[]} state IDs
+     */
+    getOutgoingStates(state: number): number[];
+    /**
+     *
+     * @param {number} state
+     * @returns {number[]} state IDs
+     */
+    getIncomingStates(state: number): number[];
+    /**
+     *
+     * @param {number} start
+     * @param {number} goal
+     * @returns {number[]|null}
+     */
+    findPath(start: number, goal: number): number[] | null;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isSimpleStateMachineDescription: boolean;
+}
+//# sourceMappingURL=SimpleStateMachineDescription.d.ts.map