@cyclonium/core 0.0.100

package/lib/export/framework.d.ts

@@ -0,0 +1,4 @@
+export { CycloComponent } from '../framework/component.ts';
+export { nextFrame, waitFor, waitUntil, waitWhile, type Coroutine, type CoroutineFrame, type CoroutineInstruction, type CoroutineIterator, type CoroutinePredicate, type StartCoroutineOptions, } from '../framework/coroutine.ts';
+export { PredefinedExecutionOrder } from '../framework/execution-order.ts';
+//# sourceMappingURL=framework.d.ts.map

package/lib/export/framework.js

@@ -0,0 +1,4 @@
+export { CycloComponent } from "../framework/component.js";
+export { nextFrame, waitFor, waitUntil, waitWhile, } from "../framework/coroutine.js";
+export { PredefinedExecutionOrder } from "../framework/execution-order.js";
+//# sourceMappingURL=framework.js.map

package/lib/export/internal.d.ts

@@ -0,0 +1,2 @@
+export { cycloBuiltinClass } from '../decorator/legacy/legacy-decorator.ts';
+//# sourceMappingURL=internal.d.ts.map

package/lib/export/internal.js

@@ -0,0 +1,2 @@
+export { cycloBuiltinClass } from "../decorator/legacy/legacy-decorator.js";
+//# sourceMappingURL=internal.js.map

package/lib/export/legacy-decorator.d.ts

@@ -0,0 +1,4 @@
+export { designType, editable, editorOnly, cycloClass, createScopedCycloClassDecorator, dynamicDefault, idem, idemBy, serializable, type CycloClassOptions, type CycloClassDecorator, } from '../decorator/legacy/legacy-general-decorator.ts';
+export { executionOrder, executeInEditMode, requiresComponent, } from '../decorator/legacy/legacy-component-decorator.ts';
+export { applyLegacyDecorators } from '../decorator/legacy/apply-legacy-decorators.ts';
+//# sourceMappingURL=legacy-decorator.d.ts.map

package/lib/export/legacy-decorator.js

@@ -0,0 +1,4 @@
+export { designType, editable, editorOnly, cycloClass, createScopedCycloClassDecorator, dynamicDefault, idem, idemBy, serializable, } from "../decorator/legacy/legacy-general-decorator.js";
+export { executionOrder, executeInEditMode, requiresComponent, } from "../decorator/legacy/legacy-component-decorator.js";
+export { applyLegacyDecorators } from "../decorator/legacy/apply-legacy-decorators.js";
+//# sourceMappingURL=legacy-decorator.js.map

package/lib/export/log.d.ts

@@ -0,0 +1,2 @@
+export { logger } from '../utils/logger.ts';
+//# sourceMappingURL=log.d.ts.map

package/lib/export/log.js

@@ -0,0 +1,2 @@
+export { logger } from "../utils/logger.js";
+//# sourceMappingURL=log.js.map

package/lib/export/math/bounds-2d.d.ts

@@ -0,0 +1,2 @@
+export * from '../../math/bounds-2d.js';
+//# sourceMappingURL=bounds-2d.d.ts.map

package/lib/export/math/bounds-2d.js

@@ -0,0 +1,2 @@
+export * from '../../math/bounds-2d.js';
+//# sourceMappingURL=bounds-2d.js.map

package/lib/export/math/geometry.d.ts

@@ -0,0 +1,2 @@
+export * from '../../math/geometry.ts';
+//# sourceMappingURL=geometry.d.ts.map

package/lib/export/math/geometry.js

@@ -0,0 +1,2 @@
+export * from "../../math/geometry.js";
+//# sourceMappingURL=geometry.js.map

package/lib/export/math/mat3.d.ts

@@ -0,0 +1,2 @@
+export * from '../../math/mat3.ts';
+//# sourceMappingURL=mat3.d.ts.map

package/lib/export/math/mat3.js

@@ -0,0 +1,2 @@
+export * from "../../math/mat3.js";
+//# sourceMappingURL=mat3.js.map

package/lib/export/math/number.d.ts

@@ -0,0 +1,2 @@
+export * from '../../math/number.ts';
+//# sourceMappingURL=number.d.ts.map

package/lib/export/math/number.js

@@ -0,0 +1,2 @@
+export * from "../../math/number.js";
+//# sourceMappingURL=number.js.map

package/lib/export/math/ray.d.ts

@@ -0,0 +1,2 @@
+export * from '../../math/ray.ts';
+//# sourceMappingURL=ray.d.ts.map

package/lib/export/math/ray.js

@@ -0,0 +1,2 @@
+export * from "../../math/ray.js";
+//# sourceMappingURL=ray.js.map

package/lib/export/math/transform-2d.d.ts

@@ -0,0 +1,2 @@
+export * from '../../math/transform-2d.ts';
+//# sourceMappingURL=transform-2d.d.ts.map

package/lib/export/math/transform-2d.js

@@ -0,0 +1,2 @@
+export * from "../../math/transform-2d.js";
+//# sourceMappingURL=transform-2d.js.map

package/lib/export/math/trigonometry.d.ts

@@ -0,0 +1,2 @@
+export * from '../../math/trigonometry.ts';
+//# sourceMappingURL=trigonometry.d.ts.map

package/lib/export/math/trigonometry.js

@@ -0,0 +1,2 @@
+export * from "../../math/trigonometry.js";
+//# sourceMappingURL=trigonometry.js.map

package/lib/export/math/vec2.d.ts

@@ -0,0 +1,2 @@
+export * from '../../math/vec2.ts';
+//# sourceMappingURL=vec2.d.ts.map

package/lib/export/math/vec2.js

@@ -0,0 +1,2 @@
+export * from "../../math/vec2.js";
+//# sourceMappingURL=vec2.js.map

package/lib/export/utils.d.ts

@@ -0,0 +1,5 @@
+export { assert } from '../utils/assert.ts';
+export { markEnum, DynamicEnum } from '../utils/enum.ts';
+export { isSubClassOfInclusive } from '../utils/inheritance.ts';
+export { dumpRaw } from '../utils/raw.ts';
+//# sourceMappingURL=utils.d.ts.map

package/lib/export/utils.js

@@ -0,0 +1,5 @@
+export { assert } from "../utils/assert.js";
+export { markEnum, DynamicEnum } from "../utils/enum.js";
+export { isSubClassOfInclusive } from "../utils/inheritance.js";
+export { dumpRaw } from "../utils/raw.js";
+//# sourceMappingURL=utils.js.map

package/lib/framework/component.d.ts

@@ -0,0 +1,90 @@
+import { Component, Node } from 'cc';
+import { AbortSignal } from '@cyclonium/abort-controller';
+import { type Coroutine, type CoroutineIterator, type StartCoroutineOptions } from './coroutine.ts';
+export declare class CycloComponent extends Component {
+    static of<TThis extends abstract new (...args: never[]) => CycloComponent>(this: TThis, componentOrNode: CycloComponent | Node): InstanceType<TThis>;
+    static ofOrNull<TThis extends abstract new (...args: never[]) => CycloComponent>(this: TThis, componentOrNode: CycloComponent | Node): InstanceType<TThis> | null;
+    static existsOn<TThis extends abstract new (...args: never[]) => CycloComponent>(this: TThis, componentOrNode: CycloComponent | Node): boolean;
+    /**
+       * @internal
+       */
+    _invokeFixedUpdate(deltaTime: number): void;
+    /**
+       * @internal
+       */
+    _invokeCoroutineUpdate(deltaTime: number): void;
+    protected get destroyingSignal(): AbortSignal;
+    protected get disablingSignal(): AbortSignal;
+    protected onAwake(): void;
+    protected onEnabled(): void;
+    protected onDisabled(): void;
+    protected onDestroy(): void;
+    protected onStart(): void;
+    protected onUpdate(_deltaTime: number): void;
+    protected onFixedUpdate(_deltaTime: number): void;
+    protected onLateUpdate(_deltaTime: number): void;
+    protected onFrameEnd(): void;
+    /**
+     * Starts a coroutine owned by this component.
+     * @param coroutine - Coroutine iterator to start.
+     * @param opts - Optional start options, including an abort signal that can stop the coroutine.
+     * @returns An opaque coroutine handle that can be passed to `stopCoroutine`.
+     * @description
+     * The coroutine starts immediately and runs until its first yield before this
+     * method returns. Component `enabled = false` does not pause it; it is stopped
+     * when the owning node becomes inactive in hierarchy or when the component is destroyed.
+     * Coroutines resume after all component `onUpdate` calls and before fixed updates.
+     * @example
+     * ```ts
+     * protected override onStart(): void {
+     *   this.startCoroutine(this.destroyLater());
+     * }
+     *
+     * private *destroyLater(): CoroutineIterator {
+     *   yield waitFor(1);
+     *   this.node.destroy();
+     * }
+     * ```
+     */
+    protected startCoroutine(coroutine: CoroutineIterator, opts?: StartCoroutineOptions): Coroutine;
+    /**
+     * Stops a coroutine handle.
+     * @param coroutine - Coroutine handle returned by `startCoroutine`.
+     * @description
+     * Stopping marks the coroutine so it will not resume on later frames. If this
+     * is called while that same coroutine is currently executing, it does not abort
+     * the current call stack; code after the stop call keeps running until the
+     * coroutine yields or returns.
+     */
+    protected stopCoroutine(coroutine: Coroutine): void;
+    /**
+     * Stops all coroutines owned by this component.
+     * @description
+     * Existing coroutines are marked as stopped and will not resume on later frames.
+     * Calling this from inside a coroutine does not abort the current call stack;
+     * the currently executing body keeps running until it yields or returns.
+     * Coroutines started during stop cleanup are treated as new coroutines and are
+     * not included in the batch being stopped.
+     */
+    protected stopAllCoroutines(): void;
+    protected onLoad(): void;
+    /**
+     * @internal
+     */
+    protected onEnable(): void;
+    /**
+     * @internal
+     */
+    protected onDisable(): void;
+    protected start(): void;
+    protected lateUpdate(deltaTime: number): void;
+    /**
+     * @deprecated
+     */
+    protected update(deltaTime: number): void;
+    private _coroutines;
+    private _disablingController;
+    private _destroyingController;
+    private _clearCoroutinesIfEmpty;
+}
+//# sourceMappingURL=component.d.ts.map

package/lib/framework/component.js

@@ -0,0 +1,322 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var CycloComponent_1;
+import { Component, director, Node } from 'cc';
+import { cycloBuiltinClass } from "../decorator/legacy/legacy-general-decorator.js";
+import { AbortController, AbortSignal } from '@cyclonium/abort-controller';
+import { addFrameTask, TaskPriority } from "./tasking.js";
+import { CoroutineRunner, stopCoroutine as stopCoroutineRecord } from "./coroutine.js";
+import { prune } from '@cyclonium/algorithm/prune';
+import { EDITOR_NOT_IN_PREVIEW } from 'cc/env';
+class ComponentScheduler {
+    enableComponent(component) {
+        const index = this._fixedUpdateRegistry.findIndex(({ component: c }) => c === component);
+        if (index < 0) {
+            this._fixedUpdateRegistry.push({ component, enabled: true });
+        }
+        else {
+            this._fixedUpdateRegistry[index].enabled = true;
+        }
+    }
+    disableComponent(component) {
+        const index = this._fixedUpdateRegistry.findIndex(({ component: c }) => c === component);
+        if (index >= 0) {
+            this._fixedUpdateRegistry[index].enabled = false;
+        }
+    }
+    prune() {
+        prune(this._fixedUpdateRegistry, ({ enabled }) => enabled);
+        prune(this._coroutineUpdateRegistry, ({ enabled }) => enabled);
+    }
+    invokeFixedUpdate(deltaTime) {
+        for (const { component, enabled } of this._fixedUpdateRegistry) {
+            if (enabled) {
+                invokeComponentFixedUpdate(component, deltaTime);
+            }
+        }
+    }
+    enableCoroutineUpdate(component) {
+        const index = this._coroutineUpdateRegistry.findIndex(({ component: c }) => c === component);
+        if (index < 0) {
+            this._coroutineUpdateRegistry.push({ component, enabled: true });
+        }
+        else {
+            this._coroutineUpdateRegistry[index].enabled = true;
+        }
+    }
+    disableCoroutineUpdate(component) {
+        const index = this._coroutineUpdateRegistry.findIndex(({ component: c }) => c === component);
+        if (index >= 0) {
+            this._coroutineUpdateRegistry[index].enabled = false;
+        }
+    }
+    invokeCoroutineUpdate(deltaTime) {
+        const count = this._coroutineUpdateRegistry.length;
+        for (let i = 0; i < count; i++) {
+            const { component, enabled } = this._coroutineUpdateRegistry[i];
+            if (enabled) {
+                invokeComponentCoroutineUpdate(component, deltaTime);
+            }
+        }
+    }
+    _fixedUpdateRegistry = [];
+    _coroutineUpdateRegistry = [];
+}
+const globalComponentScheduler = new ComponentScheduler();
+let invokeComponentFixedUpdate;
+let invokeComponentCoroutineUpdate;
+let CycloComponent = class CycloComponent extends Component {
+    static { CycloComponent_1 = this; }
+    static of(componentOrNode) {
+        const instance = (componentOrNode instanceof Component ? componentOrNode.node : componentOrNode).getComponent(this);
+        if (!instance) {
+            throw new Error(`Component ${this.name} is not attached to entity ${componentOrNode.name}.`);
+        }
+        return instance;
+    }
+    static ofOrNull(componentOrNode) {
+        return (componentOrNode instanceof Component ? componentOrNode.node : componentOrNode).getComponent(this) ?? null;
+    }
+    static existsOn(componentOrNode) {
+        return !!((componentOrNode instanceof Component ? componentOrNode.node : componentOrNode).getComponent(this));
+    }
+    /**
+       * @internal
+       */
+    _invokeFixedUpdate(deltaTime) {
+        this.onFixedUpdate(deltaTime);
+    }
+    /**
+       * @internal
+       */
+    _invokeCoroutineUpdate(deltaTime) {
+        if (!this._coroutines) {
+            return;
+        }
+        if (!this.node.activeInHierarchy) {
+            this.stopAllCoroutines();
+            return;
+        }
+        this._coroutines.update(deltaTime);
+        this._clearCoroutinesIfEmpty();
+    }
+    get destroyingSignal() {
+        return (this._destroyingController ??= new AbortController()).signal;
+    }
+    get disablingSignal() {
+        return (this._disablingController ??= new AbortController()).signal;
+    }
+    onAwake() { }
+    onEnabled() { }
+    onDisabled() { }
+    onDestroy() {
+        this.stopAllCoroutines();
+        this._destroyingController?.abort();
+        this._destroyingController = undefined;
+    }
+    onStart() { }
+    onUpdate(_deltaTime) { }
+    onFixedUpdate(_deltaTime) { }
+    onLateUpdate(_deltaTime) { }
+    onFrameEnd() { }
+    /**
+     * Starts a coroutine owned by this component.
+     * @param coroutine - Coroutine iterator to start.
+     * @param opts - Optional start options, including an abort signal that can stop the coroutine.
+     * @returns An opaque coroutine handle that can be passed to `stopCoroutine`.
+     * @description
+     * The coroutine starts immediately and runs until its first yield before this
+     * method returns. Component `enabled = false` does not pause it; it is stopped
+     * when the owning node becomes inactive in hierarchy or when the component is destroyed.
+     * Coroutines resume after all component `onUpdate` calls and before fixed updates.
+     * @example
+     * ```ts
+     * protected override onStart(): void {
+     *   this.startCoroutine(this.destroyLater());
+     * }
+     *
+     * private *destroyLater(): CoroutineIterator {
+     *   yield waitFor(1);
+     *   this.node.destroy();
+     * }
+     * ```
+     */
+    startCoroutine(coroutine, opts) {
+        const coroutines = this._coroutines ??= new CoroutineRunner();
+        const handle = coroutines.start(coroutine, opts);
+        if (!coroutines.empty) {
+            globalComponentScheduler.enableCoroutineUpdate(this);
+        }
+        this._clearCoroutinesIfEmpty();
+        return handle;
+    }
+    /**
+     * Stops a coroutine handle.
+     * @param coroutine - Coroutine handle returned by `startCoroutine`.
+     * @description
+     * Stopping marks the coroutine so it will not resume on later frames. If this
+     * is called while that same coroutine is currently executing, it does not abort
+     * the current call stack; code after the stop call keeps running until the
+     * coroutine yields or returns.
+     */
+    stopCoroutine(coroutine) {
+        if (this._coroutines) {
+            this._coroutines.stop(coroutine);
+        }
+        else {
+            stopCoroutineRecord(coroutine);
+        }
+        this._clearCoroutinesIfEmpty();
+    }
+    /**
+     * Stops all coroutines owned by this component.
+     * @description
+     * Existing coroutines are marked as stopped and will not resume on later frames.
+     * Calling this from inside a coroutine does not abort the current call stack;
+     * the currently executing body keeps running until it yields or returns.
+     * Coroutines started during stop cleanup are treated as new coroutines and are
+     * not included in the batch being stopped.
+     */
+    stopAllCoroutines() {
+        const coroutines = this._coroutines;
+        if (!coroutines) {
+            return;
+        }
+        this._coroutines = undefined;
+        globalComponentScheduler.disableCoroutineUpdate(this);
+        coroutines.stopAll();
+    }
+    onLoad() {
+        this.onAwake();
+    }
+    /**
+     * @internal
+     */
+    onEnable() {
+        globalComponentScheduler.enableComponent(this);
+        this.onEnabled();
+    }
+    /**
+     * @internal
+     */
+    onDisable() {
+        globalComponentScheduler.disableComponent(this);
+        if (!this.node.activeInHierarchy) {
+            this.stopAllCoroutines();
+        }
+        this.onDisabled();
+        this._disablingController?.abort();
+        this._disablingController = undefined;
+    }
+    start() {
+        this.onStart();
+    }
+    lateUpdate(deltaTime) {
+        this.onLateUpdate(deltaTime);
+        this.onFrameEnd();
+    }
+    /**
+     * @deprecated
+     */
+    update(deltaTime) {
+        this.onUpdate(deltaTime);
+    }
+    _coroutines = undefined;
+    _disablingController = undefined;
+    _destroyingController = undefined;
+    _clearCoroutinesIfEmpty() {
+        if (this._coroutines?.empty) {
+            this._coroutines = undefined;
+            globalComponentScheduler.disableCoroutineUpdate(this);
+        }
+    }
+    static {
+        invokeComponentFixedUpdate = (component, deltaTime) => {
+            if (component.onFixedUpdate !== CycloComponent_1.prototype.onFixedUpdate) {
+                component.onFixedUpdate(deltaTime);
+            }
+        };
+        invokeComponentCoroutineUpdate = (component, deltaTime) => {
+            component._invokeCoroutineUpdate(deltaTime);
+        };
+    }
+};
+CycloComponent = CycloComponent_1 = __decorate([
+    cycloBuiltinClass({ abstract: true })
+], CycloComponent);
+export { CycloComponent };
+class CoroutineUpdateTask {
+    update(deltaTime) {
+        globalComponentScheduler.invokeCoroutineUpdate(deltaTime);
+    }
+}
+class FixedUpdateTask {
+    maxSteps = 2;
+    update(deltaTime) {
+        const scene = director.getScene();
+        if (!scene) {
+            this._accumulatedTime = 0;
+            return;
+        }
+        const fixedTimeStep = this._fixedTimeStep;
+        const maxSteps = this.maxSteps;
+        const accumulatedTime = this._accumulatedTime + deltaTime;
+        const expectedSteps = Math.floor(accumulatedTime / fixedTimeStep);
+        const overloading = expectedSteps > maxSteps;
+        const previousOverloading = this._overloading;
+        this._overloading = overloading;
+        let actualSteps = 0;
+        if (overloading) {
+            actualSteps = maxSteps;
+            this._accumulatedTime = 0;
+            if (overloading !== previousOverloading) {
+                this._emitOverloadingBegin(expectedSteps);
+            }
+        }
+        else {
+            actualSteps = expectedSteps;
+            this._accumulatedTime = accumulatedTime - actualSteps * fixedTimeStep;
+            if (overloading !== previousOverloading) {
+                this._emitOverloadingEnd();
+            }
+        }
+        for (let i = 0; i < actualSteps; i++) {
+            globalComponentScheduler.invokeFixedUpdate(fixedTimeStep);
+        }
+    }
+    _fixedTimeStep = 1 / 60;
+    _accumulatedTime = 0;
+    _overloading = false;
+    _emitOverloadingBegin(expectedSteps) {
+        // todo
+        void expectedSteps;
+    }
+    _emitOverloadingEnd() {
+        // todo
+    }
+}
+if (!EDITOR_NOT_IN_PREVIEW) {
+    const fixedUpdatePriority = TaskPriority.before(TaskPriority.predefined.componentsLateUpdate);
+    addFrameTask({
+        thisArg: new CoroutineUpdateTask(),
+        priority: TaskPriority.between(fixedUpdatePriority, TaskPriority.predefined.componentsLateUpdate),
+        fn: CoroutineUpdateTask.prototype.update,
+    });
+    addFrameTask({
+        thisArg: new FixedUpdateTask(),
+        priority: fixedUpdatePriority,
+        fn: FixedUpdateTask.prototype.update,
+    });
+    addFrameTask({
+        thisArg: undefined,
+        priority: TaskPriority.after(TaskPriority.predefined.componentsLateUpdate),
+        fn: () => {
+            globalComponentScheduler.prune();
+        },
+    });
+}
+//# sourceMappingURL=component.js.map

package/lib/framework/coroutine.d.ts

@@ -0,0 +1,105 @@
+import type { AbortSignal } from '@cyclonium/abort-controller';
+/**
+ * Frame data passed back when a coroutine resumes.
+ */
+export interface CoroutineFrame {
+    /**
+     * Time elapsed since the previous coroutine update, in seconds.
+     */
+    readonly deltaTime: number;
+    /**
+     * Time elapsed since this coroutine started, in seconds.
+     */
+    readonly elapsedTime: number;
+    /**
+     * Number of coroutine update frames since the owner component started running coroutines.
+     */
+    readonly frame: number;
+}
+declare const CoroutineBrand: unique symbol;
+/**
+ * Handle returned by `startCoroutine`.
+ * @description
+ * This is an opaque handle. Store it if you need to stop the coroutine later,
+ * and pass it back to `stopCoroutine`; do not inspect or construct it yourself.
+ */
+export interface Coroutine {
+    readonly [CoroutineBrand]: never;
+}
+/**
+ * Yield instruction returned by coroutine wait helpers.
+ * @description
+ * This is an opaque token produced by helpers such as `nextFrame` and `waitFor`.
+ * Yield it from a coroutine to tell the scheduler when the coroutine should resume.
+ */
+export interface CoroutineInstruction {
+    readonly __brand: unique symbol;
+}
+/**
+ * Iterator shape accepted by `startCoroutine`.
+ * @description
+ * A coroutine yields `CoroutineInstruction`, `null`, or `undefined`. When it resumes,
+ * the yielded expression receives a `CoroutineFrame` describing the current frame.
+ */
+export type CoroutineIterator = IterableIterator<CoroutineYield, void, CoroutineFrame>;
+/**
+ * Predicate evaluated with the current coroutine frame.
+ * @param frame - The frame data for the coroutine update being evaluated.
+ */
+export type CoroutinePredicate = (frame: CoroutineFrame) => boolean;
+type CoroutineYield = CoroutineInstruction | null | undefined;
+/**
+ * Options used when starting a coroutine.
+ */
+export interface StartCoroutineOptions {
+    /**
+     * Abort signal that stops the coroutine when aborted.
+     * @description
+     * If the signal is already aborted, the coroutine is stopped immediately after creation.
+     * Aborting the signal later has the same effect as stopping this coroutine handle.
+     */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Resume the coroutine on the next coroutine update.
+ * @returns An opaque instruction to yield from a coroutine.
+ */
+export declare function nextFrame(): CoroutineInstruction;
+/**
+ * Resume the coroutine after at least the given duration.
+ * @param seconds - Duration to wait, in seconds. Must be a non-negative finite number.
+ * @returns An opaque instruction to yield from a coroutine.
+ */
+export declare function waitFor(seconds: number): CoroutineInstruction;
+/**
+ * Resume the coroutine when the predicate becomes true.
+ * @param predicate - Function evaluated each coroutine update with the current frame.
+ * @returns An opaque instruction to yield from a coroutine.
+ */
+export declare function waitUntil(predicate: CoroutinePredicate): CoroutineInstruction;
+/**
+ * Resume the coroutine when the predicate becomes false.
+ * @param predicate - Function evaluated each coroutine update with the current frame.
+ * @returns An opaque instruction to yield from a coroutine.
+ */
+export declare function waitWhile(predicate: CoroutinePredicate): CoroutineInstruction;
+export declare class CoroutineRunner {
+    start(coroutine: CoroutineIterator, opts?: StartCoroutineOptions): Coroutine;
+    update(deltaTime: number): void;
+    stop(handle: Coroutine): void;
+    stopAll(): void;
+    get frame(): number;
+    get deltaTime(): number;
+    get empty(): boolean;
+    private _records;
+    private _frame;
+    private _deltaTime;
+    private _pruneDeferralDepth;
+    private _beginPruneDeferral;
+    private _endPruneDeferral;
+    private _pruneIfNotDeferred;
+    private _prune;
+}
+export declare function stopCoroutine(coroutine: Coroutine): void;
+export {};
+//# sourceMappingURL=coroutine.d.ts.map