@rendley/sdk 1.0.1

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

@@ -0,0 +1,92 @@
+import * as PIXI from 'pixi.js';
+import { z } from 'zod';
+export interface ClipStyleOptions {
+    clipId: string;
+    mediaDataId?: string;
+    alpha?: number;
+    rotation?: number;
+    position?: [number, number];
+    scale?: [number, number];
+    zIndex?: number;
+    width?: number;
+    height?: number;
+}
+export declare const schema: z.ZodObject<{
+    name: z.ZodString;
+    clipId: z.ZodString;
+    mediaDataId: z.ZodOptional<z.ZodString>;
+    alpha: z.ZodNumber;
+    rotation: z.ZodNumber;
+    position: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    scale: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    zIndex: z.ZodNumber;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    clipId: string;
+    alpha: number;
+    rotation: number;
+    position: [number, number];
+    scale: [number, number];
+    zIndex: number;
+    mediaDataId?: string | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+}, {
+    name: string;
+    clipId: string;
+    alpha: number;
+    rotation: number;
+    position: [number, number];
+    scale: [number, number];
+    zIndex: number;
+    mediaDataId?: string | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+}>;
+export declare class ClipStyle<T extends PIXI.Sprite = PIXI.Sprite> {
+    protected alpha: number;
+    protected rotation: number;
+    protected position: [number, number];
+    protected zIndex: number;
+    protected width: number;
+    protected height: number;
+    protected scale: [number, number];
+    protected sprite: T | null;
+    private clipId;
+    private mediaDataId;
+    constructor(options: ClipStyleOptions);
+    private positionToCenter;
+    private scaleDownToFit;
+    setScale(scaleX: number, scaleY: number): void;
+    getScale(): [number, number];
+    setWidth(width: number): void;
+    setHeight(height: number): void;
+    getWidth(): number;
+    getHeight(): number;
+    setAlpha(alpha: number): void;
+    getAlpha(): number;
+    setRotation(rotation: number): void;
+    getRotation(): number;
+    setPosition(x: number, y: number): void;
+    getPosition(): [number, number];
+    setZIndex(zIndex: number): void;
+    getZIndex(): number;
+    load(sprite: T): void;
+    update(sprite: T): void;
+    protected emitUpdateEvent(property: string, value: unknown): boolean;
+    serialize(): {
+        name: string;
+        clipId: string;
+        alpha: number;
+        rotation: number;
+        position: [number, number];
+        scale: [number, number];
+        zIndex: number;
+        mediaDataId?: string | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+    };
+    static deserialize(payload: object): ClipStyle<PIXI.Sprite>;
+}

package/dist/modules/clip/clips/audio/AudioClip.d.ts

@@ -0,0 +1,36 @@
+import { Clip, ClipOptions } from '../../Clip';
+export interface AudioClipOptions extends ClipOptions {
+    mediaDataId: string;
+}
+export declare class AudioClip extends Clip {
+    audioElement: HTMLAudioElement;
+    isPlaying: boolean;
+    private actions;
+    private isProcessing;
+    private lastUpdateTime;
+    private lastStartTime;
+    private lastLeftTrim;
+    private lastRightTrim;
+    constructor(options: AudioClipOptions);
+    init(layerId: string): void;
+    private getGlobalTimeToClipTime;
+    getIsProcessing(): boolean;
+    preload(currentTime: number): void;
+    addActionToQueue(action: string, params?: object): void;
+    processNextQueue(): void;
+    private seekedCallback;
+    private playingCallback;
+    private pausedCallback;
+    private endedCallback;
+    private errorCallback;
+    private audioLoadedCallback;
+    private play;
+    private pause;
+    private seek;
+    onPlay(currentTime: number): Promise<void>;
+    onPause(currentTime: number): Promise<void>;
+    destroy(): void;
+    update(currentTime: number): void;
+    offload(): void;
+    clone(): Clip<import("pixi.js").Sprite, import("../../ClipStyle").ClipStyle<import("pixi.js").Sprite>>;
+}

package/dist/modules/clip/clips/gif/GifClip.d.ts

@@ -0,0 +1,27 @@
+import * as PIXI from 'pixi.js';
+import { Clip, ClipOptions } from '../../Clip';
+import { ClipStyle } from '../../ClipStyle';
+export interface GifClipOptions extends ClipOptions<ClipStyle> {
+    mediaDataId: string;
+}
+export declare class GifClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>> {
+    private lastUpdateTime;
+    private lastStartTime;
+    private lastLeftTrim;
+    private lastRightTrim;
+    private gifAnimator;
+    constructor(options: GifClipOptions);
+    init(layerId: string): void;
+    private getGlobalTimeToClipTime;
+    preload(currentTime: number): void;
+    private play;
+    private pause;
+    private seek;
+    onPlay(currentTime: number): Promise<void>;
+    onPause(currentTime: number): Promise<void>;
+    updateVisibility(currentTime: number): void;
+    update(currentTime: number): void;
+    offload(): void;
+    clone(): Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>;
+    destroy(): void;
+}

package/dist/modules/clip/clips/image/ImageClip.d.ts

@@ -0,0 +1,16 @@
+import * as PIXI from 'pixi.js';
+import { Clip, ClipOptions } from '../../Clip';
+import { ClipStyle } from '../../ClipStyle';
+export interface ImageClipOptions extends ClipOptions<ClipStyle> {
+    mediaDataId: string;
+}
+export declare class ImageClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>> {
+    constructor(options: ImageClipOptions);
+    init(layerId: string): void;
+    preload(currentTime: number): void;
+    updateVisibility(currentTime: number): void;
+    update(currentTime: number): void;
+    offload(): void;
+    clone(): Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>;
+    destroy(): void;
+}

package/dist/modules/clip/clips/index.d.ts

@@ -0,0 +1,4 @@
+export * from './audio/AudioClip';
+export * from './image/ImageClip';
+export * from './video/VideoClip';
+export * from './text/TextClip';

package/dist/modules/clip/clips/shape/ShapeClip.d.ts

@@ -0,0 +1,43 @@
+import { ShapeSprite } from './ShapeSprite';
+import { ShapeStyle } from './ShapeStyle';
+import { Clip, ClipOptions } from '../../Clip';
+export interface ShapeClipOptions extends ClipOptions<ShapeStyle> {
+    shape: string;
+}
+export declare class ShapeClip extends Clip<ShapeSprite, ShapeStyle> {
+    shape: string;
+    constructor(options: ShapeClipOptions);
+    private initGraphics;
+    preload(currentTime: number): void;
+    updateVisibility(currentTime: number): void;
+    update(currentTime: number): void;
+    offload(): void;
+    clone(): ShapeClip;
+    destroy(): void;
+    serialize(): {
+        name: string;
+        type: string;
+        id: string;
+        shape: 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("../../../..").WarmModeEnum;
+        text?: string | undefined;
+        style?: unknown;
+        mediaDataId?: string | undefined;
+        subtitlesId?: string | undefined;
+    };
+    static deserialize(payload: object): ShapeClip;
+}

package/dist/modules/clip/clips/shape/ShapeSprite.d.ts

@@ -0,0 +1,9 @@
+import * as PIXI from 'pixi.js';
+export declare class ShapeSprite extends PIXI.Sprite {
+    graphics: PIXI.Graphics;
+    constructor();
+    drawRect(width: number, height: number, color: string): void;
+    drawCircle(width: number, height: number, color: string): void;
+    drawTriangle(width: number, height: number, color: string): void;
+    destroy(): void;
+}

package/dist/modules/clip/clips/shape/ShapeStyle.d.ts

@@ -0,0 +1,27 @@
+import { ShapeSprite } from './ShapeSprite';
+import { ClipStyle, ClipStyleOptions } from '../../ClipStyle';
+interface ShapeClipStyleOptions extends ClipStyleOptions {
+    color?: string;
+}
+export declare class ShapeStyle extends ClipStyle<ShapeSprite> {
+    color: string;
+    constructor(options: ShapeClipStyleOptions);
+    setColor(color: string): void;
+    getColor(): string;
+    update(container: ShapeSprite): void;
+    serialize(): {
+        name: string;
+        color: string;
+        clipId: string;
+        alpha: number;
+        rotation: number;
+        position: [number, number];
+        scale: [number, number];
+        zIndex: number;
+        width?: number | undefined;
+        height?: number | undefined;
+        mediaDataId?: string | undefined;
+    };
+    static deserialize(payload: object): ShapeStyle;
+}
+export {};

package/dist/modules/clip/clips/text/TextClip.d.ts

@@ -0,0 +1,42 @@
+import { TextSprite } from './TextSprite';
+import { TextStyle } from './TextStyle';
+import { Clip, ClipOptions } from '../../Clip';
+export interface TextClipOptions extends ClipOptions<TextStyle> {
+    text?: string;
+}
+export declare class TextClip extends Clip<TextSprite, TextStyle> {
+    text: string;
+    constructor(options: TextClipOptions);
+    getText(): string;
+    setText(text?: string): void;
+    seek(currentTime: number): void;
+    preload(currentTime: number): void;
+    update(currentTime: number): void;
+    offload(): void;
+    clone(): TextClip;
+    serialize(): {
+        name: string;
+        text: 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('../../../../index').WarmModeEnum;
+        style?: unknown;
+        mediaDataId?: string | undefined;
+        subtitlesId?: string | undefined;
+    };
+    static deserialize(payload: object): TextClip;
+}

package/dist/modules/clip/clips/text/TextSprite.d.ts

@@ -0,0 +1,7 @@
+import * as PIXI from 'pixi.js';
+export declare class TextSprite extends PIXI.Sprite {
+    text: PIXI.Text;
+    background: PIXI.Sprite;
+    constructor();
+    setBackgroundColor(color: string | null): void;
+}

package/dist/modules/clip/clips/text/TextStyle.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { TextSprite } from './TextSprite';
+import { ClipStyle, ClipStyleOptions } from '../../ClipStyle';
+declare const FontWeightSchema: z.ZodEnum<["normal", "bold", "bolder", "lighter", "100", "200", "300", "400", "500", "600", "700", "800", "900"]>;
+declare const TextAlignSchema: z.ZodEnum<["left", "center", "right", "justify"]>;
+declare const FontStyleSchema: z.ZodEnum<["normal", "italic", "oblique"]>;
+type TextStyleFontWeight = z.infer<typeof FontWeightSchema>;
+type TextStyleAlign = z.infer<typeof TextAlignSchema>;
+type TextStyleFontStyle = z.infer<typeof FontStyleSchema>;
+interface TextClipStyleOptions extends ClipStyleOptions {
+    fontSize?: number;
+    color?: string;
+    fontWeight?: TextStyleFontWeight;
+    fontFamily?: string;
+    textAlign?: TextStyleAlign;
+    fontStyle?: TextStyleFontStyle;
+    backgroundColor?: string | null;
+    wordWrapWidth?: number | null;
+}
+export declare class TextStyle extends ClipStyle<TextSprite> {
+    fontSize: number;
+    color: string;
+    fontWeight: TextStyleFontWeight;
+    fontFamily: string;
+    textAlign: TextStyleAlign;
+    fontStyle: TextStyleFontStyle;
+    backgroundColor: string | null;
+    wordWrapWidth: number | null;
+    constructor(options: TextClipStyleOptions);
+    setFontSize(fontSize: number): void;
+    getFontSize(): number;
+    getWordWrapWidth(): number | null;
+    setWordWrapWidth(wordWrapWidth: number | null): void;
+    setColor(color: string): void;
+    getColor(): string;
+    setFontWeight(fontWeight: TextStyleFontWeight): void;
+    getFontWeight(): "bold" | "normal" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
+    setFontFamily(fontFamily: string): void;
+    getFontFamily(): string;
+    setTextAlign(textAlign: TextStyleAlign): void;
+    getTextAlign(): "left" | "center" | "right" | "justify";
+    setFontStyle(fontStyle: TextStyleFontStyle): void;
+    getFontStyle(): "normal" | "italic" | "oblique";
+    setBackgroundColor(backgroundColor: string | null): void;
+    getBackgroundColor(): string | null;
+    setRotation(rotation: number): void;
+    update(container: TextSprite): void;
+    serialize(): {
+        name: string;
+        backgroundColor: string | null;
+        color: string;
+        clipId: string;
+        alpha: number;
+        rotation: number;
+        position: [number, number];
+        scale: [number, number];
+        zIndex: number;
+        fontSize: number;
+        fontWeight: "bold" | "normal" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
+        fontFamily: string;
+        textAlign: "left" | "center" | "right" | "justify";
+        fontStyle: "normal" | "italic" | "oblique";
+        width?: number | undefined;
+        height?: number | undefined;
+        mediaDataId?: string | undefined;
+    };
+    static deserialize(payload: object): TextStyle;
+}
+export {};

package/dist/modules/clip/clips/video/VideoClip.d.ts

@@ -0,0 +1,48 @@
+import * as PIXI from 'pixi.js';
+import { Clip, ClipOptions } from '../../Clip';
+import { ClipStyle } from '../../ClipStyle';
+export interface VideoClipOptions extends ClipOptions<ClipStyle> {
+    mediaDataId: string;
+}
+export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>> {
+    videoElement: HTMLVideoElement;
+    audioElement: HTMLAudioElement | undefined;
+    isPlaying: boolean;
+    private actions;
+    private isProcessing;
+    private lastUpdateTime;
+    private lastStartTime;
+    private lastLeftTrim;
+    private lastRightTrim;
+    private decoder;
+    private frameQueue;
+    private isRendering;
+    constructor(options: VideoClipOptions);
+    init(layerId: string): void;
+    private getGlobalTimeToClipTime;
+    getIsProcessing(): boolean;
+    preload(currentTime: number): void;
+    addActionToQueue(action: string, params?: object): void;
+    processNextQueue(): void;
+    private seekedCallback;
+    private playingCallback;
+    private pausedCallback;
+    private endedCallback;
+    private errorCallback;
+    private videoLoadedCallback;
+    private play;
+    private pause;
+    private renderSeek;
+    private seek;
+    renderVideoFrameOutputCallback(frame: VideoFrame): void;
+    getNextRenderPacket(): Promise<void>;
+    searchRenderFrame(videoTime: number): Promise<VideoFrame | null>;
+    onRenderStart(): Promise<void>;
+    onRenderDone(canceled: boolean): Promise<void>;
+    onPlay(currentTime: number): Promise<void>;
+    onPause(currentTime: number): Promise<void>;
+    updateVisibility(currentTime: number): void;
+    update(currentTime: number): void;
+    offload(): void;
+    clone(): Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>;
+}

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

@@ -0,0 +1,2 @@
+export * from './clips';
+export * from './Clip';

package/dist/modules/clip/utils/generateRawData.d.ts

@@ -0,0 +1 @@
+export declare function generateRawData(width: number, height: number, randomize?: boolean): Uint8ClampedArray;

package/dist/modules/display/Display.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { PixiRenderer, PixiRendererInitOptions } from './renderer/PixiRenderer';
+export declare const DisplaySchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    backgroundColor: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    width: number;
+    backgroundColor: string;
+    height: number;
+}, {
+    width: number;
+    backgroundColor: string;
+    height: number;
+}>;
+export type DisplayOptions = Partial<Omit<PixiRendererInitOptions, 'view'>>;
+export declare class Display {
+    private width;
+    private height;
+    private backgroundColor;
+    renderer: PixiRenderer;
+    private static instance;
+    constructor(options: DisplayOptions);
+    static getInstance(options?: DisplayOptions): Display;
+    init(canvas: HTMLCanvasElement): void;
+    updateInstance(options: DisplayOptions): void;
+    getWidth(): number;
+    getHeight(): number;
+    getResolution(): [number, number];
+    getBackgroundColor(): string;
+    setBackgroundColor(color: string): void;
+    setResolution(width: number, height: number): void;
+    getClipIdByCursorPosition(cursorX: number, cursorY: number): string | null;
+    private hitTest;
+    destroy(): void;
+    serialize(): {
+        width: number;
+        backgroundColor: string;
+        height: number;
+    };
+    static deserialize(data: object): Display;
+}

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

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

package/dist/modules/display/renderer/PixiRenderer.d.ts

@@ -0,0 +1,16 @@
+import * as PIXI from 'pixi.js';
+export interface PixiRendererInitOptions {
+    width: number;
+    height: number;
+    backgroundColor: string;
+    view: HTMLCanvasElement;
+}
+export declare class PixiRenderer {
+    app: PIXI.Application | null;
+    stage: PIXI.Container | null;
+    constructor();
+    init(options: PixiRendererInitOptions): void;
+    render(): void;
+    resize(width: number, height: number): void;
+    destroy(): void;
+}

package/dist/modules/display/utils/WebCodecsVideoFrameResource.d.ts

@@ -0,0 +1,7 @@
+import * as PIXI from 'pixi.js';
+declare class WebCodecsVideoFrameResource extends PIXI.Resource {
+    private frame;
+    upload(renderer: PIXI.Renderer, baseTexture: PIXI.BaseTexture<PIXI.Resource, PIXI.IAutoDetectOptions>): boolean;
+    updateFrame(frame: VideoFrame): void;
+}
+export { WebCodecsVideoFrameResource };

package/dist/modules/display/utils/registerSelectionEvents.d.ts

@@ -0,0 +1,12 @@
+import * as PIXI from 'pixi.js';
+interface Point {
+    x: number;
+    y: number;
+}
+interface RegisterSelectionListeners {
+    onSelectionStart: (point: Point) => void;
+    onSelectionMove: (point: Point) => void;
+    onSelectionEnd: (clipIds: string[], point: Point) => void;
+}
+export declare function registerSelectionEvents(app: PIXI.Application, listeners: RegisterSelectionListeners): void;
+export {};

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

@@ -0,0 +1,4 @@
+import EventEmitter3 from 'eventemitter3';
+import { EventEmitterValidEventTypes } from './types/EventEmitter.types';
+export declare class EventEmitter extends EventEmitter3<EventEmitterValidEventTypes> {
+}

package/dist/modules/event-emitter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './EventEmitter';
+export * from './types/EventEmitter.types';