@rendley/sdk 1.10.2 → 1.11.0

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

@@ -30,29 +30,18 @@ export declare class TextClip extends Clip<TextSprite, TextStyle> {
         rightTrim: number;
         filters: {
             id: string;
-            options: {
-                lutUrl: string;
-            };
-            sourceId: string;
-        }[];
-        effects: {
-            id: string;
-            options: {
-                textureWidth: number;
-                textureHeight: number;
-                frameWidth: number;
-                frameHeight: number;
-                fragmentSrc?: string | undefined;
-                uniforms?: Record<string, unknown> | undefined;
-            };
-            sourceId: string;
+            provider: string;
+            filterId: string;
+            intensity: number;
+            clipId?: string | undefined;
         }[];
+        effects: any[];
         isVisible: boolean;
+        wrapMode?: import('../../../../index').WrapModeEnum | undefined;
         customData?: [string, unknown][] | undefined;
         style?: unknown;
         mediaDataId?: string | undefined;
         subtitlesId?: string | undefined;
-        wrapMode?: import('../../../../index').WrapModeEnum | undefined;
         animationController?: {
             animationDataIn?: {
                 name: string;
@@ -120,8 +109,8 @@ export declare class TextClip extends Clip<TextSprite, TextStyle> {
             loopSmoothing?: number | undefined;
         } | undefined;
         clipMasks?: {
+            wrapMode: import('../../../../index').MaskWrapModeEnum;
             id: string;
-            wrapMode: import("../../../filter/MaskFilter").MaskWrapModeEnum;
             clipId: string;
         }[] | undefined;
     };

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

@@ -23,6 +23,7 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
     private frameQueue;
     private isRendering;
     private decoderFlushed;
+    private renderWithPlayer;
     private callbacks;
     constructor(options: VideoClipOptions);
     init(layerId: string): Promise<void>;
@@ -76,29 +77,18 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
         rightTrim: number;
         filters: {
             id: string;
-            options: {
-                lutUrl: string;
-            };
-            sourceId: string;
-        }[];
-        effects: {
-            id: string;
-            options: {
-                textureWidth: number;
-                textureHeight: number;
-                frameWidth: number;
-                frameHeight: number;
-                fragmentSrc?: string | undefined;
-                uniforms?: Record<string, unknown> | undefined;
-            };
-            sourceId: string;
+            provider: string;
+            filterId: string;
+            intensity: number;
+            clipId?: string | undefined;
         }[];
+        effects: any[];
         isVisible: boolean;
         text?: string | undefined;
+        wrapMode?: import('../../../../types').WrapModeEnum | undefined;
         customData?: [string, unknown][] | undefined;
         style?: unknown;
         subtitlesId?: string | undefined;
-        wrapMode?: import('../../../../types').WrapModeEnum | undefined;
         animationController?: {
             animationDataIn?: {
                 name: string;
@@ -166,8 +156,8 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
             loopSmoothing?: number | undefined;
         } | undefined;
         clipMasks?: {
+            wrapMode: import("../../../filter").MaskWrapModeEnum;
             id: string;
-            wrapMode: import("../../../filter/MaskFilter").MaskWrapModeEnum;
             clipId: string;
         }[] | undefined;
         volume?: number | undefined;

package/dist/modules/effect/BasicEffect.d.ts

@@ -0,0 +1,6 @@
+import { EffectBase } from "./EffectBase";
+export declare class BasicEffect extends EffectBase {
+    setProperty(propertyName: string, value: any): void;
+    getProperty(propertyName: string): any;
+    update(clipTime: number): void;
+}

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

@@ -0,0 +1,47 @@
+import * as PIXI from "pixi.js";
+import { z } from "zod";
+export declare const EffectSchema: z.ZodObject<{
+    id: z.ZodString;
+    effectId: z.ZodString;
+    provider: z.ZodString;
+    properties: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodAny], null>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    provider: string;
+    properties: [string, any][];
+    effectId: string;
+}, {
+    id: string;
+    provider: string;
+    properties: [string, any][];
+    effectId: string;
+}>;
+export declare class Effect {
+    private id;
+    private readonly effectId;
+    private provider;
+    private effect;
+    private readonly inputTextures;
+    private propertyMap;
+    private readonly tempProperties?;
+    constructor(effectId: string, properties?: Record<string, any>);
+    init(): void;
+    update(clipTime: number): void;
+    getPixiFilter(): PIXI.Filter;
+    setProperty(propertyName: string, value: any): void;
+    getProperty(propertyName: string): any;
+    getId(): string;
+    setId(id: string): void;
+    getEffectId(): string;
+    getProvider(): string;
+    getIsBuiltIn(): boolean;
+    getProperties(): Map<string, any>;
+    destroy(): void;
+    serialize(): {
+        id: string;
+        provider: string;
+        properties: [string, any][];
+        effectId: string;
+    };
+    static deserialize(data: object): Effect;
+}

package/dist/modules/effect/EffectBase.d.ts

@@ -0,0 +1,9 @@
+import * as PIXI from "pixi.js";
+export declare abstract class EffectBase {
+    protected pixiFilter: PIXI.Filter;
+    constructor(pixiFilter: PIXI.Filter);
+    getPixiFilter(): PIXI.Filter;
+    update(currentTime: number): void;
+    abstract setProperty(propertyName: string, value: any): void;
+    abstract getProperty(propertyName: string): any;
+}

package/dist/modules/effect/built-in-effects/BuiltInBlurEffect.d.ts

@@ -0,0 +1,11 @@
+import { EffectBase } from "../EffectBase";
+export declare enum BuiltInBlurEffectPropertiesEnum {
+    STRENGTH = "strength",
+    QUALITY = "quality",
+    KERNEL_SIZE = "kernelSize"
+}
+export declare class BuiltInBlurEffect extends EffectBase {
+    constructor(properties: Map<string, any>);
+    setProperty(propertyName: string, value: any): void;
+    getProperty(propertyName: string): number | null;
+}

package/dist/modules/effect/built-in-effects/BuiltInFactory.d.ts

@@ -0,0 +1,4 @@
+import { EffectBase } from "../EffectBase";
+export declare class BuiltInFactory {
+    static create(effectId: string, properties: Map<string, any>): EffectBase | null;
+}

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

@@ -0,0 +1,2 @@
+export * from "./Effect";
+export * from "./built-in-effects/BuiltInBlurEffect";

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

@@ -32,6 +32,12 @@ export declare enum EventsEnum {
     LIBRARY_ERROR = "library:error",
     LIBRARY_MEDIA_UPDATED = "library:media:updated",
     LIBRARY_PROGRESS = "library:progress",
+    LIBRARY_EFFECT_ADDED = "library:effect:added",// To Libary
+    LIBRARY_EFFECT_REMOVED = "library:effect:removed",// From Library
+    LIBRARY_FILTER_ADDED = "library:filter:added",
+    LIBRARY_FILTER_REMOVED = "library:filter:removed",
+    LIBRARY_TRANSITION_ADDED = "library:transition:added",
+    LIBRARY_TRANSITION_REMOVED = "library:transition:removed",
     SUBTITLES_ADDED = "subtitles:added",
     SUBTITLES_REMOVED = "subtitles:removed",
     SUBTITLES_MAIN_STYLE_UPDATED = "subtitles:main-style:updated",
@@ -39,6 +45,8 @@ export declare enum EventsEnum {
     SUBTITLES_ANIMATION_UPDATED = "subtitles:animation:updated",
     SUBTITLES_TEXT_MODE_UPDATED = "subtitles:text-mode:updated",
     SUBTITLES_TRANSFORM_UPDATED = "subtitles:transform:updated",
+    EFFECT_PROPERTY_CHANGED = "effect:property:changed",
+    TRANSITION_PROPERTY_CHANGED = "transition:property:changed",
     FONT_ADDED = "font:added",
     FONT_REMOVED = "font:removed",
     FONT_ERROR = "font:error",
@@ -128,23 +136,23 @@ export type EventPayloadMap = {
     };
     [EventsEnum.CLIP_FILTER_ADDED]: {
         clipId: string;
+        id: string;
         filterId: string;
-        sourceId: string;
     };
     [EventsEnum.CLIP_FILTER_REMOVED]: {
         clipId: string;
+        id: string;
         filterId: string;
-        sourceId: string;
     };
     [EventsEnum.CLIP_EFFECT_ADDED]: {
         clipId: string;
+        id: string;
         effectId: string;
-        sourceId: string;
     };
     [EventsEnum.CLIP_EFFECT_REMOVED]: {
         clipId: string;
+        id: string;
         effectId: string;
-        sourceId: string;
     };
     [EventsEnum.LIBRARY_ADDED]: {
         mediaDataId: string;
@@ -179,6 +187,34 @@ export type EventPayloadMap = {
     [EventsEnum.SUBTITLES_ANIMATION_UPDATED]: undefined;
     [EventsEnum.SUBTITLES_TEXT_MODE_UPDATED]: undefined;
     [EventsEnum.SUBTITLES_TRANSFORM_UPDATED]: undefined;
+    [EventsEnum.LIBRARY_EFFECT_ADDED]: {
+        effectId: string;
+    };
+    [EventsEnum.LIBRARY_EFFECT_REMOVED]: {
+        effectId: string;
+    };
+    [EventsEnum.LIBRARY_FILTER_ADDED]: {
+        filterId: string;
+    };
+    [EventsEnum.LIBRARY_FILTER_REMOVED]: {
+        filterId: string;
+    };
+    [EventsEnum.LIBRARY_TRANSITION_ADDED]: {
+        transitionId: string;
+    };
+    [EventsEnum.LIBRARY_TRANSITION_REMOVED]: {
+        transitionId: string;
+    };
+    [EventsEnum.EFFECT_PROPERTY_CHANGED]: {
+        id: string;
+        property: string;
+        value: any;
+    };
+    [EventsEnum.TRANSITION_PROPERTY_CHANGED]: {
+        id: string;
+        property: string;
+        value: any;
+    };
     [EventsEnum.FONT_ADDED]: {
         fontId: string;
     };

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

@@ -29,4 +29,5 @@ export interface MediaInfoStream {
     frameCount?: number;
     sampleRate?: number;
     channels?: number;
+    hasAlpha?: boolean;
 }

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

@@ -2,47 +2,52 @@ import * as PIXI from "pixi.js";
 import { z } from "zod";
 export declare const FilterSchema: z.ZodObject<{
     id: z.ZodString;
-    sourceId: z.ZodString;
-    options: z.ZodObject<{
-        lutUrl: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        lutUrl: string;
-    }, {
-        lutUrl: string;
-    }>;
+    filterId: z.ZodString;
+    provider: z.ZodString;
+    clipId: z.ZodOptional<z.ZodString>;
+    intensity: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     id: string;
-    options: {
-        lutUrl: string;
-    };
-    sourceId: string;
+    provider: string;
+    filterId: string;
+    intensity: number;
+    clipId?: string | undefined;
 }, {
     id: string;
-    options: {
-        lutUrl: string;
-    };
-    sourceId: string;
+    provider: string;
+    filterId: string;
+    intensity: number;
+    clipId?: string | undefined;
 }>;
 export interface FilterOptions {
-    lutUrl: string;
-    sourceId: string;
+    filterId: string;
+    intensity?: number;
+    clipId?: string;
 }
 export declare class Filter {
-    id: string;
-    private sourceId;
-    lutUrl: string;
-    intensity: number;
+    private id;
+    private readonly filterId;
+    private provider;
+    private clipId?;
+    private intensity;
     private lutTexture;
     private pixiFilter;
     constructor(options: FilterOptions);
-    getSourceId(): string;
+    init(): void;
+    getId(): string;
+    setClipId(clipId: string): void;
+    getClipId(): string | undefined;
+    getProvider(): string;
+    setIntensity(intensity: number): void;
+    getIntensity(): number;
+    getFilterId(): string;
     getPixiFilter(): PIXI.Filter;
     serialize(): {
         id: string;
-        options: {
-            lutUrl: string;
-        };
-        sourceId: string;
+        provider: string;
+        filterId: string;
+        intensity: number;
+        clipId?: string | undefined;
     };
     static deserialize(data: object): Filter;
 }

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

@@ -11,8 +11,8 @@ export declare const MaskFilterSchema: z.ZodObject<{
     clipId: z.ZodString;
     wrapMode: z.ZodDefault<z.ZodNativeEnum<typeof MaskWrapModeEnum>>;
 }, "strict", z.ZodTypeAny, {
-    id: string;
     wrapMode: MaskWrapModeEnum;
+    id: string;
     clipId: string;
 }, {
     id: string;

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

@@ -1,2 +1,2 @@
 export * from "./Filter";
-export * from "./Effect";
+export * from "./MaskFilter";

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

@@ -17,43 +17,43 @@ export declare const LayerSchema: z.ZodObject<{
     clips: z.ZodArray<z.ZodAny, "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">;
+        transitionId: z.ZodString;
+        provider: z.ZodString;
+        properties: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodAny], null>, "many">;
     }, "strip", z.ZodTypeAny, {
-        type: "transition";
-        name: string;
         id: string;
+        provider: string;
+        properties: [string, any][];
         startClipId: string;
         endClipId: string;
         inDuration: number;
         outDuration: number;
-        transitionSrc: string;
+        transitionId: string;
     }, {
-        type: "transition";
-        name: string;
         id: string;
+        provider: string;
+        properties: [string, any][];
         startClipId: string;
         endClipId: string;
         inDuration: number;
         outDuration: number;
-        transitionSrc: string;
+        transitionId: string;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     id: string;
     transitions: {
-        type: "transition";
-        name: string;
         id: string;
+        provider: string;
+        properties: [string, any][];
         startClipId: string;
         endClipId: string;
         inDuration: number;
         outDuration: number;
-        transitionSrc: string;
+        transitionId: string;
     }[];
     clips: any[];
     visible?: boolean | undefined;
@@ -62,14 +62,14 @@ export declare const LayerSchema: z.ZodObject<{
 }, {
     id: string;
     transitions: {
-        type: "transition";
-        name: string;
         id: string;
+        provider: string;
+        properties: [string, any][];
         startClipId: string;
         endClipId: string;
         inDuration: number;
         outDuration: number;
-        transitionSrc: string;
+        transitionId: string;
     }[];
     clips: any[];
     visible?: boolean | undefined;
@@ -100,7 +100,8 @@ export declare class Layer {
     moveClipToLayer(clipId: string, newLayerId: string): void;
     splitClip(clipId: string, time: number): Promise<Clip | null>;
     addTransition(data: TransitionOptions | Transition): void;
-    removeTransition(transitionId: string): void;
+    removeTransition(id: string): void;
+    removeAllTransitionsByTransitionId(transitionId: string): void;
     getTransitions(): Transition[];
     getDuration(): number;
     hasEmptySpace(startTime: number, endTime: number): boolean;
@@ -118,14 +119,14 @@ export declare class Layer {
     serialize(): {
         id: string;
         transitions: {
-            type: "transition";
-            name: string;
             id: string;
+            provider: string;
+            properties: [string, any][];
             startClipId: string;
             endClipId: string;
             inDuration: number;
             outDuration: number;
-            transitionSrc: string;
+            transitionId: string;
         }[];
         clips: any[];
         visible?: boolean | undefined;

package/dist/modules/library/BuiltInEffectDefines.d.ts

@@ -0,0 +1,7 @@
+import { EffectDataOptions } from "./EffectData";
+export declare enum BuiltInEffectIdEnum {
+    BLUR = "builtin-blur",
+    GLOW = "builtin-glow"
+}
+export declare const BuiltInEffectIds: BuiltInEffectIdEnum[];
+export declare const BuiltInEffectOptions: EffectDataOptions[];

package/dist/modules/library/EffectData.d.ts

@@ -0,0 +1,141 @@
+import * as PIXI from "pixi.js";
+import { z } from "zod";
+import { PropertyDescription } from "./types/Property.types";
+import { InputTextureDescriptor } from "./types/Texture.types";
+export interface EffectDataOptions {
+    id?: string;
+    name?: string;
+    provider?: string;
+    fragmentSrc: string;
+    properties?: PropertyDescription[];
+    inputTextures?: InputTextureDescriptor[];
+    serializable?: boolean;
+}
+export declare const EffectDataSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    provider: z.ZodString;
+    fragmentSrc: z.ZodString;
+    properties: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodNativeEnum<typeof import("./types/Property.types").PropertyDescriptionTypeEnum>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        defaultValue: z.ZodType<Required<any>, z.ZodTypeDef, Required<any>>;
+    }, "strip", z.ZodTypeAny, {
+        type: import("./types/Property.types").PropertyDescriptionTypeEnum;
+        name: string;
+        defaultValue: Required<any>;
+        label?: string | undefined;
+        description?: string | undefined;
+    }, {
+        type: import("./types/Property.types").PropertyDescriptionTypeEnum;
+        name: string;
+        defaultValue: Required<any>;
+        label?: string | undefined;
+        description?: string | undefined;
+    }>, "many">;
+    inputTextures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodString;
+        wrapMode: z.ZodOptional<z.ZodNativeEnum<typeof import("./types/Texture.types").InputTextureWrapMode>>;
+        scaleMode: z.ZodOptional<z.ZodNativeEnum<typeof import("./types/Texture.types").InputTextureScaleMode>>;
+        mipmap: z.ZodOptional<z.ZodNativeEnum<typeof import("./types/Texture.types").InputTextureMipmapMode>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        url: string;
+        wrapMode?: import("./types/Texture.types").InputTextureWrapMode | undefined;
+        scaleMode?: import("./types/Texture.types").InputTextureScaleMode | undefined;
+        mipmap?: import("./types/Texture.types").InputTextureMipmapMode | undefined;
+    }, {
+        name: string;
+        url: string;
+        wrapMode?: import("./types/Texture.types").InputTextureWrapMode | undefined;
+        scaleMode?: import("./types/Texture.types").InputTextureScaleMode | undefined;
+        mipmap?: import("./types/Texture.types").InputTextureMipmapMode | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    provider: string;
+    fragmentSrc: string;
+    properties: {
+        type: import("./types/Property.types").PropertyDescriptionTypeEnum;
+        name: string;
+        defaultValue: Required<any>;
+        label?: string | undefined;
+        description?: string | undefined;
+    }[];
+    inputTextures?: {
+        name: string;
+        url: string;
+        wrapMode?: import("./types/Texture.types").InputTextureWrapMode | undefined;
+        scaleMode?: import("./types/Texture.types").InputTextureScaleMode | undefined;
+        mipmap?: import("./types/Texture.types").InputTextureMipmapMode | undefined;
+    }[] | undefined;
+}, {
+    name: string;
+    id: string;
+    provider: string;
+    fragmentSrc: string;
+    properties: {
+        type: import("./types/Property.types").PropertyDescriptionTypeEnum;
+        name: string;
+        defaultValue: Required<any>;
+        label?: string | undefined;
+        description?: string | undefined;
+    }[];
+    inputTextures?: {
+        name: string;
+        url: string;
+        wrapMode?: import("./types/Texture.types").InputTextureWrapMode | undefined;
+        scaleMode?: import("./types/Texture.types").InputTextureScaleMode | undefined;
+        mipmap?: import("./types/Texture.types").InputTextureMipmapMode | undefined;
+    }[] | undefined;
+}>;
+export declare class EffectData {
+    private readonly id;
+    private readonly name;
+    private readonly provider;
+    private readonly fragmentSrc;
+    private readonly properties;
+    private readonly inputTextures?;
+    private readonly serializable;
+    private initialized;
+    private readonly defaultPropertyMap;
+    private readonly textures;
+    constructor(options: EffectDataOptions);
+    init(): Promise<void>;
+    getInputTextures(): InputTextureDescriptor[] | undefined;
+    getTextureImage(name: string): ImageBitmap | undefined;
+    createPixiTexture(name: string): PIXI.Texture<PIXI.Resource> | null;
+    getId(): string;
+    getName(): string;
+    getProvider(): string;
+    getIsBuiltIn(): boolean;
+    getProperties(): PropertyDescription[];
+    getDefaultPropertyMap(): ReadonlyMap<string, any>;
+    getIsSerializable(): boolean;
+    createEffectInstance(initPropertyMap: Map<string, any>, inputTextures: Record<string, PIXI.Texture>): import("../effect/EffectBase").EffectBase | null;
+    serialize(): {
+        name: string;
+        id: string;
+        provider: string;
+        fragmentSrc: string;
+        properties: {
+            type: import("./types/Property.types").PropertyDescriptionTypeEnum;
+            name: string;
+            defaultValue: Required<any>;
+            label?: string | undefined;
+            description?: string | undefined;
+        }[];
+        inputTextures?: {
+            name: string;
+            url: string;
+            wrapMode?: import("./types/Texture.types").InputTextureWrapMode | undefined;
+            scaleMode?: import("./types/Texture.types").InputTextureScaleMode | undefined;
+            mipmap?: import("./types/Texture.types").InputTextureMipmapMode | undefined;
+        }[] | undefined;
+    };
+    static deserialize(data: any): EffectData;
+}

package/dist/modules/library/FilterData.d.ts

@@ -0,0 +1,49 @@
+import * as PIXI from "pixi.js";
+import { z } from "zod";
+export declare const FilterDataSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    provider: z.ZodString;
+    lutUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    provider: string;
+    lutUrl: string;
+}, {
+    name: string;
+    id: string;
+    provider: string;
+    lutUrl: string;
+}>;
+export interface FilterDataOptions {
+    id?: string;
+    lutUrl: string;
+    name?: string;
+    provider?: string;
+    serializable?: boolean;
+}
+export declare class FilterData {
+    private readonly id;
+    private readonly lutUrl;
+    private readonly name;
+    private readonly provider;
+    private lutImage;
+    private readonly serializable;
+    private initialized;
+    constructor(options: FilterDataOptions);
+    init(): Promise<void>;
+    getId(): string;
+    getName(): string;
+    getProvider(): string;
+    getLutUrl(): string;
+    getIsSerializable(): boolean;
+    createPixiTexture(): PIXI.Texture<PIXI.Resource> | null;
+    serialize(): {
+        name: string;
+        id: string;
+        provider: string;
+        lutUrl: string;
+    };
+    static deserialize(data: object): FilterData;
+}