@twick/core 0.11.0

package/lib/flow/delay.d.ts

@@ -0,0 +1,29 @@
+import type { ThreadGenerator } from '../threading';
+/**
+ * Run the given generator or callback after a specific amount of time.
+ *
+ * @example
+ * ```ts
+ * yield* delay(1, rect.fill('#ff0000', 2));
+ * ```
+ *
+ * Note that the same animation can be written as:
+ * ```ts
+ * yield* waitFor(1),
+ * yield* rect.fill('#ff0000', 2),
+ * ```
+ *
+ * The reason `delay` exists is to make it easier to pass it to other flow
+ * functions. For example:
+ * ```ts
+ * yield* all(
+ *   rect.opacity(1, 3),
+ *   delay(1, rect.fill('#ff0000', 2));
+ * );
+ * ```
+ *
+ * @param time - The delay in seconds
+ * @param task - The task or callback to run after the delay.
+ */
+export declare function delay(time: number, task: ThreadGenerator | Callback): ThreadGenerator;
+//# sourceMappingURL=delay.d.ts.map

package/lib/flow/delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../src/flow/delay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,cAAc,CAAC;AAIlD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAiB,KAAK,CACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,eAAe,GAAG,QAAQ,GAC/B,eAAe,CAOjB"}

package/lib/flow/delay.js

@@ -0,0 +1,39 @@
+import { decorate, threadable } from '../decorators';
+import { waitFor } from './scheduling';
+decorate(delay, threadable());
+/**
+ * Run the given generator or callback after a specific amount of time.
+ *
+ * @example
+ * ```ts
+ * yield* delay(1, rect.fill('#ff0000', 2));
+ * ```
+ *
+ * Note that the same animation can be written as:
+ * ```ts
+ * yield* waitFor(1),
+ * yield* rect.fill('#ff0000', 2),
+ * ```
+ *
+ * The reason `delay` exists is to make it easier to pass it to other flow
+ * functions. For example:
+ * ```ts
+ * yield* all(
+ *   rect.opacity(1, 3),
+ *   delay(1, rect.fill('#ff0000', 2));
+ * );
+ * ```
+ *
+ * @param time - The delay in seconds
+ * @param task - The task or callback to run after the delay.
+ */
+export function* delay(time, task) {
+    yield* waitFor(time);
+    if ('next' in task) {
+        yield* task;
+    }
+    else {
+        task();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmxvdy9kZWxheS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFFLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUVuRCxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sY0FBYyxDQUFDO0FBRXJDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQztBQUM5Qjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXlCRztBQUNILE1BQU0sU0FBUyxDQUFDLENBQUMsS0FBSyxDQUNwQixJQUFZLEVBQ1osSUFBZ0M7SUFFaEMsS0FBSyxDQUFDLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3JCLElBQUksTUFBTSxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ25CLEtBQUssQ0FBQyxDQUFDLElBQUksQ0FBQztJQUNkLENBQUM7U0FBTSxDQUFDO1FBQ04sSUFBSSxFQUFFLENBQUM7SUFDVCxDQUFDO0FBQ0gsQ0FBQyJ9

package/lib/flow/every.d.ts

@@ -0,0 +1,41 @@
+import type { ThreadGenerator } from '../threading';
+export interface EveryCallback {
+    /**
+     * A callback called by {@link EveryTimer} every N seconds.
+     *
+     * @param tick - The amount of times the timer has ticked.
+     */
+    (tick: number): void;
+}
+export interface EveryTimer {
+    /**
+     * The generator responsible for running this timer.
+     */
+    runner: ThreadGenerator;
+    setInterval(value: number): void;
+    setCallback(value: EveryCallback): void;
+    /**
+     * Wait until the timer ticks.
+     */
+    sync(): ThreadGenerator;
+}
+/**
+ * Call the given callback every N seconds.
+ *
+ * @example
+ * ```ts
+ * const timer = every(2, time => console.log(time));
+ * yield timer.runner;
+ *
+ * // current time: 0s
+ * yield* waitFor(5);
+ * // current time: 5s
+ * yield* timer.sync();
+ * // current time: 6s
+ * ```
+ *
+ * @param interval - The interval between subsequent calls.
+ * @param callback - The callback to be called.
+ */
+export declare function every(interval: number, callback: EveryCallback): EveryTimer;
+//# sourceMappingURL=every.d.ts.map

package/lib/flow/every.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"every.d.ts","sourceRoot":"","sources":["../../src/flow/every.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,cAAc,CAAC;AAGlD,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,MAAM,EAAE,eAAe,CAAC;IACxB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,WAAW,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IAExC;;OAEG;IACH,IAAI,IAAI,eAAe,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,UAAU,CAwC3E"}

package/lib/flow/every.js

@@ -0,0 +1,61 @@
+import { decorate, threadable } from '../decorators';
+import { usePlayback } from '../utils';
+/**
+ * Call the given callback every N seconds.
+ *
+ * @example
+ * ```ts
+ * const timer = every(2, time => console.log(time));
+ * yield timer.runner;
+ *
+ * // current time: 0s
+ * yield* waitFor(5);
+ * // current time: 5s
+ * yield* timer.sync();
+ * // current time: 6s
+ * ```
+ *
+ * @param interval - The interval between subsequent calls.
+ * @param callback - The callback to be called.
+ */
+export function every(interval, callback) {
+    let changed = false;
+    decorate(everyRunner, threadable('every'));
+    function* everyRunner() {
+        const project = usePlayback();
+        let acc = 0;
+        let tick = 0;
+        callback(tick);
+        changed = true;
+        while (true) {
+            if (acc >= project.secondsToFrames(interval)) {
+                acc = 0;
+                tick++;
+                callback(tick);
+                changed = true;
+            }
+            else {
+                changed = false;
+            }
+            acc++;
+            yield;
+        }
+    }
+    return {
+        runner: everyRunner(),
+        setInterval(value) {
+            interval = value;
+            changed = false;
+        },
+        setCallback(value) {
+            callback = value;
+            changed = false;
+        },
+        *sync() {
+            while (!changed) {
+                yield;
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmxvdy9ldmVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFFLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUVuRCxPQUFPLEVBQUMsV0FBVyxFQUFDLE1BQU0sVUFBVSxDQUFDO0FBeUJyQzs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxNQUFNLFVBQVUsS0FBSyxDQUFDLFFBQWdCLEVBQUUsUUFBdUI7SUFDN0QsSUFBSSxPQUFPLEdBQUcsS0FBSyxDQUFDO0lBQ3BCLFFBQVEsQ0FBQyxXQUFXLEVBQUUsVUFBVSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDM0MsUUFBUSxDQUFDLENBQUMsV0FBVztRQUNuQixNQUFNLE9BQU8sR0FBRyxXQUFXLEVBQUUsQ0FBQztRQUM5QixJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUM7UUFDWixJQUFJLElBQUksR0FBRyxDQUFDLENBQUM7UUFDYixRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDZixPQUFPLEdBQUcsSUFBSSxDQUFDO1FBRWYsT0FBTyxJQUFJLEVBQUUsQ0FBQztZQUNaLElBQUksR0FBRyxJQUFJLE9BQU8sQ0FBQyxlQUFlLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztnQkFDN0MsR0FBRyxHQUFHLENBQUMsQ0FBQztnQkFDUixJQUFJLEVBQUUsQ0FBQztnQkFDUCxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQ2YsT0FBTyxHQUFHLElBQUksQ0FBQztZQUNqQixDQUFDO2lCQUFNLENBQUM7Z0JBQ04sT0FBTyxHQUFHLEtBQUssQ0FBQztZQUNsQixDQUFDO1lBQ0QsR0FBRyxFQUFFLENBQUM7WUFDTixLQUFLLENBQUM7UUFDUixDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU87UUFDTCxNQUFNLEVBQUUsV0FBVyxFQUFFO1FBQ3JCLFdBQVcsQ0FBQyxLQUFLO1lBQ2YsUUFBUSxHQUFHLEtBQUssQ0FBQztZQUNqQixPQUFPLEdBQUcsS0FBSyxDQUFDO1FBQ2xCLENBQUM7UUFDRCxXQUFXLENBQUMsS0FBSztZQUNmLFFBQVEsR0FBRyxLQUFLLENBQUM7WUFDakIsT0FBTyxHQUFHLEtBQUssQ0FBQztRQUNsQixDQUFDO1FBQ0QsQ0FBQyxJQUFJO1lBQ0gsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO2dCQUNoQixLQUFLLENBQUM7WUFDUixDQUFDO1FBQ0gsQ0FBQztLQUNGLENBQUM7QUFDSixDQUFDIn0=

package/lib/flow/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Utilities for controlling the flow and timing of an animation.
+ * @packageDocumentation
+ */
+export * from './all';
+export * from './any';
+export * from './chain';
+export * from './delay';
+export * from './every';
+export * from './join';
+export * from './loop';
+export * from './loopFor';
+export * from './names';
+export * from './run';
+export * from './scheduling';
+export * from './sequence';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/flow/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/lib/flow/index.js

@@ -0,0 +1,17 @@
+/**
+ * Utilities for controlling the flow and timing of an animation.
+ * @packageDocumentation
+ */
+export * from './all';
+export * from './any';
+export * from './chain';
+export * from './delay';
+export * from './every';
+export * from './join';
+export * from './loop';
+export * from './loopFor';
+export * from './names';
+export * from './run';
+export * from './scheduling';
+export * from './sequence';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmxvdy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFlBQVksQ0FBQyJ9

package/lib/flow/join.d.ts

@@ -0,0 +1,35 @@
+import type { ThreadGenerator } from '../threading/ThreadGenerator';
+/**
+ * Pause the current generator until all listed tasks are finished.
+ *
+ * @example
+ * ```ts
+ * const task = yield generatorFunction();
+ *
+ * // do something concurrently
+ *
+ * yield* join(task);
+ * ```
+ *
+ * @param tasks - A list of tasks to join.
+ */
+export declare function join(...tasks: ThreadGenerator[]): ThreadGenerator;
+/**
+ * Pause the current generator until listed tasks are finished.
+ *
+ * @example
+ * ```ts
+ * const taskA = yield generatorFunctionA();
+ * const taskB = yield generatorFunctionB();
+ *
+ * // do something concurrently
+ *
+ * // await any of the tasks
+ * yield* join(false, taskA, taskB);
+ * ```
+ *
+ * @param all - Whether we should wait for all tasks or for at least one.
+ * @param tasks - A list of tasks to join.
+ */
+export declare function join(all: boolean, ...tasks: ThreadGenerator[]): ThreadGenerator;
+//# sourceMappingURL=join.d.ts.map

package/lib/flow/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../src/flow/join.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAC;AAIlE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAAC,GAAG,KAAK,EAAE,eAAe,EAAE,GAAG,eAAe,CAAC;AACnE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAClB,GAAG,EAAE,OAAO,EACZ,GAAG,KAAK,EAAE,eAAe,EAAE,GAC1B,eAAe,CAAC"}

package/lib/flow/join.js

@@ -0,0 +1,33 @@
+import { decorate, threadable } from '../decorators';
+import { useThread } from '../utils';
+decorate(join, threadable());
+export function* join(first, ...tasks) {
+    let all = true;
+    if (typeof first === 'boolean') {
+        all = first;
+    }
+    else {
+        tasks.push(first);
+    }
+    const parent = useThread();
+    const threads = (tasks
+        .map(task => parent.children.find(thread => thread.runner === task))
+        .filter(thread => thread));
+    const startTime = parent.time();
+    let childTime;
+    if (all) {
+        while (threads.find(thread => !thread.canceled)) {
+            yield;
+        }
+        childTime = Math.max(...threads.map(thread => thread.time()));
+    }
+    else {
+        while (!threads.find(thread => thread.canceled)) {
+            yield;
+        }
+        const canceled = threads.filter(thread => thread.canceled);
+        childTime = Math.min(...canceled.map(thread => thread.time()));
+    }
+    parent.time(Math.max(startTime, childTime));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiam9pbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mbG93L2pvaW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBRSxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHbkQsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUVuQyxRQUFRLENBQUMsSUFBSSxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUM7QUFxQzdCLE1BQU0sU0FBUyxDQUFDLENBQUMsSUFBSSxDQUNuQixLQUFnQyxFQUNoQyxHQUFHLEtBQXdCO0lBRTNCLElBQUksR0FBRyxHQUFHLElBQUksQ0FBQztJQUNmLElBQUksT0FBTyxLQUFLLEtBQUssU0FBUyxFQUFFLENBQUM7UUFDL0IsR0FBRyxHQUFHLEtBQUssQ0FBQztJQUNkLENBQUM7U0FBTSxDQUFDO1FBQ04sS0FBSyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNwQixDQUFDO0lBRUQsTUFBTSxNQUFNLEdBQUcsU0FBUyxFQUFFLENBQUM7SUFDM0IsTUFBTSxPQUFPLEdBQWEsQ0FDeEIsS0FBSztTQUNGLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLE1BQU0sS0FBSyxJQUFJLENBQUMsQ0FBQztTQUNuRSxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FDNUIsQ0FBQztJQUVGLE1BQU0sU0FBUyxHQUFHLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNoQyxJQUFJLFNBQVMsQ0FBQztJQUNkLElBQUksR0FBRyxFQUFFLENBQUM7UUFDUixPQUFPLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDO1lBQ2hELEtBQUssQ0FBQztRQUNSLENBQUM7UUFDRCxTQUFTLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ2hFLENBQUM7U0FBTSxDQUFDO1FBQ04sT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztZQUNoRCxLQUFLLENBQUM7UUFDUixDQUFDO1FBQ0QsTUFBTSxRQUFRLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUMzRCxTQUFTLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLFFBQVEsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ2pFLENBQUM7SUFFRCxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsU0FBUyxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUM7QUFDOUMsQ0FBQyJ9

package/lib/flow/loop.d.ts

@@ -0,0 +1,58 @@
+import type { ThreadGenerator } from '../threading';
+export interface LoopCallback {
+    /**
+     * A callback called by {@link loop} during each iteration.
+     *
+     * @param i - The current iteration index.
+     */
+    (i: number): ThreadGenerator | void;
+}
+/**
+ * Run the given generator in a loop.
+ *
+ * @remarks
+ * Each iteration waits until the previous one is completed.
+ * Because this loop never finishes it cannot be used in the main thread.
+ * Instead, use `yield` or {@link threading.spawn} to run the loop concurrently.
+ *
+ * @example
+ * Rotate the `rect` indefinitely:
+ * ```ts
+ * yield loop(
+ *   () => rect.rotation(0).rotation(360, 2, linear),
+ * );
+ * ```
+ *
+ * @param factory - A function creating the generator to run. Because generators
+ *                  can't be reset, a new generator is created on each
+ *                  iteration.
+ */
+export declare function loop(factory: LoopCallback): ThreadGenerator;
+/**
+ * Run the given generator N times.
+ *
+ * @remarks
+ * Each iteration waits until the previous one is completed.
+ *
+ * @example
+ * ```ts
+ * const colors = [
+ *   '#ff6470',
+ *   '#ffc66d',
+ *   '#68abdf',
+ *   '#99c47a',
+ * ];
+ *
+ * yield* loop(
+ *   colors.length,
+ *   i => rect.fill(colors[i], 2),
+ * );
+ * ```
+ *
+ * @param iterations - The number of iterations.
+ * @param factory - A function creating the generator to run. Because generators
+ *                  can't be reset, a new generator is created on each
+ *                  iteration.
+ */
+export declare function loop(iterations: number, factory: LoopCallback): ThreadGenerator;
+//# sourceMappingURL=loop.d.ts.map

package/lib/flow/loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/flow/loop.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,cAAc,CAAC;AA4BlD,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,CAAC,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAAC;CACrC;AAID;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,eAAe,CAAC;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAClB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,YAAY,GACpB,eAAe,CAAC"}

package/lib/flow/loop.js

@@ -0,0 +1,51 @@
+import { decorate, threadable } from '../decorators';
+import { useLogger, useThread } from '../utils';
+const infiniteLoop = `
+Make sure to use \`yield\` or \`spawn()\` to execute the loop concurrently in a
+separate thread:
+
+\`\`\`ts wrong
+// prettier-ignore
+yield* loop(() => rect().opacity(0).opacity(1, 1));
+\`\`\`
+
+\`\`\`ts correct
+yield loop(() => rect().opacity(0).opacity(1, 1));
+// or
+spawn(loop(() => rect().opacity(0).opacity(1, 1)));
+\`\`\`
+
+If you want to execute the loop a finite number of times, specify the iteration
+count as the first argument:
+
+\`\`\`ts
+// prettier-ignore
+yield* loop(10, () => rect().opacity(0).opacity(1, 1));
+//          ^ iteration count
+\`\`\`
+`;
+decorate(loop, threadable());
+export function* loop(iterations, factory) {
+    if (typeof iterations !== 'number') {
+        factory = iterations;
+        iterations = Infinity;
+    }
+    if (iterations === Infinity && useThread().parent === null) {
+        useLogger().error({
+            message: 'Tried to execute an infinite loop in the main thread.',
+            remarks: infiniteLoop,
+            stack: new Error().stack,
+        });
+        return;
+    }
+    for (let i = 0; i < iterations; i++) {
+        const generator = factory(i);
+        if (generator) {
+            yield* generator;
+        }
+        else {
+            yield;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9vcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mbG93L2xvb3AudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBRSxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFbkQsT0FBTyxFQUFDLFNBQVMsRUFBRSxTQUFTLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFFOUMsTUFBTSxZQUFZLEdBQUc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBdUJwQixDQUFDO0FBV0YsUUFBUSxDQUFDLElBQUksRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO0FBcUQ3QixNQUFNLFNBQVMsQ0FBQyxDQUFDLElBQUksQ0FDbkIsVUFBaUMsRUFDakMsT0FBc0I7SUFFdEIsSUFBSSxPQUFPLFVBQVUsS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUNuQyxPQUFPLEdBQUcsVUFBVSxDQUFDO1FBQ3JCLFVBQVUsR0FBRyxRQUFRLENBQUM7SUFDeEIsQ0FBQztJQUVELElBQUksVUFBVSxLQUFLLFFBQVEsSUFBSSxTQUFTLEVBQUUsQ0FBQyxNQUFNLEtBQUssSUFBSSxFQUFFLENBQUM7UUFDM0QsU0FBUyxFQUFFLENBQUMsS0FBSyxDQUFDO1lBQ2hCLE9BQU8sRUFBRSx1REFBdUQ7WUFDaEUsT0FBTyxFQUFFLFlBQVk7WUFDckIsS0FBSyxFQUFFLElBQUksS0FBSyxFQUFFLENBQUMsS0FBSztTQUN6QixDQUFDLENBQUM7UUFDSCxPQUFPO0lBQ1QsQ0FBQztJQUVELEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxVQUFVLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQztRQUNwQyxNQUFNLFNBQVMsR0FBRyxPQUFRLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDOUIsSUFBSSxTQUFTLEVBQUUsQ0FBQztZQUNkLEtBQUssQ0FBQyxDQUFDLFNBQVMsQ0FBQztRQUNuQixDQUFDO2FBQU0sQ0FBQztZQUNOLEtBQUssQ0FBQztRQUNSLENBQUM7SUFDSCxDQUFDO0FBQ0gsQ0FBQyJ9

package/lib/flow/loopFor.d.ts

@@ -0,0 +1,25 @@
+import type { ThreadGenerator } from '../threading';
+import type { LoopCallback } from './loop';
+/**
+ * Run a generator in a loop for the given amount of time.
+ *
+ * @remarks
+ * Generators are executed completely before the next iteration starts.
+ * An iteration is allowed to finish even when the time is up. This means that
+ * the actual duration of the loop may be longer than the given duration.
+ *
+ * @example
+ * ```ts
+ * yield* loopFor(
+ *   3,
+ *   () => circle().position.x(-10, 0.1).to(10, 0.1)
+ * );
+ * ```
+ *
+ * @param seconds - The duration in seconds.
+ * @param factory - A function creating the generator to run. Because generators
+ *                  can't be reset, a new generator is created on each
+ *                  iteration.
+ */
+export declare function loopFor(seconds: number, factory: LoopCallback): ThreadGenerator;
+//# sourceMappingURL=loopFor.d.ts.map

package/lib/flow/loopFor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopFor.d.ts","sourceRoot":"","sources":["../../src/flow/loopFor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,QAAQ,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAiB,OAAO,CACtB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,GACpB,eAAe,CAgBjB"}

package/lib/flow/loopFor.js

@@ -0,0 +1,42 @@
+import { decorate, threadable } from '../decorators';
+import { usePlayback, useThread } from '../utils';
+decorate(loopFor, threadable());
+/**
+ * Run a generator in a loop for the given amount of time.
+ *
+ * @remarks
+ * Generators are executed completely before the next iteration starts.
+ * An iteration is allowed to finish even when the time is up. This means that
+ * the actual duration of the loop may be longer than the given duration.
+ *
+ * @example
+ * ```ts
+ * yield* loopFor(
+ *   3,
+ *   () => circle().position.x(-10, 0.1).to(10, 0.1)
+ * );
+ * ```
+ *
+ * @param seconds - The duration in seconds.
+ * @param factory - A function creating the generator to run. Because generators
+ *                  can't be reset, a new generator is created on each
+ *                  iteration.
+ */
+export function* loopFor(seconds, factory) {
+    const thread = useThread();
+    const step = usePlayback().framesToSeconds(1);
+    const targetTime = thread.time() + seconds;
+    let iteration = 0;
+    while (targetTime - step > thread.fixed) {
+        const generator = factory(iteration);
+        if (generator) {
+            yield* generator;
+        }
+        else {
+            yield;
+        }
+        iteration += 1;
+    }
+    thread.time(targetTime);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9vcEZvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mbG93L2xvb3BGb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBRSxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFbkQsT0FBTyxFQUFDLFdBQVcsRUFBRSxTQUFTLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFHaEQsUUFBUSxDQUFDLE9BQU8sRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO0FBQ2hDOzs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQW9CRztBQUNILE1BQU0sU0FBUyxDQUFDLENBQUMsT0FBTyxDQUN0QixPQUFlLEVBQ2YsT0FBcUI7SUFFckIsTUFBTSxNQUFNLEdBQUcsU0FBUyxFQUFFLENBQUM7SUFDM0IsTUFBTSxJQUFJLEdBQUcsV0FBVyxFQUFFLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzlDLE1BQU0sVUFBVSxHQUFHLE1BQU0sQ0FBQyxJQUFJLEVBQUUsR0FBRyxPQUFPLENBQUM7SUFFM0MsSUFBSSxTQUFTLEdBQUcsQ0FBQyxDQUFDO0lBQ2xCLE9BQU8sVUFBVSxHQUFHLElBQUksR0FBRyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDeEMsTUFBTSxTQUFTLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ3JDLElBQUksU0FBUyxFQUFFLENBQUM7WUFDZCxLQUFLLENBQUMsQ0FBQyxTQUFTLENBQUM7UUFDbkIsQ0FBQzthQUFNLENBQUM7WUFDTixLQUFLLENBQUM7UUFDUixDQUFDO1FBQ0QsU0FBUyxJQUFJLENBQUMsQ0FBQztJQUNqQixDQUFDO0lBQ0QsTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztBQUMxQixDQUFDIn0=

package/lib/flow/names.d.ts

@@ -0,0 +1,3 @@
+export declare function setTaskName(task: Generator, source: Generator | string): void;
+export declare function getTaskName(task: Generator): string;
+//# sourceMappingURL=names.d.ts.map

package/lib/flow/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/flow/names.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAM7E;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAEnD"}

package/lib/flow/names.js

@@ -0,0 +1,11 @@
+export function setTaskName(task, source) {
+    const prototype = Object.getPrototypeOf(task);
+    if (!prototype.threadable) {
+        prototype.threadable = true;
+        prototype.name = typeof source === 'string' ? source : getTaskName(source);
+    }
+}
+export function getTaskName(task) {
+    return Object.getPrototypeOf(task).name ?? null;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmFtZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmxvdy9uYW1lcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLFVBQVUsV0FBVyxDQUFDLElBQWUsRUFBRSxNQUEwQjtJQUNyRSxNQUFNLFNBQVMsR0FBRyxNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzlDLElBQUksQ0FBQyxTQUFTLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDMUIsU0FBUyxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUM7UUFDNUIsU0FBUyxDQUFDLElBQUksR0FBRyxPQUFPLE1BQU0sS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzdFLENBQUM7QUFDSCxDQUFDO0FBRUQsTUFBTSxVQUFVLFdBQVcsQ0FBQyxJQUFlO0lBQ3pDLE9BQU8sTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDO0FBQ2xELENBQUMifQ==

package/lib/flow/run.d.ts

@@ -0,0 +1,45 @@
+import type { ThreadGenerator } from '../threading';
+/**
+ * Turn the given generator function into a task.
+ *
+ * @remarks
+ * If you want to immediately run the generator in its own thread, you can use
+ * {@link threading.spawn} instead. This function is useful when you want to
+ * pass the created task to other flow functions.
+ *
+ * @example
+ * ```ts
+ * yield* all(
+ *   run(function* () {
+ *     // do things
+ *   }),
+ *   rect.opacity(1, 1),
+ * );
+ * ```
+ *
+ * @param runner - A generator function or a factory that creates the generator.
+ */
+export declare function run(runner: () => ThreadGenerator): ThreadGenerator;
+/**
+ * Turn the given generator function into a task.
+ *
+ * @remarks
+ * If you want to immediately run the generator in its own thread, you can use
+ * {@link threading.spawn} instead. This function is useful when you want to
+ * pass the created task to other flow functions.
+ *
+ * @example
+ * ```ts
+ * yield* all(
+ *   run(function* () {
+ *     // do things
+ *   }),
+ *   rect.opacity(1, 1),
+ * );
+ * ```
+ *
+ * @param runner - A generator function or a factory that creates the generator.
+ * @param name - An optional name used when displaying this generator in the UI.
+ */
+export declare function run(name: string, runner: () => ThreadGenerator): ThreadGenerator;
+//# sourceMappingURL=run.d.ts.map

package/lib/flow/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/flow/run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,cAAc,CAAC;AAElD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,wBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,eAAe,GAAG,eAAe,CAAC;AACpE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,GAAG,CACjB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,eAAe,GAC5B,eAAe,CAAC"}

package/lib/flow/run.js

@@ -0,0 +1,14 @@
+import { setTaskName } from './names';
+export function run(firstArg, runner) {
+    let task;
+    if (typeof firstArg === 'string') {
+        task = runner();
+        setTaskName(task, firstArg);
+    }
+    else {
+        task = firstArg();
+        setTaskName(task, task);
+    }
+    return task;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Zsb3cvcnVuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBQyxXQUFXLEVBQUMsTUFBTSxTQUFTLENBQUM7QUFnRHBDLE1BQU0sVUFBVSxHQUFHLENBQ2pCLFFBQTBDLEVBQzFDLE1BQThCO0lBRTlCLElBQUksSUFBSSxDQUFDO0lBQ1QsSUFBSSxPQUFPLFFBQVEsS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUNqQyxJQUFJLEdBQUcsTUFBTyxFQUFFLENBQUM7UUFDakIsV0FBVyxDQUFDLElBQUksRUFBRSxRQUFRLENBQUMsQ0FBQztJQUM5QixDQUFDO1NBQU0sQ0FBQztRQUNOLElBQUksR0FBRyxRQUFRLEVBQUUsQ0FBQztRQUNsQixXQUFXLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQzFCLENBQUM7SUFFRCxPQUFPLElBQUksQ0FBQztBQUNkLENBQUMifQ==

package/lib/flow/scheduling.d.ts

@@ -0,0 +1,18 @@
+import type { ThreadGenerator } from '../threading';
+/**
+ * Wait for the given amount of time.
+ *
+ * @example
+ * ```ts
+ * // current time: 0s
+ * yield waitFor(2);
+ * // current time: 2s
+ * yield waitFor(3);
+ * // current time: 5s
+ * ```
+ *
+ * @param seconds - The relative time in seconds.
+ * @param after - An optional task to be run after the function completes.
+ */
+export declare function waitFor(seconds?: number, after?: ThreadGenerator): ThreadGenerator;
+//# sourceMappingURL=scheduling.d.ts.map

package/lib/flow/scheduling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduling.d.ts","sourceRoot":"","sources":["../../src/flow/scheduling.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,cAAc,CAAC;AAIlD;;;;;;;;;;;;;;GAcG;AACH,wBAAiB,OAAO,CACtB,OAAO,SAAI,EACX,KAAK,CAAC,EAAE,eAAe,GACtB,eAAe,CAejB"}

package/lib/flow/scheduling.js

@@ -0,0 +1,33 @@
+import { decorate, threadable } from '../decorators';
+import { usePlayback, useThread } from '../utils';
+decorate(waitFor, threadable());
+/**
+ * Wait for the given amount of time.
+ *
+ * @example
+ * ```ts
+ * // current time: 0s
+ * yield waitFor(2);
+ * // current time: 2s
+ * yield waitFor(3);
+ * // current time: 5s
+ * ```
+ *
+ * @param seconds - The relative time in seconds.
+ * @param after - An optional task to be run after the function completes.
+ */
+export function* waitFor(seconds = 0, after) {
+    const thread = useThread();
+    const step = usePlayback().framesToSeconds(1);
+    const targetTime = thread.time() + seconds;
+    // subtracting the step is not necessary, but it keeps the thread time ahead
+    // of the project time.
+    while (targetTime - step > thread.fixed) {
+        yield;
+    }
+    thread.time(targetTime);
+    if (after) {
+        yield* after;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZWR1bGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mbG93L3NjaGVkdWxpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBRSxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFbkQsT0FBTyxFQUFDLFdBQVcsRUFBRSxTQUFTLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFFaEQsUUFBUSxDQUFDLE9BQU8sRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO0FBQ2hDOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsTUFBTSxTQUFTLENBQUMsQ0FBQyxPQUFPLENBQ3RCLE9BQU8sR0FBRyxDQUFDLEVBQ1gsS0FBdUI7SUFFdkIsTUFBTSxNQUFNLEdBQUcsU0FBUyxFQUFFLENBQUM7SUFDM0IsTUFBTSxJQUFJLEdBQUcsV0FBVyxFQUFFLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRTlDLE1BQU0sVUFBVSxHQUFHLE1BQU0sQ0FBQyxJQUFJLEVBQUUsR0FBRyxPQUFPLENBQUM7SUFDM0MsNEVBQTRFO0lBQzVFLHVCQUF1QjtJQUN2QixPQUFPLFVBQVUsR0FBRyxJQUFJLEdBQUcsTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3hDLEtBQUssQ0FBQztJQUNSLENBQUM7SUFDRCxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBRXhCLElBQUksS0FBSyxFQUFFLENBQUM7UUFDVixLQUFLLENBQUMsQ0FBQyxLQUFLLENBQUM7SUFDZixDQUFDO0FBQ0gsQ0FBQyJ9

package/lib/flow/sequence.d.ts

@@ -0,0 +1,22 @@
+import type { ThreadGenerator } from '../threading';
+/**
+ * Start all tasks one after another with a constant delay between.
+ *
+ * @remarks
+ * The function doesn't wait until the previous task in the sequence has
+ * finished. Once the delay has passed, the next task will start even if
+ * the previous is still running.
+ *
+ * @example
+ * ```ts
+ * yield* sequence(
+ *   0.1,
+ *   ...rects.map(rect => rect.x(100, 1))
+ * );
+ * ```
+ *
+ * @param delay - The delay between each of the tasks.
+ * @param tasks - A list of tasks to be run in a sequence.
+ */
+export declare function sequence(delay: number, ...tasks: ThreadGenerator[]): ThreadGenerator;
+//# sourceMappingURL=sequence.d.ts.map