@rendley/sdk 1.0.1

package/dist/libs/ffmpeg/classes.d.ts

@@ -0,0 +1,201 @@
+import { DemuxerPacket, FFFSMountOptions, FFFSPath, FFFSType, FFMessageFrameData, FFMessageLoadConfig, FFMessageRenderSettings, FileData, FSNode, IsFirst, LogEventCallback, OK, ProgressEventCallback, FFMessageMuxerData, FFMessageInitMuxerData, FFMessageAuthentificateData } from './types';
+import { MediaInfo } from '../../modules/ffmpeg/types/FFmpeg.types';
+type FFMessageOptions = {
+    signal?: AbortSignal;
+};
+/**
+ * Provides APIs to interact with ffmpeg web worker.
+ *
+ * @example
+ * ```ts
+ * const ffmpeg = new FFmpeg();
+ * ```
+ */
+export declare class FFmpeg {
+    #private;
+    loaded: boolean;
+    /**
+     * Listen to log or prgress events from `ffmpeg.exec()`.
+     *
+     * @example
+     * ```ts
+     * ffmpeg.on("log", ({ type, message }) => {
+     *   // ...
+     * })
+     * ```
+     *
+     * @example
+     * ```ts
+     * ffmpeg.on("progress", ({ progress, time }) => {
+     *   // ...
+     * })
+     * ```
+     *
+     * @remarks
+     * - log includes output to stdout and stderr.
+     * - The progress events are accurate only when the length of
+     * input and output video/audio file are the same.
+     *
+     * @category FFmpeg
+     */
+    on(event: 'log', callback: LogEventCallback): void;
+    on(event: 'progress', callback: ProgressEventCallback): void;
+    /**
+     * Unlisten to log or prgress events from `ffmpeg.exec()`.
+     *
+     * @category FFmpeg
+     */
+    off(event: 'log', callback: LogEventCallback): void;
+    off(event: 'progress', callback: ProgressEventCallback): void;
+    /**
+     * Loads ffmpeg-core inside web worker. It is required to call this method first
+     * as it initializes WebAssembly and other essential variables.
+     *
+     * @category FFmpeg
+     * @returns `true` if ffmpeg core is loaded for the first time.
+     */
+    load: (config: FFMessageLoadConfig, { signal }?: FFMessageOptions) => Promise<IsFirst>;
+    /**
+     * Execute ffmpeg command.
+     *
+     * @remarks
+     * To avoid common I/O issues, ["-nostdin", "-y"] are prepended to the args
+     * by default.
+     *
+     * @example
+     * ```ts
+     * const ffmpeg = new FFmpeg();
+     * await ffmpeg.load();
+     * await ffmpeg.writeFile("video.avi", ...);
+     * // ffmpeg -i video.avi video.mp4
+     * await ffmpeg.exec(["-i", "video.avi", "video.mp4"]);
+     * const data = ffmpeg.readFile("video.mp4");
+     * ```
+     *
+     * @returns `0` if no error, `!= 0` if timeout (1) or error.
+     * @category FFmpeg
+     */
+    exec: (args: string[], timeout?: number, { signal }?: FFMessageOptions) => Promise<number>;
+    /**
+     * Terminate all ongoing API calls and terminate web worker.
+     * `FFmpeg.load()` must be called again before calling any other APIs.
+     *
+     * @category FFmpeg
+     */
+    terminate: () => void;
+    /**
+     * Write data to ffmpeg.wasm.
+     *
+     * @example
+     * ```ts
+     * const ffmpeg = new FFmpeg();
+     * await ffmpeg.load();
+     * await ffmpeg.writeFile("video.avi", await fetchFile("../video.avi"));
+     * await ffmpeg.writeFile("text.txt", "hello world");
+     * ```
+     *
+     * @category File System
+     */
+    writeFile: (path: string, data: FileData, { signal }?: FFMessageOptions) => Promise<OK>;
+    mount: (fsType: FFFSType, options: FFFSMountOptions, mountPoint: FFFSPath) => Promise<OK>;
+    unmount: (mountPoint: FFFSPath) => Promise<OK>;
+    /**
+     * Read data from ffmpeg.wasm.
+     *
+     * @example
+     * ```ts
+     * const ffmpeg = new FFmpeg();
+     * await ffmpeg.load();
+     * const data = await ffmpeg.readFile("video.mp4");
+     * ```
+     *
+     * @category File System
+     */
+    readFile: (path: string, encoding?: string, { signal }?: FFMessageOptions) => Promise<FileData>;
+    /**
+     * Delete a file.
+     *
+     * @category File System
+     */
+    deleteFile: (path: string, { signal }?: FFMessageOptions) => Promise<OK>;
+    /**
+     * Rename a file or directory.
+     *
+     * @category File System
+     */
+    rename: (oldPath: string, newPath: string, { signal }?: FFMessageOptions) => Promise<OK>;
+    /**
+     * Create a directory.
+     *
+     * @category File System
+     */
+    createDir: (path: string, { signal }?: FFMessageOptions) => Promise<OK>;
+    /**
+     * List directory contents.
+     *
+     * @category File System
+     */
+    listDir: (path: string, { signal }?: FFMessageOptions) => Promise<FSNode[]>;
+    /**
+     * Delete an empty directory.
+     *
+     * @category File System
+     */
+    deleteDir: (path: string, { signal }?: FFMessageOptions) => Promise<OK>;
+    prepareRenderer: (settings: FFMessageRenderSettings, { signal }?: FFMessageOptions) => Promise<OK>;
+    addFrameToRenderer: ({ data }: FFMessageFrameData, { signal }?: FFMessageOptions) => Promise<OK>;
+    cancelRenderer: ({ signal }?: FFMessageOptions) => Promise<OK>;
+    finalizeRenderer: ({ signal }?: FFMessageOptions) => Promise<OK>;
+    initDemuxer: (id: string, path: string, { signal }?: FFMessageOptions) => Promise<OK>;
+    closeDemuxer: (id: string, { signal }?: FFMessageOptions) => Promise<OK>;
+    seekDemuxer: (id: string, time: number, { signal }?: FFMessageOptions) => Promise<OK>;
+    getNextPacketDemuxer: (id: string, { signal }?: FFMessageOptions) => Promise<DemuxerPacket | undefined>;
+    initMuxer: (initSettings: FFMessageInitMuxerData, { signal }?: FFMessageOptions) => Promise<OK>;
+    addChunkMuxer: (data: FFMessageMuxerData, { signal }?: FFMessageOptions) => Promise<OK>;
+    closeMuxer: ({ signal }?: FFMessageOptions) => Promise<OK>;
+    authentificate: (data: FFMessageAuthentificateData, { signal }?: FFMessageOptions) => Promise<number>;
+    isAuthenticated: () => Promise<boolean>;
+    getAuthStatus: () => Promise<number>;
+    getAuthSecondsRemaining: () => Promise<number>;
+    getSettings: () => Promise<OK>;
+    /**
+     * Gets information about a media file.
+     *
+     * @example
+     * ```ts
+     * const ffmpeg = new FFmpeg();
+     * await ffmpeg.load();
+     * await ffmpeg.writeFile("video.avi", ...);
+     * const info = await ffmpeg.getMediaInfo("video.mp4");
+     * ```
+     *
+     * @returns an object with the following properties:
+     * - status: 'success' | 'error' (in case of error another property will be present 'error' with the error string)
+     * - path: the path of the media file
+     * - duration: the duration in seconds
+     * - format: the format of the media file
+     * - averageFps: the average fps of all the video streams
+     * - streamCount: the number of streams
+     * - streams: an array of objects with the following properties:
+     *   - index: the index of the stream
+     *   - codec: the codec of the stream
+     *   - type: 'video' | 'audio' | 'image' | 'gif' | 'subtitle' | 'data' | 'attachment' | 'unknown'
+     *   - format: the format of the stream
+     *   - duration: the duration in seconds
+     *   - bitrate: the bitrate in bits per second
+     *   - startTime: the start time in seconds
+     *  In case of videos:
+     *   - width: the width of the video
+     *   - height: the height of the video
+     *   - rotation: the rotation of the video
+     *   - averageFps: the average fps of the video
+     *   - frameCount: the number of frames in the video
+     *  In case of audio:
+     *   - sampleRate: the sample rate of the audio
+     *   - channelCount: the number of channels in the audio
+     * @category FFmpeg
+     */
+    getMediaInfo: (path: string, { signal }?: FFMessageOptions) => Promise<MediaInfo>;
+    getMediaSubtitles: (path: string, { signal }?: FFMessageOptions) => Promise<string>;
+}
+export {};

package/dist/libs/ffmpeg/config.d.ts

@@ -0,0 +1,2 @@
+import { FFMessageLoadConfig } from './types';
+export declare const FFMPEG_CORE_CONFIG: FFMessageLoadConfig;

package/dist/libs/ffmpeg/const.d.ts

@@ -0,0 +1,37 @@
+export declare const MIME_TYPE_JAVASCRIPT = "text/javascript";
+export declare const MIME_TYPE_WASM = "application/wasm";
+export declare const CORE_URL: string;
+export declare enum FFMessageType {
+    LOAD = "LOAD",
+    EXEC = "EXEC",
+    WRITE_FILE = "WRITE_FILE",
+    READ_FILE = "READ_FILE",
+    DELETE_FILE = "DELETE_FILE",
+    RENAME = "RENAME",
+    CREATE_DIR = "CREATE_DIR",
+    LIST_DIR = "LIST_DIR",
+    DELETE_DIR = "DELETE_DIR",
+    ERROR = "ERROR",
+    DOWNLOAD = "DOWNLOAD",
+    PROGRESS = "PROGRESS",
+    LOG = "LOG",
+    MOUNT = "MOUNT",
+    UNMOUNT = "UNMOUNT",
+    RENDER_PREPARE = "RENDER_PREPARE",
+    RENDER_CANCEL = "RENDER_CANCEL",
+    RENDER_FINALIZE = "RENDER_FINALIZE",
+    RENDER_ADDFRAME = "RENDER_ADDFRAME",
+    GET_INFO = "GET_INFO",
+    GET_SUBTITLES = "GET_SUBTITLES",
+    DEMUXER_INIT = "DEMUXER_INIT",
+    DEMUXER_SEEK = "DEMUXER_SEEK",
+    DEMUXER_CLOSE = "DEMUXER_CLOSE",
+    DEMUXER_GETPACKET = "DEMUXER_GETPACKET",
+    MUXER_INIT = "MUXER_INIT",
+    MUXER_ADDVIDEOCHUNK = "MUXER_ADDVIDEOCHUNK",
+    MUXER_CLOSE = "MUXER_FINALIZE",
+    AUTH_AUTHENTICATE = "AUTHENTICATE",
+    AUTH_GETSTATUS = "AUTH_STATUS",
+    AUTH_GETSECONDS = "AUTH_GETSECONDS",
+    AUTH_ISAUTHENTICATED = "AUTH_ISAUTHENTICATED"
+}

package/dist/libs/ffmpeg/empty.d.mts

@@ -0,0 +1,3 @@
+export declare class FFmpeg {
+    constructor();
+}

package/dist/libs/ffmpeg/errors.d.ts

@@ -0,0 +1,4 @@
+export declare const ERROR_UNKNOWN_MESSAGE_TYPE: Error;
+export declare const ERROR_NOT_LOADED: Error;
+export declare const ERROR_TERMINATED: Error;
+export declare const ERROR_IMPORT_FAILURE: Error;

package/dist/libs/ffmpeg/fetchFile.d.ts

@@ -0,0 +1 @@
+export declare const fetchFile: (file?: string | File | Blob) => Promise<Uint8Array>;

package/dist/libs/ffmpeg/index.d.ts

@@ -0,0 +1 @@
+export * from "./classes";

package/dist/libs/ffmpeg/types.d.ts

@@ -0,0 +1,175 @@
+export type FFFSPath = string;
+export type FFmpegCoreModule = any;
+export type FFmpegCoreModuleFactory = any;
+/**
+ * ffmpeg-core loading configuration.
+ */
+export interface FFMessageLoadConfig {
+    /**
+     * `ffmpeg-core.js` URL.
+     *
+     * @defaultValue `https://unpkg.com/@ffmpeg/core@${CORE_VERSION}/dist/umd/ffmpeg-core.js`;
+     */
+    coreURL: string;
+    /**
+     * `ffmpeg-core.wasm` URL.
+     *
+     * @defaultValue `https://unpkg.com/@ffmpeg/core@${CORE_VERSION}/dist/umd/ffmpeg-core.wasm`;
+     */
+    wasmURL: string;
+    /**
+     * `ffmpeg-core.worker.js` URL.
+     *
+     * @defaultValue `https://unpkg.com/@ffmpeg/core-mt@${CORE_VERSION}/dist/umd/ffmpeg-core.worker.js`;
+     */
+    workerURL?: string;
+}
+export interface FFMessageRenderSettings {
+    width: number;
+    height: number;
+    framerate: number;
+    outputPath?: string;
+    hasAlpha?: boolean;
+}
+export interface FFMessageFrameData {
+    data: Uint8Array;
+}
+export interface FFMessageInitDemuxerData {
+    id: string;
+    path: FFFSPath;
+}
+export interface FFMessageSeekDemuxerData {
+    id: string;
+    time: number;
+}
+export interface FFMessageIdDemuxerData {
+    id: string;
+}
+export interface FFMessageMuxerData {
+    packet: Uint8Array;
+    timestamp: bigint;
+    duration: bigint;
+    isKeyFrame: boolean;
+}
+export interface FFMessageInitMuxerData {
+    path: FFFSPath;
+    width: number;
+    height: number;
+    framerate: number;
+    codec: string;
+}
+export interface FFMessageExecData {
+    args: string[];
+    timeout?: number;
+}
+export interface FFMessageWriteFileData {
+    path: FFFSPath;
+    data: FileData;
+}
+export interface FFMessageReadFileData {
+    path: FFFSPath;
+    encoding: string;
+}
+export interface FFMessageDeleteFileData {
+    path: FFFSPath;
+}
+export interface FFMessageRenameData {
+    oldPath: FFFSPath;
+    newPath: FFFSPath;
+}
+export interface FFMessageCreateDirData {
+    path: FFFSPath;
+}
+export interface FFMessageListDirData {
+    path: FFFSPath;
+}
+export interface FFMessageGetInfoData {
+    path: FFFSPath;
+}
+export interface FFMessageGetSubtitlesData {
+    path: FFFSPath;
+}
+export interface FFMessageAuthentificateData {
+    licensee: string;
+    key: string;
+}
+/**
+ * @remarks
+ * Only deletes empty directory.
+ */
+export interface FFMessageDeleteDirData {
+    path: FFFSPath;
+}
+export declare enum FFFSType {
+    MEMFS = "MEMFS",
+    NODEFS = "NODEFS",
+    NODERAWFS = "NODERAWFS",
+    IDBFS = "IDBFS",
+    WORKERFS = "WORKERFS",
+    PROXYFS = "PROXYFS"
+}
+export type WorkerFSFileEntry = File;
+export interface WorkerFSBlobEntry {
+    name: string;
+    data: Blob;
+}
+export interface WorkerFSMountData {
+    blobs?: WorkerFSBlobEntry[];
+    files?: WorkerFSFileEntry[];
+}
+export type FFFSMountOptions = WorkerFSMountData;
+export interface FFMessageMountData {
+    fsType: FFFSType;
+    options: FFFSMountOptions;
+    mountPoint: FFFSPath;
+}
+export interface FFMessageUnmountData {
+    mountPoint: FFFSPath;
+}
+export type FFMessageData = FFMessageLoadConfig | FFMessageExecData | FFMessageWriteFileData | FFMessageReadFileData | FFMessageDeleteFileData | FFMessageRenameData | FFMessageCreateDirData | FFMessageListDirData | FFMessageDeleteDirData | FFMessageMountData | FFMessageUnmountData | FFMessageGetInfoData | FFMessageGetSubtitlesData | FFMessageFrameData | FFMessageRenderSettings | FFMessageInitDemuxerData | FFMessageSeekDemuxerData | FFMessageIdDemuxerData | FFMessageMuxerData | FFMessageAuthentificateData;
+export interface Message {
+    type: string;
+    data?: FFMessageData;
+}
+export interface FFMessage extends Message {
+    id: number;
+}
+export interface FFMessageEvent extends MessageEvent {
+    data: FFMessage;
+}
+export interface LogEvent {
+    type: string;
+    message: string;
+}
+export interface ProgressEvent {
+    progress: number;
+    time: number;
+}
+export interface DemuxerPacket {
+    packet: Uint8Array;
+    isKeyFrame: boolean;
+    timestamp: bigint;
+    duration: bigint;
+}
+export type ExitCode = number;
+export type ErrorMessage = string;
+export type FileData = Uint8Array | string;
+export type IsFirst = boolean;
+export type OK = boolean;
+export interface FSNode {
+    name: string;
+    isDir: boolean;
+}
+export type CallbackData = FileData | ExitCode | ErrorMessage | LogEvent | ProgressEvent | IsFirst | OK | Error | FSNode[] | undefined | object;
+export interface Callbacks {
+    [id: number | string]: (data: CallbackData) => void;
+}
+export type LogEventCallback = (event: LogEvent) => void;
+export type ProgressEventCallback = (event: ProgressEvent) => void;
+export interface FFMessageEventCallback {
+    data: {
+        id: number;
+        type: string;
+        data: CallbackData;
+    };
+}

package/dist/libs/ffmpeg/utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate an unique message ID.
+ */
+export declare const getMessageID: () => number;

package/dist/libs/ffmpeg/worker.d.ts

@@ -0,0 +1,10 @@
+/// <reference no-default-lib="true"/>
+/// <reference lib="esnext" />
+/// <reference lib="webworker" />
+/// <reference lib="dom" />
+import type { FFmpegCoreModuleFactory } from './types';
+declare global {
+    interface WorkerGlobalScope {
+        createFFmpegCore: FFmpegCoreModuleFactory;
+    }
+}

package/dist/modules/clip/Clip.d.ts

@@ -0,0 +1,206 @@
+import * as PIXI from 'pixi.js';
+import { z } from 'zod';
+import { ClipStyle } from './ClipStyle';
+import { Effect, Filter } from '../filter';
+import { WarmModeEnum } from '../../types/clip.types';
+export declare enum ClipState {
+    Idle = 0,
+    Preloading = 1,
+    Loaded = 2,
+    Offloaded = 3
+}
+export interface ClipOptions<K extends ClipStyle = ClipStyle> {
+    mediaDataId?: string;
+    subtitlesId?: string;
+    subtitlesOffset?: number;
+    startTime?: number;
+    duration?: number;
+    leftTrim?: number;
+    rightTrim?: number;
+    filters?: Clip['filters'];
+    effects?: Clip['effects'];
+    style?: Partial<ReturnType<K['serialize']>>;
+}
+export declare const ClipSchema: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodString;
+    type: z.ZodString;
+    mediaDataId: z.ZodOptional<z.ZodString>;
+    subtitlesId: z.ZodOptional<z.ZodString>;
+    subtitlesOffset: z.ZodNumber;
+    startTime: z.ZodNumber;
+    duration: z.ZodNumber;
+    leftTrim: z.ZodNumber;
+    rightTrim: z.ZodNumber;
+    filters: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        sourceId: z.ZodString;
+        options: z.ZodObject<{
+            lutUrl: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            lutUrl: string;
+        }, {
+            lutUrl: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        options: {
+            lutUrl: string;
+        };
+        id: string;
+        sourceId: string;
+    }, {
+        name: string;
+        options: {
+            lutUrl: string;
+        };
+        id: string;
+        sourceId: string;
+    }>, "many">;
+    effects: z.ZodArray<z.ZodUnknown, "many">;
+    warpMode: z.ZodNativeEnum<typeof WarmModeEnum>;
+    style: z.ZodUnknown;
+    text: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: string;
+    id: string;
+    duration: number;
+    filters: {
+        name: string;
+        options: {
+            lutUrl: string;
+        };
+        id: string;
+        sourceId: string;
+    }[];
+    effects: unknown[];
+    subtitlesOffset: number;
+    startTime: number;
+    leftTrim: number;
+    rightTrim: number;
+    warpMode: WarmModeEnum;
+    mediaDataId?: string | undefined;
+    subtitlesId?: string | undefined;
+    style?: unknown;
+    text?: string | undefined;
+}, {
+    name: string;
+    type: string;
+    id: string;
+    duration: number;
+    filters: {
+        name: string;
+        options: {
+            lutUrl: string;
+        };
+        id: string;
+        sourceId: string;
+    }[];
+    effects: unknown[];
+    subtitlesOffset: number;
+    startTime: number;
+    leftTrim: number;
+    rightTrim: number;
+    warpMode: WarmModeEnum;
+    mediaDataId?: string | undefined;
+    subtitlesId?: string | undefined;
+    style?: unknown;
+    text?: string | undefined;
+}>;
+export declare class Clip<T extends PIXI.Sprite = PIXI.Sprite, K extends ClipStyle = ClipStyle> {
+    id: string;
+    protected startTime: number;
+    protected duration: number;
+    protected leftTrim: number;
+    protected rightTrim: number;
+    protected filters: Filter[];
+    protected effects: Effect[];
+    protected warpMode: WarmModeEnum;
+    protected isBuffering: boolean;
+    protected mediaDataId?: string;
+    protected subtitlesId?: string;
+    protected subtitlesOffset: number;
+    protected type: string;
+    protected hasTransition: boolean;
+    sprite: T;
+    style: K;
+    state: ClipState;
+    constructor(options: ClipOptions<K>);
+    init(layerId: string): void;
+    isReady(): boolean;
+    getStartTime(): number;
+    getEndTime(): number;
+    getLeftTrim(): number;
+    getRightTrim(): number;
+    getLeftBound(): number;
+    getRightBound(): number;
+    getTrimmedDuration(): number;
+    getFilters(): Filter[];
+    getEffects(): Effect[];
+    moveBy(amount: number): void;
+    getType(): string;
+    generateNewId(): void;
+    setStartTime(startTime: number): void;
+    setLeftTrim(trim: number): void;
+    setRightTrim(trim: number): void;
+    getDuration(): number;
+    getFilterById(filterId: string): Filter | undefined;
+    getEffectById(effectId: string): Effect | undefined;
+    setHasTransition(hasTransition: boolean): void;
+    getHasTransition(): boolean;
+    getMediaId(): string | undefined;
+    getIsProcessing(): boolean;
+    addFilter(filter: Filter): void;
+    removeFilter(filterId: string): void;
+    addEffect(effect: Effect): void;
+    removeEffect(effectId: string): void;
+    destroy(): void;
+    onPlay(currentTime: number): Promise<void>;
+    onPause(currentTime: number): void;
+    onResize(width: number, height: number): void;
+    onRenderStart(): Promise<void>;
+    onRenderDone(canceled: boolean): Promise<void>;
+    isActive(currentTime: number): boolean;
+    updateVisibility(currentTime: number): void;
+    setSubtitles(subtitlesId: string, offset: number): void;
+    removeSubtitles(): void;
+    getSubtitlesId(): string | undefined;
+    getSubtitlesOffset(): number;
+    setSubtitlesOffset(offset: number): void;
+    render(currentTime: number): null;
+    private processUpdate;
+    getSubtitleText(currentTime: number): string | undefined;
+    private updatePIXIFilters;
+    update(currentTime: number): void;
+    preload(currentTime: number): void;
+    offload(): void;
+    clone(): Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>;
+    protected updateTexture(pixels: Uint8Array, width: number, height: number): void;
+    serialize(): {
+        name: string;
+        type: string;
+        id: string;
+        duration: number;
+        filters: {
+            name: string;
+            options: {
+                lutUrl: string;
+            };
+            id: string;
+            sourceId: string;
+        }[];
+        effects: unknown[];
+        subtitlesOffset: number;
+        startTime: number;
+        leftTrim: number;
+        rightTrim: number;
+        warpMode: WarmModeEnum;
+        mediaDataId?: string | undefined;
+        subtitlesId?: string | undefined;
+        style?: unknown;
+        text?: string | undefined;
+    };
+    static deserialize(data: object): Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>;
+}