INIT

node_modules/runed/dist/utilities/finite-state-machine/finite-state-machine.svelte.d.ts

@@ -0,0 +1,37 @@
+export type FSMLifecycleFn<StatesT extends string, EventsT extends string> = (meta: LifecycleFnMeta<StatesT, EventsT>) => void;
+export type LifecycleFnMeta<StatesT extends string, EventsT extends string> = {
+    from: StatesT | null;
+    to: StatesT;
+    event: EventsT | null;
+    args: unknown;
+};
+export declare function isLifecycleFnMeta<StatesT extends string, EventsT extends string>(meta: unknown): meta is LifecycleFnMeta<StatesT, EventsT>;
+export type FSMLifecycle = "_enter" | "_exit";
+export type ActionFn<StatesT> = (...args: unknown[]) => StatesT | void;
+export type Action<StatesT> = StatesT | ActionFn<StatesT>;
+export type StateHandler<StatesT extends string, EventsT extends string> = {
+    [e in EventsT]?: Action<StatesT>;
+} & {
+    [k in FSMLifecycle]?: FSMLifecycleFn<StatesT, EventsT>;
+};
+export type Transition<StatesT extends string, EventsT extends string> = {
+    [s in StatesT]: StateHandler<StatesT, EventsT>;
+} & {
+    "*"?: StateHandler<StatesT, EventsT>;
+};
+/**
+ * Defines a strongly-typed finite state machine.
+ *
+ * @see {@link https://runed.dev/docs/utilities/finite-state-machine}
+ */
+export declare class FiniteStateMachine<StatesT extends string, EventsT extends string> {
+    #private;
+    readonly states: Transition<StatesT, EventsT>;
+    constructor(initial: StatesT, states: Transition<StatesT, EventsT>);
+    /** Triggers a new event and returns the new state. */
+    send(event: EventsT, ...args: unknown[]): StatesT;
+    /** Debounces the triggering of an event. */
+    debounce(wait: number | undefined, event: EventsT, ...args: unknown[]): Promise<StatesT>;
+    /** The current state. */
+    get current(): StatesT;
+}

node_modules/runed/dist/utilities/finite-state-machine/finite-state-machine.svelte.js

@@ -0,0 +1,78 @@
+export function isLifecycleFnMeta(meta) {
+    return (!!meta &&
+        typeof meta === "object" &&
+        "to" in meta &&
+        "from" in meta &&
+        "event" in meta &&
+        "args" in meta);
+}
+/**
+ * Defines a strongly-typed finite state machine.
+ *
+ * @see {@link https://runed.dev/docs/utilities/finite-state-machine}
+ */
+export class FiniteStateMachine {
+    #current = $state();
+    states;
+    #timeout = {};
+    constructor(initial, states) {
+        this.#current = initial;
+        this.states = states;
+        this.send = this.send.bind(this);
+        this.debounce = this.debounce.bind(this);
+        // synthetically trigger _enter for the initial state.
+        this.#dispatch("_enter", { from: null, to: initial, event: null, args: [] });
+    }
+    #transition(newState, event, args) {
+        const metadata = { from: this.#current, to: newState, event, args };
+        this.#dispatch("_exit", metadata);
+        this.#current = newState;
+        this.#dispatch("_enter", metadata);
+    }
+    #dispatch(event, ...args) {
+        const action = this.states[this.#current]?.[event] ?? this.states["*"]?.[event];
+        if (action instanceof Function) {
+            if (event === "_enter" || event === "_exit") {
+                if (isLifecycleFnMeta(args[0])) {
+                    action(args[0]);
+                }
+                else {
+                    console.warn("Invalid metadata passed to lifecycle function of the FSM.");
+                }
+            }
+            else {
+                return action(...args);
+            }
+        }
+        else if (typeof action === "string") {
+            return action;
+        }
+        else if (event !== "_enter" && event !== "_exit") {
+            console.warn("No action defined for event", event, "in state", this.#current);
+        }
+    }
+    /** Triggers a new event and returns the new state. */
+    send(event, ...args) {
+        const newState = this.#dispatch(event, ...args);
+        if (newState && newState !== this.#current) {
+            this.#transition(newState, event, args);
+        }
+        return this.#current;
+    }
+    /** Debounces the triggering of an event. */
+    async debounce(wait = 500, event, ...args) {
+        if (this.#timeout[event]) {
+            clearTimeout(this.#timeout[event]);
+        }
+        return new Promise((resolve) => {
+            this.#timeout[event] = setTimeout(() => {
+                delete this.#timeout[event];
+                resolve(this.send(event, ...args));
+            }, wait);
+        });
+    }
+    /** The current state. */
+    get current() {
+        return this.#current;
+    }
+}

node_modules/runed/dist/utilities/finite-state-machine/index.d.ts

@@ -0,0 +1 @@
+export * from "./finite-state-machine.svelte.js";

node_modules/runed/dist/utilities/finite-state-machine/index.js

@@ -0,0 +1 @@
+export * from "./finite-state-machine.svelte.js";