@rendley/sdk 1.0.1

package/dist/modules/event-emitter/types/EventEmitter.types.d.ts

@@ -0,0 +1,179 @@
+export declare enum EventsEnum {
+    READY = "ready",
+    PLAYING = "playing",
+    LOG = "log",
+    ERROR = "error",
+    TIME = "time",
+    RENDER_COMPLETED = "render:completed",
+    RENDER_ERROR = "render:error",
+    LAYER_ADDED = "layer:added",
+    LAYER_REMOVED = "layer:removed",
+    LAYER_UPDATED = "layer:updated",
+    LAYER_ERROR = "layer:error",
+    LAYERS_ORDER_UPDATED = "layers:order:updated",
+    TRANSITION_ADDED = "transition:added",
+    TRANSITION_REMOVED = "transition:removed",
+    TRANSITION_UPDATED = "transition:updated",
+    TRANSITION_ERROR = "transition:error",
+    CLIP_ADDED = "clip:added",
+    CLIP_REMOVED = "clip:removed",
+    CLIP_UPDATED = "clip:updated",
+    CLIP_UPDATED_TEXT = "clip:updated:text",
+    CLIP_ERROR = "clip:error",
+    CLIP_STYLE_UPDATED = "clip:style:updated",
+    CLIP_FILTER_ADDED = "clip:filter:added",
+    CLIP_FILTER_REMOVED = "clip:filter:removed",
+    CLIP_EFFECT_ADDED = "clip:effect:added",
+    CLIP_EFFECT_REMOVED = "clip:effect:removed",
+    GALLERY_ADDED = "gallery:added",
+    GALLERY_REMOVED = "gallery:removed",
+    GALLERY_ERROR = "gallery:error",
+    GALLERY_MEDIA_UPDATED = "gallery:media:updated",
+    SUBTITLES_ADDED = "subtitles:added",
+    SUBTITLES_REMOVED = "subtitles:removed",
+    FONT_ADDED = "font:added",
+    FONT_REMOVED = "font:removed",
+    FONT_ERROR = "font:error",
+    DISPLAY_RESOLUTION_UPDATED = "display:resolution:updated",
+    DISPLAY_BACKGROUND_UPDATED = "display:background:updated"
+}
+export type EventPayloadMap = {
+    [EventsEnum.READY]: undefined;
+    [EventsEnum.PLAYING]: {
+        isPlaying: boolean;
+    };
+    [EventsEnum.LOG]: {
+        name: string;
+        message: string;
+    };
+    [EventsEnum.ERROR]: {
+        name: string;
+        message: string;
+    };
+    [EventsEnum.TIME]: number;
+    [EventsEnum.RENDER_COMPLETED]: undefined;
+    [EventsEnum.RENDER_ERROR]: {
+        name: string;
+        message: string;
+    };
+    [EventsEnum.LAYER_ADDED]: {
+        layerId: string;
+    };
+    [EventsEnum.LAYER_REMOVED]: {
+        layerId: string;
+    };
+    [EventsEnum.LAYER_UPDATED]: {
+        layerId: string;
+    };
+    [EventsEnum.LAYER_ERROR]: {
+        layerId: string;
+        name: string;
+        message: string;
+    };
+    [EventsEnum.LAYERS_ORDER_UPDATED]: {
+        layersIds: string[];
+    };
+    [EventsEnum.TRANSITION_ADDED]: {
+        layerId: string;
+        transitionId: string;
+    };
+    [EventsEnum.TRANSITION_REMOVED]: {
+        layerId: string;
+        transitionId: string;
+    };
+    [EventsEnum.TRANSITION_UPDATED]: {
+        transitionId: string;
+    };
+    [EventsEnum.TRANSITION_ERROR]: {
+        transitionId: string;
+        name: string;
+        message: string;
+    };
+    [EventsEnum.CLIP_ADDED]: {
+        clipId: string;
+    };
+    [EventsEnum.CLIP_REMOVED]: {
+        clipId: string;
+        layerId: string;
+    };
+    [EventsEnum.CLIP_UPDATED]: {
+        clipId: string;
+    };
+    [EventsEnum.CLIP_UPDATED_TEXT]: {
+        clipId: string;
+        text: string;
+    };
+    [EventsEnum.CLIP_ERROR]: {
+        clipId: string;
+        name: string;
+        message: string;
+    };
+    [EventsEnum.CLIP_STYLE_UPDATED]: {
+        clipId: string;
+        property: string;
+        value: unknown;
+    };
+    [EventsEnum.CLIP_FILTER_ADDED]: {
+        clipId: string;
+        filterId: string;
+        sourceId: string;
+    };
+    [EventsEnum.CLIP_FILTER_REMOVED]: {
+        clipId: string;
+        filterId: string;
+        sourceId: string;
+    };
+    [EventsEnum.CLIP_EFFECT_ADDED]: {
+        clipId: string;
+        effectId: string;
+        sourceId: string;
+    };
+    [EventsEnum.CLIP_EFFECT_REMOVED]: {
+        clipId: string;
+        effectId: string;
+        sourceId: string;
+    };
+    [EventsEnum.GALLERY_ADDED]: {
+        mediaDataId: string;
+    };
+    [EventsEnum.GALLERY_REMOVED]: {
+        mediaDataId: string;
+    };
+    [EventsEnum.GALLERY_ERROR]: {
+        mediaDataId: string;
+        error: Error;
+    };
+    [EventsEnum.GALLERY_MEDIA_UPDATED]: {
+        mediaDataId: string;
+        status: string;
+    };
+    [EventsEnum.SUBTITLES_ADDED]: {
+        subtitlesId: string;
+    };
+    [EventsEnum.SUBTITLES_REMOVED]: {
+        subtitlesId: string;
+    };
+    [EventsEnum.FONT_ADDED]: {
+        fontId: string;
+    };
+    [EventsEnum.FONT_REMOVED]: {
+        fontId: string;
+    };
+    [EventsEnum.FONT_ERROR]: {
+        fontId: string;
+        name: string;
+        message: string;
+    };
+    [EventsEnum.DISPLAY_BACKGROUND_UPDATED]: {
+        backgroundColor: string;
+    };
+    [EventsEnum.DISPLAY_RESOLUTION_UPDATED]: {
+        width: number;
+        height: number;
+    };
+};
+type EventEmitterValidEventType<T> = T extends undefined ? () => void : (payload: T) => void;
+export type EventEmitterValidEventTypes = {
+    [K in keyof EventPayloadMap]: EventEmitterValidEventType<EventPayloadMap[K]>;
+};
+export {};

package/dist/modules/ffmpeg/FFmpeg.d.ts

@@ -0,0 +1,11 @@
+import { FFmpeg as RootFFmpeg } from '../../libs/ffmpeg';
+import { FFMessageLoadConfig } from '../../libs/ffmpeg/types';
+declare class FFmpeg {
+    private static instance;
+    private ffmpeg;
+    private constructor();
+    static getInstance(): FFmpeg;
+    initialize(config: FFMessageLoadConfig): Promise<boolean | undefined>;
+    getFFmpeg(): RootFFmpeg;
+}
+export { FFmpeg };

package/dist/modules/ffmpeg/types/FFmpeg.types.d.ts

@@ -0,0 +1,32 @@
+export interface MediaInfo {
+    type: string;
+    status: string;
+    path: string;
+    format: string;
+    duration: number;
+    streamCount: number;
+    streams: MediaInfoStream[];
+    averageFps: number;
+    thumbnail: Uint8Array;
+    wasConverted?: boolean;
+}
+export interface MediaInfoStream {
+    index: number;
+    type: string;
+    codec: string;
+    codecRFC6381: string;
+    extradata?: Uint8Array;
+    bitrate: number;
+    format: number;
+    duration: number;
+    startTime: number;
+    width?: number;
+    height?: number;
+    codedWidth?: number;
+    codedHeight?: number;
+    rotation?: number;
+    averageFps?: number;
+    frameCount?: number;
+    sampleRate?: number;
+    channels?: number;
+}

package/dist/modules/filter/Effect.d.ts

@@ -0,0 +1,36 @@
+import * as PIXI from 'pixi.js';
+export interface EffectOptions {
+    sourceId: string;
+    fragmentSrc?: string;
+    uniforms?: Record<string, unknown>;
+    textureWidth: number;
+    textureHeight: number;
+    frameWidth: number;
+    frameHeight: number;
+}
+export declare class Effect {
+    id: string;
+    private sourceId;
+    private options;
+    private pixiFilter;
+    constructor(options: EffectOptions);
+    getSourceId(): string;
+    getPixiFilter(): PIXI.Filter;
+    private lastUpdate;
+    updateUniformsFromSprite(sprite: PIXI.Sprite): void;
+    update(currentTime: number): void;
+    serialize(): {
+        name: string;
+        options: {
+            textureWidth: number;
+            textureHeight: number;
+            frameWidth: number;
+            frameHeight: number;
+            fragmentSrc?: string | undefined;
+            uniforms?: Record<string, unknown> | undefined;
+        };
+        id: string;
+        sourceId: string;
+    };
+    static deserialize(data: object): Effect;
+}

package/dist/modules/filter/Filter.d.ts

@@ -0,0 +1,52 @@
+import * as PIXI from 'pixi.js';
+import { z } from 'zod';
+export declare const FilterSchema: 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;
+}>;
+export interface FilterOptions {
+    lutUrl: string;
+    sourceId: string;
+}
+export declare class Filter {
+    id: string;
+    private sourceId;
+    lutUrl: string;
+    intensity: number;
+    private lutTexture;
+    private pixiFilter;
+    constructor(options: FilterOptions);
+    getSourceId(): string;
+    getPixiFilter(): PIXI.Filter;
+    serialize(): {
+        name: string;
+        options: {
+            lutUrl: string;
+        };
+        id: string;
+        sourceId: string;
+    };
+    static deserialize(data: object): Filter;
+}

package/dist/modules/filter/effects/OldFilmEffect.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/modules/filter/effects/WaveEffect.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/modules/filter/filters/VintageFilter.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/modules/filter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Filter';
+export * from './Effect';

package/dist/modules/filter/utils/removeShaderNameLine.d.ts

@@ -0,0 +1 @@
+export declare function removeShaderNameLine(shaderCode: string): string | undefined;

package/dist/modules/font-registry/FontRegistry.d.ts

@@ -0,0 +1,22 @@
+export declare class FontRegistry {
+    fonts: {
+        font: FontFace;
+        src: string;
+    }[];
+    constructor();
+    loadFromUrl(name: string, url: string, descriptors?: FontFaceDescriptors): Promise<void>;
+    loadFromCssUrl(name: string, cssUrl: string): Promise<void>;
+    private load;
+    offload(fontFamily: string): void;
+    serialize(): {
+        fonts: {
+            family: string;
+            src: string;
+            descriptors?: {
+                weight?: string | undefined;
+                style?: string | undefined;
+            } | undefined;
+        }[];
+    };
+    static deserialize(data: unknown): Promise<FontRegistry>;
+}

package/dist/modules/font-registry/index.d.ts

@@ -0,0 +1 @@
+export * from './FontRegistry';

package/dist/modules/layer/Layer.d.ts

@@ -0,0 +1,278 @@
+import * as PIXI from 'pixi.js';
+import { z } from 'zod';
+import { AudioClipOptions, Clip, ImageClipOptions, TextClipOptions, VideoClipOptions } from '../clip';
+import { GifClipOptions } from '../clip/clips/gif/GifClip';
+import { ShapeClipOptions } from '../clip/clips/shape/ShapeClip';
+import { Transition } from '../transition/Transition';
+type ClipOptions = ImageClipOptions | VideoClipOptions | TextClipOptions | AudioClipOptions | GifClipOptions | ShapeClipOptions;
+export type ClipTypeRange = Pick<ClipOptions, 'startTime' | 'duration'>;
+export declare const LayerSchema: z.ZodObject<{
+    id: z.ZodString;
+    isEnabled: z.ZodBoolean;
+    isMuted: z.ZodBoolean;
+    clips: z.ZodArray<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 import('../../types').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: import('../../types').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: import('../../types').WarmModeEnum;
+        mediaDataId?: string | undefined;
+        subtitlesId?: string | undefined;
+        style?: unknown;
+        text?: string | undefined;
+    }>, "many">;
+    transitions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        startClipId: z.ZodString;
+        endClipId: z.ZodString;
+        inDuration: z.ZodNumber;
+        outDuration: z.ZodNumber;
+        transitionSrc: z.ZodString;
+        type: z.ZodLiteral<"transition">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "transition";
+        id: string;
+        startClipId: string;
+        endClipId: string;
+        inDuration: number;
+        outDuration: number;
+        transitionSrc: string;
+    }, {
+        name: string;
+        type: "transition";
+        id: string;
+        startClipId: string;
+        endClipId: string;
+        inDuration: number;
+        outDuration: number;
+        transitionSrc: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    isEnabled: boolean;
+    isMuted: boolean;
+    clips: {
+        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: import('../../types').WarmModeEnum;
+        mediaDataId?: string | undefined;
+        subtitlesId?: string | undefined;
+        style?: unknown;
+        text?: string | undefined;
+    }[];
+    transitions: {
+        name: string;
+        type: "transition";
+        id: string;
+        startClipId: string;
+        endClipId: string;
+        inDuration: number;
+        outDuration: number;
+        transitionSrc: string;
+    }[];
+}, {
+    id: string;
+    isEnabled: boolean;
+    isMuted: boolean;
+    clips: {
+        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: import('../../types').WarmModeEnum;
+        mediaDataId?: string | undefined;
+        subtitlesId?: string | undefined;
+        style?: unknown;
+        text?: string | undefined;
+    }[];
+    transitions: {
+        name: string;
+        type: "transition";
+        id: string;
+        startClipId: string;
+        endClipId: string;
+        inDuration: number;
+        outDuration: number;
+        transitionSrc: string;
+    }[];
+}>;
+export declare class Layer {
+    id: string;
+    isEnabled: boolean;
+    isMuted: boolean;
+    clipsIds: string[];
+    clips: Record<string, Clip>;
+    transitions: Transition[];
+    container: PIXI.Container;
+    constructor();
+    init(): void;
+    destroy(): void;
+    addClip(options: Clip): Clip | null;
+    addClip(options: ClipOptions): Clip | null;
+    removeClip(clipId: string, shouldNotDestroy?: boolean): boolean;
+    moveClipToLayer(clipId: string, newLayerId: string): void;
+    splitClip(clipId: string, time: number): Clip | null;
+    addTransition(transition: Transition): void;
+    removeTransition(transitionId: string): void;
+    getDuration(): number;
+    hasEmptySpace(startTime: number, endTime: number): boolean;
+    getClipById(clipId: string): Clip | undefined;
+    getNextEmptySpace(startTime: number, endTime: number): number;
+    adjustClipsLayout(): void;
+    setZIndex(zIndex: number): void;
+    onPlay(currentTime: number): Promise<void>;
+    onPause(currentTime: number): void;
+    onResize(width: number, height: number): void;
+    update(currentTime: number): void;
+    render(currentTime: number): PIXI.Container<PIXI.DisplayObject>;
+    isEmpty(): boolean;
+    private createClip;
+    serialize(): {
+        id: string;
+        isEnabled: boolean;
+        isMuted: boolean;
+        clips: {
+            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: import('../../types').WarmModeEnum;
+            mediaDataId?: string | undefined;
+            subtitlesId?: string | undefined;
+            style?: unknown;
+            text?: string | undefined;
+        }[];
+        transitions: {
+            name: string;
+            type: "transition";
+            id: string;
+            startClipId: string;
+            endClipId: string;
+            inDuration: number;
+            outDuration: number;
+            transitionSrc: string;
+        }[];
+    };
+    static deserialize(data: object): Layer;
+}
+export {};

package/dist/modules/layer/index.d.ts

@@ -0,0 +1 @@
+export * from './Layer';