@twick/core 0.11.0

package/lib/threading/Thread.d.ts

@@ -0,0 +1,77 @@
+import type { ThreadGenerator } from './ThreadGenerator';
+export declare function noop(): ThreadGenerator;
+/**
+ * A class representing an individual thread.
+ *
+ * @remarks
+ * Thread is a wrapper for a generator that can be executed concurrently.
+ *
+ * Aside from the main thread, all threads need to have a parent.
+ * If a parent finishes execution, all of its child threads are terminated.
+ */
+export declare class Thread {
+    /**
+     * The generator wrapped by this thread.
+     */
+    readonly runner: ThreadGenerator & {
+        task?: Thread;
+    };
+    children: Thread[];
+    /**
+     * The next value to be passed to the wrapped generator.
+     */
+    value: unknown;
+    /**
+     * The current time of this thread.
+     *
+     * @remarks
+     * Used by {@link flow.waitFor} and other time-based functions to properly
+     * support durations shorter than one frame.
+     */
+    readonly time: import("../signals").SimpleSignal<number, void>;
+    /**
+     * The fixed time of this thread.
+     *
+     * @remarks
+     * Fixed time is a multiple of the frame duration. It can be used to account
+     * for the difference between this thread's {@link time} and the time of the
+     * current animation frame.
+     */
+    get fixed(): number;
+    /**
+     * Check if this thread or any of its ancestors has been canceled.
+     */
+    get canceled(): boolean;
+    get paused(): boolean;
+    parent: Thread | null;
+    private isCanceled;
+    private isPaused;
+    private fixedTime;
+    private queue;
+    constructor(
+    /**
+     * The generator wrapped by this thread.
+     */
+    runner: ThreadGenerator & {
+        task?: Thread;
+    });
+    /**
+     * Progress the wrapped generator once.
+     */
+    next(): IteratorYieldResult<void | Promise<any> | ThreadGenerator | import("./ThreadGenerator").Promisable<any>> | IteratorReturnResult<void> | {
+        value: null;
+        done: boolean;
+    };
+    /**
+     * Prepare the thread for the next update cycle.
+     *
+     * @param dt - The delta time of the next cycle.
+     */
+    update(dt: number): void;
+    spawn(child: ThreadGenerator | (() => ThreadGenerator)): ThreadGenerator;
+    add(child: Thread): void;
+    drain(callback: (task: ThreadGenerator) => void): void;
+    cancel(): void;
+    pause(value: boolean): void;
+}
+//# sourceMappingURL=Thread.d.ts.map

package/lib/threading/Thread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Thread.d.ts","sourceRoot":"","sources":["../../src/threading/Thread.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAgDvD,wBAAiB,IAAI,IAAI,eAAe,CAEvC;AAED;;;;;;;;GAQG;AACH,qBAAa,MAAM;IA8Cf;;OAEG;aACa,MAAM,EAAE,eAAe,GAAG;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC;IAhDpD,QAAQ,EAAE,MAAM,EAAE,CAAM;IAC/B;;OAEG;IACI,KAAK,EAAE,OAAO,CAAC;IAEtB;;;;;;OAMG;IACH,SAAgB,IAAI,kDAAmB;IAEvC;;;;;;;OAOG;IACH,IAAW,KAAK,WAEf;IAED;;OAEG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAED,IAAW,MAAM,IAAI,OAAO,CAE3B;IAEM,MAAM,EAAE,MAAM,GAAG,IAAI,CAAQ;IACpC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,KAAK,CAAyB;;IAGpC;;OAEG;IACa,MAAM,EAAE,eAAe,GAAG;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC;IAc3D;;OAEG;IACI,IAAI;;;;IAeX;;;;OAIG;IACI,MAAM,CAAC,EAAE,EAAE,MAAM;IAQjB,KAAK,CACV,KAAK,EAAE,eAAe,GAAG,CAAC,MAAM,eAAe,CAAC,GAC/C,eAAe;IAQX,GAAG,CAAC,KAAK,EAAE,MAAM;IAUjB,KAAK,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI;IAK/C,MAAM;IAON,KAAK,CAAC,KAAK,EAAE,OAAO;CAG5B"}

package/lib/threading/Thread.js

@@ -0,0 +1,169 @@
+import { decorate, threadable } from '../decorators';
+import { getTaskName, setTaskName } from '../flow';
+import { createSignal } from '../signals';
+import { endThread, startThread, useLogger } from '../utils';
+import { isThreadGenerator } from './ThreadGenerator';
+const reusedGenerator = `
+This usually happens when you mistakenly reuse a generator that is already
+running.
+
+For example, using \`yield\` here will run the opacity generator concurrently and
+store it in the \`task\` variable (in case you want to cancel or await it later):
+
+\`\`\`ts
+const task = yield rect().opacity(1, 1);
+\`\`\`
+
+Trying to \`yield\` this task again will cause the current error:
+
+\`\`\`ts
+yield task;
+\`\`\`
+
+Passing it to other flow functions will also cause the error:
+
+\`\`\`ts
+// prettier-ignore
+yield* all(task);
+\`\`\`
+
+Try to investigate your code looking for \`yield\` statements whose return value
+is reused in this way. Here's an example of a common mistake:
+
+\`\`\`ts wrong
+// prettier-ignore
+yield* all(
+  yield rect().opacity(1, 1), 
+  yield rect().x(200, 1),
+);
+\`\`\`
+
+\`\`\`ts correct
+// prettier-ignore
+yield* all(
+  rect().opacity(1, 1), 
+  rect().x(200, 1),
+);
+\`\`\`
+`;
+decorate(noop, threadable());
+export function* noop() {
+    // do nothing
+}
+/**
+ * A class representing an individual thread.
+ *
+ * @remarks
+ * Thread is a wrapper for a generator that can be executed concurrently.
+ *
+ * Aside from the main thread, all threads need to have a parent.
+ * If a parent finishes execution, all of its child threads are terminated.
+ */
+export class Thread {
+    /**
+     * The fixed time of this thread.
+     *
+     * @remarks
+     * Fixed time is a multiple of the frame duration. It can be used to account
+     * for the difference between this thread's {@link time} and the time of the
+     * current animation frame.
+     */
+    get fixed() {
+        return this.fixedTime;
+    }
+    /**
+     * Check if this thread or any of its ancestors has been canceled.
+     */
+    get canceled() {
+        return this.isCanceled || (this.parent?.canceled ?? false);
+    }
+    get paused() {
+        return this.isPaused || (this.parent?.paused ?? false);
+    }
+    constructor(
+    /**
+     * The generator wrapped by this thread.
+     */
+    runner) {
+        this.runner = runner;
+        this.children = [];
+        /**
+         * The current time of this thread.
+         *
+         * @remarks
+         * Used by {@link flow.waitFor} and other time-based functions to properly
+         * support durations shorter than one frame.
+         */
+        this.time = createSignal(0);
+        this.parent = null;
+        this.isCanceled = false;
+        this.isPaused = false;
+        this.fixedTime = 0;
+        this.queue = [];
+        if (this.runner.task) {
+            useLogger().error({
+                message: `The generator "${getTaskName(this.runner)}" is already being executed by another thread.`,
+                remarks: reusedGenerator,
+            });
+            this.runner = noop();
+        }
+        this.runner.task = this;
+    }
+    /**
+     * Progress the wrapped generator once.
+     */
+    next() {
+        if (this.paused) {
+            return {
+                value: null,
+                done: false,
+            };
+        }
+        startThread(this);
+        const result = this.runner.next(this.value);
+        endThread(this);
+        this.value = null;
+        return result;
+    }
+    /**
+     * Prepare the thread for the next update cycle.
+     *
+     * @param dt - The delta time of the next cycle.
+     */
+    update(dt) {
+        if (!this.paused) {
+            this.time(this.time() + dt);
+            this.fixedTime += dt;
+        }
+        this.children = this.children.filter(child => !child.canceled);
+    }
+    spawn(child) {
+        if (!isThreadGenerator(child)) {
+            child = child();
+        }
+        this.queue.push(child);
+        return child;
+    }
+    add(child) {
+        child.parent = this;
+        child.isCanceled = false;
+        child.time(this.time());
+        child.fixedTime = this.fixedTime;
+        this.children.push(child);
+        setTaskName(child.runner, `unknown ${this.children.length}`);
+    }
+    drain(callback) {
+        this.queue.forEach(callback);
+        this.queue = [];
+    }
+    cancel() {
+        this.runner.return();
+        this.isCanceled = true;
+        this.parent = null;
+        this.drain(task => task.return());
+    }
+    pause(value) {
+        this.isPaused = value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/threading/ThreadGenerator.d.ts

@@ -0,0 +1,39 @@
+import type { Thread } from './Thread';
+export interface Promisable<T> {
+    toPromise(): Promise<T>;
+}
+export declare function isPromisable(value: any): value is Promisable<any>;
+/**
+ * The main generator type produced by all generator functions in Motion Canvas.
+ *
+ * @example
+ * Yielded values can be used to control the flow of animation:
+ *
+ * Progress to the next frame:
+ * ```ts
+ * yield;
+ * ```
+ *
+ * Run another generator synchronously:
+ * ```ts
+ * yield* generatorFunction();
+ * ```
+ *
+ * Run another generator concurrently:
+ * ```ts
+ * const task = yield generatorFunction();
+ * ```
+ *
+ * Await a Promise:
+ * ```ts
+ * const result = yield asyncFunction();
+ * ```
+ */
+export type ThreadGenerator = Generator<ThreadGenerator | Promise<any> | Promisable<any> | void, void, Thread | any>;
+/**
+ * Check if the given value is a {@link ThreadGenerator}.
+ *
+ * @param value - A possible thread {@link ThreadGenerator}.
+ */
+export declare function isThreadGenerator(value: unknown): value is ThreadGenerator;
+//# sourceMappingURL=ThreadGenerator.d.ts.map

package/lib/threading/ThreadGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadGenerator.d.ts","sourceRoot":"","sources":["../../src/threading/ThreadGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAErC,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,SAAS,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;CACzB;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,UAAU,CAAC,GAAG,CAAC,CAMjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,CACrC,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,IAAI,EACvD,IAAI,EACJ,MAAM,GAAG,GAAG,CACb,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAO1E"}

package/lib/threading/ThreadGenerator.js

@@ -0,0 +1,17 @@
+export function isPromisable(value) {
+    return (value &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        'toPromise' in value);
+}
+/**
+ * Check if the given value is a {@link ThreadGenerator}.
+ *
+ * @param value - A possible thread {@link ThreadGenerator}.
+ */
+export function isThreadGenerator(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        Symbol.iterator in value &&
+        'next' in value);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVGhyZWFkR2VuZXJhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RocmVhZGluZy9UaHJlYWRHZW5lcmF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBTUEsTUFBTSxVQUFVLFlBQVksQ0FBQyxLQUFVO0lBQ3JDLE9BQU8sQ0FDTCxLQUFLO1FBQ0wsQ0FBQyxPQUFPLEtBQUssS0FBSyxRQUFRLElBQUksT0FBTyxLQUFLLEtBQUssVUFBVSxDQUFDO1FBQzFELFdBQVcsSUFBSSxLQUFLLENBQ3JCLENBQUM7QUFDSixDQUFDO0FBa0NEOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsaUJBQWlCLENBQUMsS0FBYztJQUM5QyxPQUFPLENBQ0wsS0FBSyxLQUFLLElBQUk7UUFDZCxPQUFPLEtBQUssS0FBSyxRQUFRO1FBQ3pCLE1BQU0sQ0FBQyxRQUFRLElBQUksS0FBSztRQUN4QixNQUFNLElBQUksS0FBSyxDQUNoQixDQUFDO0FBQ0osQ0FBQyJ9

package/lib/threading/cancel.d.ts

@@ -0,0 +1,17 @@
+import type { ThreadGenerator } from './ThreadGenerator';
+/**
+ * Cancel all listed tasks.
+ *
+ * Example:
+ * ```ts
+ * const task = yield generatorFunction();
+ *
+ * // do something concurrently
+ *
+ * yield* cancel(task);
+ * ```
+ *
+ * @param tasks - A list of tasks to cancel.
+ */
+export declare function cancel(...tasks: ThreadGenerator[]): void;
+//# sourceMappingURL=cancel.d.ts.map

package/lib/threading/cancel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancel.d.ts","sourceRoot":"","sources":["../../src/threading/cancel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAEvD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,GAAG,KAAK,EAAE,eAAe,EAAE,QASjD"}

package/lib/threading/cancel.js

@@ -0,0 +1,26 @@
+import { useThread } from '../utils';
+/**
+ * Cancel all listed tasks.
+ *
+ * Example:
+ * ```ts
+ * const task = yield generatorFunction();
+ *
+ * // do something concurrently
+ *
+ * yield* cancel(task);
+ * ```
+ *
+ * @param tasks - A list of tasks to cancel.
+ */
+export function cancel(...tasks) {
+    const thread = useThread();
+    for (const task of tasks) {
+        const child = thread.children.find(thread => thread.runner === task);
+        if (child && !child.canceled) {
+            child.cancel();
+            child.time(thread.time());
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FuY2VsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RocmVhZGluZy9jYW5jZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUduQzs7Ozs7Ozs7Ozs7OztHQWFHO0FBQ0gsTUFBTSxVQUFVLE1BQU0sQ0FBQyxHQUFHLEtBQXdCO0lBQ2hELE1BQU0sTUFBTSxHQUFHLFNBQVMsRUFBRSxDQUFDO0lBQzNCLEtBQUssTUFBTSxJQUFJLElBQUksS0FBSyxFQUFFLENBQUM7UUFDekIsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsTUFBTSxLQUFLLElBQUksQ0FBQyxDQUFDO1FBQ3JFLElBQUksS0FBSyxJQUFJLENBQUMsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQzdCLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNmLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7UUFDNUIsQ0FBQztJQUNILENBQUM7QUFDSCxDQUFDIn0=

package/lib/threading/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Thread management.
+ *
+ * @packageDocumentation
+ */
+export * from './cancel';
+export * from './spawn';
+export * from './Thread';
+export * from './ThreadGenerator';
+export * from './threads';
+//# sourceMappingURL=index.d.ts.map

package/lib/threading/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/threading/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC"}

package/lib/threading/index.js

@@ -0,0 +1,11 @@
+/**
+ * Thread management.
+ *
+ * @packageDocumentation
+ */
+export * from './cancel';
+export * from './spawn';
+export * from './Thread';
+export * from './ThreadGenerator';
+export * from './threads';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGhyZWFkaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsV0FBVyxDQUFDIn0=

package/lib/threading/spawn.d.ts

@@ -0,0 +1,28 @@
+import type { ThreadGenerator } from './ThreadGenerator';
+/**
+ * Run the given task concurrently.
+ *
+ * @example
+ * Using an existing task:
+ * ```ts
+ * spawn(rect().opacity(1, 1));
+ * ```
+ * Using a generator function:
+ * ```ts
+ * spawn(function* () {
+ *   yield* rect().opacity(1, 1);
+ *   yield* waitFor('click');
+ *   yield* rect().opacity(0, 1);
+ * });
+ * ```
+ * Await the spawned task:
+ * ```ts
+ * const task = spawn(rect().opacity(1, 1));
+ * // do some other things
+ * yield* join(task); // await the task
+ * ```
+ *
+ * @param task - Either a generator function or a task to run.
+ */
+export declare function spawn(task: ThreadGenerator | (() => ThreadGenerator)): ThreadGenerator;
+//# sourceMappingURL=spawn.d.ts.map

package/lib/threading/spawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../src/threading/spawn.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,KAAK,CACnB,IAAI,EAAE,eAAe,GAAG,CAAC,MAAM,eAAe,CAAC,GAC9C,eAAe,CAEjB"}

package/lib/threading/spawn.js

@@ -0,0 +1,30 @@
+import { useThread } from '../utils';
+/**
+ * Run the given task concurrently.
+ *
+ * @example
+ * Using an existing task:
+ * ```ts
+ * spawn(rect().opacity(1, 1));
+ * ```
+ * Using a generator function:
+ * ```ts
+ * spawn(function* () {
+ *   yield* rect().opacity(1, 1);
+ *   yield* waitFor('click');
+ *   yield* rect().opacity(0, 1);
+ * });
+ * ```
+ * Await the spawned task:
+ * ```ts
+ * const task = spawn(rect().opacity(1, 1));
+ * // do some other things
+ * yield* join(task); // await the task
+ * ```
+ *
+ * @param task - Either a generator function or a task to run.
+ */
+export function spawn(task) {
+    return useThread().spawn(task);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Bhd24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGhyZWFkaW5nL3NwYXduLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFHbkM7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXdCRztBQUNILE1BQU0sVUFBVSxLQUFLLENBQ25CLElBQStDO0lBRS9DLE9BQU8sU0FBUyxFQUFFLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ2pDLENBQUMifQ==

package/lib/threading/threads.d.ts

@@ -0,0 +1,46 @@
+import { Thread } from './Thread';
+import type { ThreadGenerator } from './ThreadGenerator';
+/**
+ * Check if the given value is a [Promise][promise].
+ *
+ * @param value - A possible [Promise][promise].
+ *
+ * [promise]: https://developer.mozilla.org/en-US/docs/web/javascript/reference/global_objects/promise
+ */
+export declare function isPromise(value: any): value is Promise<any>;
+/**
+ * A generator function or a normal function that returns a generator.
+ */
+export interface ThreadsFactory {
+    (): ThreadGenerator;
+}
+export interface ThreadsCallback {
+    (root: Thread): void;
+}
+/**
+ * Create a context in which generators can be run concurrently.
+ *
+ * @remarks
+ * From the perspective of the external generator, `threads` is executed
+ * synchronously. By default, each scene generator is wrapped in its own
+ * `threads` generator.
+ *
+ * @example
+ * ```ts
+ * // first
+ *
+ * yield* threads(function* () {
+ *   const task = yield generatorFunction();
+ *   // second
+ * }); // <- `task` will be terminated here because the scope
+ *     //    of this `threads` generator has ended
+ *
+ * // third
+ * ```
+ *
+ * @param factory - A function that returns the generator to run.
+ * @param callback - Called whenever threads are created, canceled or finished.
+ *                   Used for debugging purposes.
+ */
+export declare function threads(factory: ThreadsFactory, callback?: ThreadsCallback): ThreadGenerator;
+//# sourceMappingURL=threads.d.ts.map

package/lib/threading/threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threads.d.ts","sourceRoot":"","sources":["../../src/threading/threads.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAGvD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,CAE3D;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,eAAe,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAGD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAiB,OAAO,CACtB,OAAO,EAAE,cAAc,EACvB,QAAQ,CAAC,EAAE,eAAe,GACzB,eAAe,CAkDjB"}

package/lib/threading/threads.js

@@ -0,0 +1,89 @@
+import { decorate, threadable } from '../decorators';
+import { setTaskName } from '../flow';
+import { usePlayback } from '../utils';
+import { Thread } from './Thread';
+import { isThreadGenerator } from './ThreadGenerator';
+/**
+ * Check if the given value is a [Promise][promise].
+ *
+ * @param value - A possible [Promise][promise].
+ *
+ * [promise]: https://developer.mozilla.org/en-US/docs/web/javascript/reference/global_objects/promise
+ */
+export function isPromise(value) {
+    return typeof value?.then === 'function';
+}
+decorate(threads, threadable());
+/**
+ * Create a context in which generators can be run concurrently.
+ *
+ * @remarks
+ * From the perspective of the external generator, `threads` is executed
+ * synchronously. By default, each scene generator is wrapped in its own
+ * `threads` generator.
+ *
+ * @example
+ * ```ts
+ * // first
+ *
+ * yield* threads(function* () {
+ *   const task = yield generatorFunction();
+ *   // second
+ * }); // <- `task` will be terminated here because the scope
+ *     //    of this `threads` generator has ended
+ *
+ * // third
+ * ```
+ *
+ * @param factory - A function that returns the generator to run.
+ * @param callback - Called whenever threads are created, canceled or finished.
+ *                   Used for debugging purposes.
+ */
+export function* threads(factory, callback) {
+    const playback = usePlayback();
+    const root = factory();
+    setTaskName(root, 'root');
+    const rootThread = new Thread(root);
+    callback?.(rootThread);
+    let threads = [rootThread];
+    while (threads.length > 0) {
+        const newThreads = [];
+        const queue = [...threads];
+        const dt = playback.deltaTime;
+        while (queue.length > 0) {
+            const thread = queue.pop();
+            if (!thread || thread.canceled) {
+                continue;
+            }
+            const result = thread.next();
+            if (result.done) {
+                thread.cancel();
+                continue;
+            }
+            if (isThreadGenerator(result.value)) {
+                const child = new Thread(result.value);
+                thread.value = result.value;
+                thread.add(child);
+                queue.push(thread);
+                queue.push(child);
+            }
+            else if (result.value) {
+                thread.value = yield result.value;
+                queue.push(thread);
+            }
+            else {
+                thread.update(dt);
+                thread.drain(task => {
+                    const child = new Thread(task);
+                    thread.add(child);
+                    newThreads.unshift(child);
+                });
+                newThreads.unshift(thread);
+            }
+        }
+        threads = newThreads.filter(thread => !thread.canceled);
+        if (threads.length > 0)
+            yield;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/transitions/fadeTransition.d.ts

@@ -0,0 +1,8 @@
+import type { ThreadGenerator } from '../threading';
+/**
+ * Perform a transition that fades between the scenes.
+ *
+ * @param duration - The duration of the transition.
+ */
+export declare function fadeTransition(duration?: number): ThreadGenerator;
+//# sourceMappingURL=fadeTransition.d.ts.map

package/lib/transitions/fadeTransition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fadeTransition.d.ts","sourceRoot":"","sources":["../../src/transitions/fadeTransition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,cAAc,CAAC;AAGlD;;;;GAIG;AACH,wBAAiB,cAAc,CAAC,QAAQ,SAAM,GAAG,eAAe,CAQ/D"}

package/lib/transitions/fadeTransition.js

@@ -0,0 +1,16 @@
+import { createSignal } from '../signals';
+import { useTransition } from './useTransition';
+/**
+ * Perform a transition that fades between the scenes.
+ *
+ * @param duration - The duration of the transition.
+ */
+export function* fadeTransition(duration = 0.6) {
+    const progress = createSignal(0);
+    const endTransition = useTransition(ctx => {
+        ctx.globalAlpha = progress();
+    });
+    yield* progress(1, duration);
+    endTransition();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFkZVRyYW5zaXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJhbnNpdGlvbnMvZmFkZVRyYW5zaXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLFlBQVksQ0FBQztBQUV4QyxPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFFOUM7Ozs7R0FJRztBQUNILE1BQU0sU0FBUyxDQUFDLENBQUMsY0FBYyxDQUFDLFFBQVEsR0FBRyxHQUFHO0lBQzVDLE1BQU0sUUFBUSxHQUFHLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNqQyxNQUFNLGFBQWEsR0FBRyxhQUFhLENBQUMsR0FBRyxDQUFDLEVBQUU7UUFDeEMsR0FBRyxDQUFDLFdBQVcsR0FBRyxRQUFRLEVBQUUsQ0FBQztJQUMvQixDQUFDLENBQUMsQ0FBQztJQUVILEtBQUssQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDN0IsYUFBYSxFQUFFLENBQUM7QUFDbEIsQ0FBQyJ9

package/lib/transitions/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Transitions between scenes.
+ *
+ * @packageDocumentation
+ */
+export * from './fadeTransition';
+export * from './slideTransition';
+export * from './useTransition';
+export * from './zoomInTransition';
+export * from './zoomOutTransition';
+//# sourceMappingURL=index.d.ts.map

package/lib/transitions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transitions/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/lib/transitions/index.js

@@ -0,0 +1,11 @@
+/**
+ * Transitions between scenes.
+ *
+ * @packageDocumentation
+ */
+export * from './fadeTransition';
+export * from './slideTransition';
+export * from './useTransition';
+export * from './zoomInTransition';
+export * from './zoomOutTransition';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJhbnNpdGlvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxxQkFBcUIsQ0FBQyJ9