@twick/core 0.11.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 motion-canvas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/app/Logger.d.ts

@@ -0,0 +1,105 @@
+export declare enum LogLevel {
+    Error = "error",
+    Warn = "warn",
+    Info = "info",
+    Http = "http",
+    Verbose = "verbose",
+    Debug = "debug",
+    Silly = "silly"
+}
+/**
+ * Represents an individual log entry.
+ *
+ * @remarks
+ * When displayed in the editor, the log entry will have the following format:
+ * ```
+ *                              inspect node ┐
+ *   ┌ expand more          duration ┐       │
+ *   ▼                               ▼       ▼
+ * ┌────────────────────────────────────────────┐
+ * │ ▶ message                       300 ms (+) │
+ * ├────────────────────────────────────────────┤
+ * │ remarks                                    │
+ * │ object                                     │
+ * │ stacktrace                                 │
+ * └────────────────────────────────────────────┘
+ * ```
+ */
+export interface LogPayload {
+    /**
+     * The log level.
+     */
+    level?: LogLevel;
+    /**
+     * The main message of the log.
+     *
+     * @remarks
+     * Always visible.
+     */
+    message: string;
+    /**
+     * Additional information about the log.
+     *
+     * @remarks
+     * Visible only when the log is expanded.
+     */
+    remarks?: string;
+    /**
+     * An object that will be serialized as JSON and displayed under the message.
+     *
+     * @remarks
+     * Visible only when the log is expanded.
+     */
+    object?: any;
+    /**
+     * The stack trace of the log.
+     *
+     * @remarks
+     * Visible only when the log is expanded.
+     * The current stack trace can be obtained using `new Error().stack`.
+     * Both Chromium and Firefox stack traces are supported.
+     */
+    stack?: string;
+    /**
+     * An optional duration in milliseconds.
+     *
+     * @remarks
+     * Can be used to display any duration related to the log.
+     * The value is always visible next to the message.
+     */
+    durationMs?: number;
+    /**
+     * An optional key used to inspect a related object.
+     *
+     * @remarks
+     * This will be used together with the {@link scenes.Inspectable} interface to
+     * display additional information about the inspected object.
+     * When specified, the log will have an "inspect" button that will open the
+     * "Properties" tab and select the inspected object.
+     */
+    inspect?: string;
+    /**
+     * Any additional information that the log may contain.
+     */
+    [K: string]: any;
+}
+export declare class Logger {
+    /**
+     * Triggered when a new message is logged.
+     */
+    get onLogged(): import("../events").Subscribable<LogPayload, import("../events").EventHandler<LogPayload>>;
+    private readonly logged;
+    readonly history: LogPayload[];
+    private profilers;
+    log(payload: LogPayload): void;
+    error(payload: string | LogPayload): void;
+    warn(payload: string | LogPayload): void;
+    info(payload: string | LogPayload): void;
+    http(payload: string | LogPayload): void;
+    verbose(payload: string | LogPayload): void;
+    debug(payload: string | LogPayload): void;
+    silly(payload: string | LogPayload): void;
+    protected logLevel(level: LogLevel, payload: string | LogPayload): void;
+    profile(id: string, payload?: LogPayload): void;
+}
+//# sourceMappingURL=Logger.d.ts.map

package/lib/app/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../src/app/Logger.ts"],"names":[],"mappings":"AAEA,oBAAY,QAAQ;IAClB,KAAK,UAAU;IACf,IAAI,SAAS;IACb,IAAI,SAAS;IACb,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,KAAK,CAAC,EAAE,QAAQ,CAAC;IAEjB;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,GAAG,CAAC;IAEb;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;CAClB;AAED,qBAAa,MAAM;IACjB;;OAEG;IACH,IAAW,QAAQ,+FAElB;IACD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqC;IAC5D,SAAgB,OAAO,EAAE,UAAU,EAAE,CAAM;IAE3C,OAAO,CAAC,SAAS,CAA8B;IAExC,GAAG,CAAC,OAAO,EAAE,UAAU;IAKvB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAclC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAQjC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAQjC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAQjC,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAQpC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAIlC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAQzC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU;IAMzD,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU;CAgBhD"}

package/lib/app/Logger.js

@@ -0,0 +1,77 @@
+import { EventDispatcher } from '../events';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["Error"] = "error";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Info"] = "info";
+    LogLevel["Http"] = "http";
+    LogLevel["Verbose"] = "verbose";
+    LogLevel["Debug"] = "debug";
+    LogLevel["Silly"] = "silly";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    constructor() {
+        this.logged = new EventDispatcher();
+        this.history = [];
+        this.profilers = {};
+    }
+    /**
+     * Triggered when a new message is logged.
+     */
+    get onLogged() {
+        return this.logged.subscribable;
+    }
+    log(payload) {
+        this.logged.dispatch(payload);
+        this.history.push(payload);
+    }
+    error(payload) {
+        console.error('error from browser process:', typeof payload === 'string' ? payload : payload.message);
+        this.logLevel(LogLevel.Error, payload);
+        if (window.browserError) {
+            window.browserError(typeof payload === 'string' ? payload : payload.message);
+        }
+    }
+    warn(payload) {
+        console.warn('warning from browser process:', typeof payload === 'string' ? payload : payload.message);
+        this.logLevel(LogLevel.Warn, payload);
+    }
+    info(payload) {
+        console.info('info from browser process:', typeof payload === 'string' ? payload : payload.message);
+        this.logLevel(LogLevel.Info, payload);
+    }
+    http(payload) {
+        console.log('http log from browser process:', typeof payload === 'string' ? payload : payload.message);
+        this.logLevel(LogLevel.Http, payload);
+    }
+    verbose(payload) {
+        console.log('verbose log from browser process:', typeof payload === 'string' ? payload : payload.message);
+        this.logLevel(LogLevel.Verbose, payload);
+    }
+    debug(payload) {
+        this.logLevel(LogLevel.Debug, payload);
+    }
+    silly(payload) {
+        console.log('silly log from browser process:', typeof payload === 'string' ? payload : payload.message);
+        this.logLevel(LogLevel.Silly, payload);
+    }
+    logLevel(level, payload) {
+        const result = typeof payload === 'string' ? { message: payload } : payload;
+        result.level = level;
+        this.log(result);
+    }
+    profile(id, payload) {
+        const time = performance.now();
+        if (this.profilers[id]) {
+            const timeEnd = this.profilers[id];
+            delete this.profilers[id];
+            const result = payload ?? { message: id };
+            result.level ?? (result.level = LogLevel.Debug);
+            result.durationMs = time - timeEnd;
+            this.log(result);
+            return;
+        }
+        this.profilers[id] = time;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/app/PlaybackManager.d.ts

@@ -0,0 +1,55 @@
+import type { Scene, SceneDescriptionReload, Slide } from '../scenes';
+export declare enum PlaybackState {
+    Playing = 0,
+    Rendering = 1,
+    Paused = 2,
+    Presenting = 3
+}
+/**
+ * A general class for managing a sequence of scenes.
+ *
+ * @remarks
+ * This class provides primitive operations that can be executed on a scene
+ * sequence, such as {@link progress} or {@link seek}.
+ *
+ * @internal
+ */
+export declare class PlaybackManager {
+    /**
+     * Triggered when the active scene changes.
+     *
+     * @eventProperty
+     */
+    get onSceneChanged(): import("../events").SubscribableValueEvent<Scene<unknown>>;
+    /**
+     * Triggered when the scenes get recalculated.
+     *
+     * @remarks
+     * This event indicates that the timing of at least one scene has changed.
+     *
+     * @eventProperty
+     */
+    get onScenesRecalculated(): import("../events").SubscribableValueEvent<Scene<unknown>[]>;
+    frame: number;
+    speed: number;
+    fps: number;
+    duration: number;
+    finished: boolean;
+    slides: Slide[];
+    previousScene: Scene | null;
+    state: PlaybackState;
+    get currentScene(): Scene;
+    set currentScene(scene: Scene);
+    private currentSceneReference;
+    private scenes;
+    setup(scenes: Scene[]): void;
+    progress(): Promise<boolean>;
+    seek(frame: number): Promise<boolean>;
+    reset(): Promise<void>;
+    reload(description?: SceneDescriptionReload<never>): void;
+    recalculate(): Promise<void>;
+    private next;
+    private findBestScene;
+    private getNextScene;
+}
+//# sourceMappingURL=PlaybackManager.d.ts.map

package/lib/app/PlaybackManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlaybackManager.d.ts","sourceRoot":"","sources":["../../src/app/PlaybackManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,KAAK,EAAE,sBAAsB,EAAE,KAAK,EAAC,MAAM,WAAW,CAAC;AAEpE,oBAAY,aAAa;IACvB,OAAO,IAAA;IACP,SAAS,IAAA;IACT,MAAM,IAAA;IACN,UAAU,IAAA;CACX;AAED;;;;;;;;GAQG;AACH,qBAAa,eAAe;IAC1B;;;;OAIG;IACH,IAAW,cAAc,+DAKxB;IAED;;;;;;;OAOG;IACH,IAAW,oBAAoB,iEAE9B;IAEM,KAAK,SAAK;IACV,KAAK,SAAK;IACV,GAAG,SAAM;IACT,QAAQ,SAAK;IACb,QAAQ,UAAS;IACjB,MAAM,EAAE,KAAK,EAAE,CAAM;IAErB,aAAa,EAAE,KAAK,GAAG,IAAI,CAAQ;IACnC,KAAK,gBAAwB;IAEpC,IAAW,YAAY,IAAI,KAAK,CAK/B;IAED,IAAW,YAAY,CAAC,KAAK,EAAE,KAAK,EAMnC;IAED,OAAO,CAAC,qBAAqB,CAAuC;IACpE,OAAO,CAAC,MAAM,CAAoC;IAE3C,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE;IAKf,QAAQ;IAKR,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA4BrC,KAAK;IAOX,MAAM,CAAC,WAAW,CAAC,EAAE,sBAAsB,CAAC,KAAK,CAAC;IAI5C,WAAW;YAyBV,IAAI;IAmClB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,YAAY;CAYrB"}

package/lib/app/PlaybackManager.js

@@ -0,0 +1,179 @@
+import { ValueDispatcher } from '../events';
+export var PlaybackState;
+(function (PlaybackState) {
+    PlaybackState[PlaybackState["Playing"] = 0] = "Playing";
+    PlaybackState[PlaybackState["Rendering"] = 1] = "Rendering";
+    PlaybackState[PlaybackState["Paused"] = 2] = "Paused";
+    PlaybackState[PlaybackState["Presenting"] = 3] = "Presenting";
+})(PlaybackState || (PlaybackState = {}));
+/**
+ * A general class for managing a sequence of scenes.
+ *
+ * @remarks
+ * This class provides primitive operations that can be executed on a scene
+ * sequence, such as {@link progress} or {@link seek}.
+ *
+ * @internal
+ */
+export class PlaybackManager {
+    constructor() {
+        this.frame = 0;
+        this.speed = 1;
+        this.fps = 30;
+        this.duration = 0;
+        this.finished = false;
+        this.slides = [];
+        this.previousScene = null;
+        this.state = PlaybackState.Paused;
+        this.currentSceneReference = null;
+        this.scenes = new ValueDispatcher([]);
+    }
+    /**
+     * Triggered when the active scene changes.
+     *
+     * @eventProperty
+     */
+    get onSceneChanged() {
+        if (this.currentSceneReference === null) {
+            throw new Error('PlaybackManager has not been properly initialized');
+        }
+        return this.currentSceneReference.subscribable;
+    }
+    /**
+     * Triggered when the scenes get recalculated.
+     *
+     * @remarks
+     * This event indicates that the timing of at least one scene has changed.
+     *
+     * @eventProperty
+     */
+    get onScenesRecalculated() {
+        return this.scenes.subscribable;
+    }
+    get currentScene() {
+        if (this.currentSceneReference === null) {
+            throw new Error('PlaybackManager has not been properly initialized');
+        }
+        return this.currentSceneReference.current;
+    }
+    set currentScene(scene) {
+        if (!scene) {
+            throw new Error('Invalid scene.');
+        }
+        this.currentSceneReference ?? (this.currentSceneReference = new ValueDispatcher(scene));
+        this.currentSceneReference.current = scene;
+    }
+    setup(scenes) {
+        this.scenes.current = scenes;
+        this.currentScene = scenes[0];
+    }
+    async progress() {
+        this.finished = await this.next();
+        return this.finished;
+    }
+    async seek(frame) {
+        if (frame <= this.frame ||
+            (this.currentScene.isCached() && this.currentScene.lastFrame < frame)) {
+            const scene = this.findBestScene(frame);
+            if (scene !== this.currentScene) {
+                this.currentScene.stopAllMedia();
+                this.previousScene = null;
+                this.currentScene = scene;
+                this.frame = this.currentScene.firstFrame;
+                await this.currentScene.reset();
+            }
+            else if (this.frame >= frame) {
+                this.previousScene = null;
+                this.frame = this.currentScene.firstFrame;
+                await this.currentScene.reset();
+            }
+        }
+        this.finished = false;
+        while (this.frame < frame && !this.finished) {
+            this.finished = await this.next();
+        }
+        return this.finished;
+    }
+    async reset() {
+        this.previousScene = null;
+        this.currentScene = this.scenes.current[0];
+        this.frame = 0;
+        await this.currentScene.reset();
+    }
+    reload(description) {
+        this.scenes.current.forEach(scene => scene.reload(description));
+    }
+    async recalculate() {
+        this.previousScene = null;
+        this.slides = [];
+        const speed = this.speed;
+        this.frame = 0;
+        this.speed = 1;
+        const scenes = [];
+        try {
+            for (const scene of this.scenes.current) {
+                await scene.recalculate(frame => {
+                    this.frame = frame;
+                });
+                this.slides.push(...scene.slides.onChanged.current);
+                scenes.push(scene);
+            }
+        }
+        finally {
+            this.speed = speed;
+        }
+        this.scenes.current = scenes;
+        this.duration = this.frame;
+    }
+    async next() {
+        if (this.previousScene) {
+            await this.previousScene.next();
+            if (this.currentScene.isFinished()) {
+                this.previousScene = null;
+            }
+        }
+        this.frame += this.speed;
+        if (this.currentScene.isFinished()) {
+            return true;
+        }
+        await this.currentScene.next();
+        if (this.previousScene && this.currentScene.isAfterTransitionIn()) {
+            this.previousScene = null;
+        }
+        if (this.currentScene.canTransitionOut()) {
+            this.previousScene = this.currentScene;
+            const nextScene = this.getNextScene(this.previousScene);
+            if (nextScene) {
+                this.previousScene.stopAllMedia();
+                this.currentScene = nextScene;
+                await this.currentScene.reset(this.previousScene);
+            }
+            if (!nextScene || this.currentScene.isAfterTransitionIn()) {
+                this.previousScene = null;
+            }
+        }
+        return this.currentScene.isFinished();
+    }
+    findBestScene(frame) {
+        let lastScene = this.scenes.current[0];
+        for (const scene of this.scenes.current) {
+            if (!scene.isCached() || scene.lastFrame > frame) {
+                return scene;
+            }
+            lastScene = scene;
+        }
+        return lastScene;
+    }
+    getNextScene(scene) {
+        const scenes = this.scenes.current;
+        if (!scene) {
+            return scenes[0];
+        }
+        const index = scenes.findIndex(s => s === scene);
+        if (index < 0) {
+            return null;
+        }
+        return scenes[index + 1] ?? null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/app/PlaybackStatus.d.ts

@@ -0,0 +1,30 @@
+import type { PlaybackManager, PlaybackState } from './PlaybackManager';
+/**
+ * A read-only representation of the playback.
+ */
+export declare class PlaybackStatus {
+    private readonly playback;
+    constructor(playback: PlaybackManager);
+    /**
+     * Convert seconds to frames using the current framerate.
+     *
+     * @param seconds - The seconds to convert.
+     */
+    secondsToFrames(seconds: number): number;
+    /**
+     * Convert frames to seconds using the current framerate.
+     *
+     * @param frames - The frames to convert.
+     */
+    framesToSeconds(frames: number): number;
+    get time(): number;
+    get frame(): number;
+    get speed(): number;
+    get fps(): number;
+    get state(): PlaybackState;
+    /**
+     * The time passed since the last frame in seconds.
+     */
+    get deltaTime(): number;
+}
+//# sourceMappingURL=PlaybackStatus.d.ts.map

package/lib/app/PlaybackStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlaybackStatus.d.ts","sourceRoot":"","sources":["../../src/app/PlaybackStatus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAE,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAEtE;;GAEG;AACH,qBAAa,cAAc;IACN,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,eAAe;IAE7D;;;;OAIG;IACI,eAAe,CAAC,OAAO,EAAE,MAAM;IAItC;;;;OAIG;IACI,eAAe,CAAC,MAAM,EAAE,MAAM;IAIrC,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,KAAK,IAAI,MAAM,CAEzB;IAED,IAAW,KAAK,IAAI,MAAM,CAEzB;IAED,IAAW,GAAG,IAAI,MAAM,CAEvB;IAED,IAAW,KAAK,IAAI,aAAa,CAEhC;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;CACF"}

package/lib/app/PlaybackStatus.js

@@ -0,0 +1,46 @@
+/**
+ * A read-only representation of the playback.
+ */
+export class PlaybackStatus {
+    constructor(playback) {
+        this.playback = playback;
+    }
+    /**
+     * Convert seconds to frames using the current framerate.
+     *
+     * @param seconds - The seconds to convert.
+     */
+    secondsToFrames(seconds) {
+        return Math.ceil(seconds * this.playback.fps);
+    }
+    /**
+     * Convert frames to seconds using the current framerate.
+     *
+     * @param frames - The frames to convert.
+     */
+    framesToSeconds(frames) {
+        return frames / this.playback.fps;
+    }
+    get time() {
+        return this.framesToSeconds(this.playback.frame);
+    }
+    get frame() {
+        return this.playback.frame;
+    }
+    get speed() {
+        return this.playback.speed;
+    }
+    get fps() {
+        return this.playback.fps;
+    }
+    get state() {
+        return this.playback.state;
+    }
+    /**
+     * The time passed since the last frame in seconds.
+     */
+    get deltaTime() {
+        return this.framesToSeconds(1) * this.speed;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGxheWJhY2tTdGF0dXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBwL1BsYXliYWNrU3RhdHVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLGNBQWM7SUFDekIsWUFBb0MsUUFBeUI7UUFBekIsYUFBUSxHQUFSLFFBQVEsQ0FBaUI7SUFBRyxDQUFDO0lBRWpFOzs7O09BSUc7SUFDSSxlQUFlLENBQUMsT0FBZTtRQUNwQyxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDaEQsQ0FBQztJQUVEOzs7O09BSUc7SUFDSSxlQUFlLENBQUMsTUFBYztRQUNuQyxPQUFPLE1BQU0sR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQztJQUNwQyxDQUFDO0lBRUQsSUFBVyxJQUFJO1FBQ2IsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDbkQsQ0FBQztJQUVELElBQVcsS0FBSztRQUNkLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUM7SUFDN0IsQ0FBQztJQUVELElBQVcsS0FBSztRQUNkLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUM7SUFDN0IsQ0FBQztJQUVELElBQVcsR0FBRztRQUNaLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUM7SUFDM0IsQ0FBQztJQUVELElBQVcsS0FBSztRQUNkLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUM7SUFDN0IsQ0FBQztJQUVEOztPQUVHO0lBQ0gsSUFBVyxTQUFTO1FBQ2xCLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQzlDLENBQUM7Q0FDRiJ9

package/lib/app/Player.d.ts

@@ -0,0 +1,130 @@
+import { Vector2 } from '../types';
+import type { Logger } from './Logger';
+import { PlaybackManager } from './PlaybackManager';
+import { PlaybackStatus } from './PlaybackStatus';
+import type { Project } from './Project';
+export interface PlayerState extends Record<string, unknown> {
+    paused: boolean;
+    loop: boolean;
+    muted: boolean;
+    volume: number;
+    speed: number;
+}
+export interface PlayerSettings {
+    range: [number, number];
+    fps: number;
+    size: Vector2;
+    resolutionScale: number;
+}
+/**
+ * The player logic used by the editor and embeddable player.
+ *
+ * @remarks
+ * This class builds on top of the `PlaybackManager` to provide a simple
+ * interface similar to other media players. It plays through the animation
+ * using a real-time update loop.
+ */
+export declare class Player {
+    private project;
+    private settings;
+    private initialState;
+    private initialFrame;
+    /**
+     * Triggered during each iteration of the update loop when the frame is ready
+     * to be rendered.
+     *
+     * @remarks
+     * Player does not perform any rendering on its own. For the animation to be
+     * visible, another class must subscribe to this event and perform the
+     * rendering itself. {@link Stage} can be used to display the animation.
+     *
+     * @eventProperty
+     */
+    get onRender(): import("../events").Subscribable<void, import("../events").AsyncEventHandler<void>>;
+    private readonly render;
+    get onStateChanged(): import("../events").SubscribableValueEvent<PlayerState>;
+    private readonly playerState;
+    get onFrameChanged(): import("../events").SubscribableValueEvent<number>;
+    private readonly frame;
+    get onDurationChanged(): import("../events").SubscribableValueEvent<number>;
+    private readonly duration;
+    /**
+     * Triggered right after recalculation finishes.
+     *
+     * @remarks
+     * Can be used to provide visual feedback.
+     *
+     * @eventProperty
+     */
+    get onRecalculated(): import("../events").Subscribable<void, import("../events").EventHandler<void>>;
+    private readonly recalculated;
+    readonly playback: PlaybackManager;
+    readonly status: PlaybackStatus;
+    readonly logger: Logger;
+    private readonly sharedWebGLContext;
+    private readonly lock;
+    private startTime;
+    private endTime;
+    private requestId;
+    private renderTime;
+    private requestedSeek;
+    private requestedRender;
+    private requestedRecalculation;
+    private size;
+    private resolutionScale;
+    private active;
+    private get startFrame();
+    private get endFrame();
+    private get finished();
+    constructor(project: Project, settings?: Partial<PlayerSettings>, initialState?: Partial<PlayerState>, initialFrame?: number);
+    configure(settings: PlayerSettings): Promise<void>;
+    /**
+     * Whether the given frame is inside the animation range.
+     *
+     * @param frame - The frame to check.
+     */
+    isInRange(frame: number): boolean;
+    /**
+     * Whether the given frame is inside the user-defined range.
+     *
+     * @param frame - The frame to check.
+     */
+    isInUserRange(frame: number): boolean;
+    requestSeek(value: number): void;
+    requestPreviousFrame(): void;
+    requestNextFrame(): void;
+    requestReset(): void;
+    requestRender(): void;
+    toggleLoop(value?: boolean): void;
+    togglePlayback(value?: boolean): void;
+    toggleAudio(value?: boolean): void;
+    setAudioVolume(value: number): void;
+    addAudioVolume(value: number): void;
+    setSpeed(value: number): void;
+    setVariables(variables: Record<string, unknown>): void;
+    /**
+     * Activate the player.
+     *
+     * @remarks
+     * A player needs to be active in order for the update loop to run. Each
+     * player is active by default.
+     */
+    activate(): void;
+    /**
+     * Deactivate the player.
+     *
+     * @remarks
+     * Deactivating the player prevents its update loop from running. This should
+     * be done before disposing the player, to prevent it from running in the
+     * background.
+     *
+     * Just pausing the player does not stop the loop.
+     */
+    deactivate(): void;
+    private requestRecalculation;
+    private prepare;
+    private run;
+    private request;
+    clampRange(frame: number): number;
+}
+//# sourceMappingURL=Player.d.ts.map