@rendley/sdk 1.6.0 → 1.7.1

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

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { ShapeSprite } from "./ShapeSprite";
 import { ClipStyle, ClipStyleOptions } from "../../ClipStyle";
 interface ShapeClipStyleOptions extends ClipStyleOptions {
@@ -7,6 +8,58 @@ interface ShapeClipStyleOptions extends ClipStyleOptions {
     strokeAlpha?: number;
     hasFill?: boolean;
 }
+export declare const ShapeStyleSchema: z.ZodObject<{
+    height: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    mediaDataId: z.ZodOptional<z.ZodString>;
+    clipId: 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;
+    cornerRadius: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    relativeCornerRadius: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    fillColor: z.ZodOptional<z.ZodString>;
+    strokeColor: z.ZodOptional<z.ZodString>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeAlpha: z.ZodOptional<z.ZodNumber>;
+    hasFill: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    clipId: string;
+    alpha: number;
+    rotation: number;
+    position: [number, number];
+    scale: [number, number];
+    zIndex: number;
+    relativeCornerRadius: boolean;
+    hasFill: boolean;
+    height?: number | undefined;
+    width?: number | undefined;
+    mediaDataId?: string | undefined;
+    cornerRadius?: [number, number, number, number] | undefined;
+    fillColor?: string | undefined;
+    strokeColor?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeAlpha?: number | undefined;
+}, {
+    clipId: string;
+    alpha: number;
+    rotation: number;
+    position: [number, number];
+    scale: [number, number];
+    zIndex: number;
+    height?: number | undefined;
+    width?: number | undefined;
+    mediaDataId?: string | undefined;
+    cornerRadius?: [number, number, number, number] | undefined;
+    relativeCornerRadius?: boolean | undefined;
+    fillColor?: string | undefined;
+    strokeColor?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeAlpha?: number | undefined;
+    hasFill?: boolean | undefined;
+}>;
 export declare class ShapeStyle extends ClipStyle<ShapeSprite> {
     protected fillColor: string;
     protected strokeColor: string;

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

@@ -35,12 +35,24 @@ export declare class TextClip extends Clip<TextSprite, TextStyle> {
             };
             sourceId: string;
         }[];
-        effects: unknown[];
-        warpMode: import('../../../../index').WarpModeEnum;
+        effects: {
+            id: string;
+            options: {
+                textureWidth: number;
+                textureHeight: number;
+                frameWidth: number;
+                frameHeight: number;
+                fragmentSrc?: string | undefined;
+                uniforms?: Record<string, unknown> | undefined;
+            };
+            sourceId: string;
+        }[];
+        isVisible: boolean;
         style?: unknown;
         customData?: [string, unknown][] | undefined;
         mediaDataId?: string | undefined;
         subtitlesId?: string | undefined;
+        wrapMode?: import('../../../../index').WrapModeEnum | undefined;
         animationController?: {
             animationDataIn?: {
                 name: string;
@@ -107,6 +119,11 @@ export declare class TextClip extends Clip<TextSprite, TextStyle> {
             animationLoopCount?: number | undefined;
             loopSmoothing?: number | undefined;
         } | undefined;
+        clipMasks?: {
+            id: string;
+            clipId: string;
+            wrapMode: import("../../../filter/MaskFilter").MaskWrapModeEnum;
+        }[] | undefined;
     };
     static deserialize(payload: object): TextClip;
 }

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

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { TextSprite } from "./TextSprite";
 import { ClipStyle, ClipStyleOptions } from "../../ClipStyle";
 import { TextStyleAlign, TextStyleFontStyle, TextStyleFontWeight } from '../../../../types/text.types';
@@ -12,7 +13,78 @@ interface TextClipStyleOptions extends ClipStyleOptions {
     wordWrapWidth?: number | null;
     strokeColor?: string;
     strokeThickness?: number;
+    padding?: number[];
 }
+export declare const TextStyleSchema: z.ZodObject<{
+    height: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    mediaDataId: z.ZodOptional<z.ZodString>;
+    clipId: 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;
+    cornerRadius: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    relativeCornerRadius: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    fontSize: z.ZodNumber;
+    color: z.ZodString;
+    fontWeight: z.ZodEnum<["normal", "bold", "bolder", "lighter", "100", "200", "300", "400", "500", "600", "700", "800", "900"]>;
+    fontFamily: z.ZodString;
+    textAlign: z.ZodEnum<["left", "center", "right", "justify"]>;
+    fontStyle: z.ZodEnum<["normal", "italic", "oblique"]>;
+    backgroundColor: z.ZodNullable<z.ZodString>;
+    strokeColor: z.ZodDefault<z.ZodString>;
+    strokeThickness: z.ZodDefault<z.ZodNumber>;
+    wordWrapWidth: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    padding: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    clipId: string;
+    alpha: number;
+    rotation: number;
+    position: [number, number];
+    scale: [number, number];
+    zIndex: number;
+    relativeCornerRadius: boolean;
+    fontSize: number;
+    fontWeight: "bold" | "normal" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
+    fontFamily: string;
+    fontStyle: "normal" | "italic" | "oblique";
+    backgroundColor: string | null;
+    strokeThickness: number;
+    strokeColor: string;
+    padding: number[];
+    wordWrapWidth: number | null;
+    textAlign: "left" | "center" | "right" | "justify";
+    height?: number | undefined;
+    width?: number | undefined;
+    mediaDataId?: string | undefined;
+    cornerRadius?: [number, number, number, number] | undefined;
+}, {
+    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;
+    fontStyle: "normal" | "italic" | "oblique";
+    backgroundColor: string | null;
+    textAlign: "left" | "center" | "right" | "justify";
+    height?: number | undefined;
+    width?: number | undefined;
+    mediaDataId?: string | undefined;
+    cornerRadius?: [number, number, number, number] | undefined;
+    relativeCornerRadius?: boolean | undefined;
+    strokeColor?: string | undefined;
+    strokeThickness?: number | undefined;
+    wordWrapWidth?: number | null | undefined;
+    padding?: number[] | undefined;
+}>;
 export declare class TextStyle extends ClipStyle<TextSprite> {
     fontSize: number;
     color: string;
@@ -24,7 +96,9 @@ export declare class TextStyle extends ClipStyle<TextSprite> {
     wordWrapWidth: number | null;
     strokeColor: string;
     strokeThickness: number;
+    padding: number[];
     private isDirty;
+    protected animationColor: string | null;
     constructor(options: TextClipStyleOptions);
     setDirty(): void;
     setStrokeColor(strokeColor: string): void;
@@ -37,6 +111,8 @@ export declare class TextStyle extends ClipStyle<TextSprite> {
     setWordWrapWidth(wordWrapWidth: number | null): void;
     setColor(color: string): void;
     getColor(): string;
+    setAnimationColor(color: string | null): void;
+    getAnimationColor(): string | null;
     setFontWeight(fontWeight: TextStyleFontWeight): void;
     getFontWeight(): "bold" | "normal" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
     setFontFamily(fontFamily: string): void;
@@ -47,6 +123,8 @@ export declare class TextStyle extends ClipStyle<TextSprite> {
     getFontStyle(): "normal" | "italic" | "oblique";
     setBackgroundColor(backgroundColor: string | null): void;
     getBackgroundColor(): string | null;
+    setPadding(padding: number | number[]): void;
+    getPadding(): number[];
     update(container: TextSprite): void;
     serialize(): {
         color: string;
@@ -64,6 +142,8 @@ export declare class TextStyle extends ClipStyle<TextSprite> {
         backgroundColor: string | null;
         strokeThickness: number;
         strokeColor: string;
+        padding: number[];
+        wordWrapWidth: number | null;
         textAlign: "left" | "center" | "right" | "justify";
         height?: number | undefined;
         width?: number | undefined;

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

@@ -22,29 +22,34 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
     private decoder;
     private frameQueue;
     private isRendering;
+    private decoderFlushed;
     constructor(options: VideoClipOptions);
     init(layerId: string): Promise<void>;
     private getGlobalTimeToClipTime;
     getIsProcessing(): boolean;
     updateMediaData(newMediaId?: string): Promise<boolean>;
     preload(currentTime: number): void;
-    addActionToQueue(action: string, params?: object): void;
-    processNextQueue(): void;
+    private addActionToQueue;
+    private processNextQueue;
     private seekedCallback;
     private playingCallback;
     private pausedCallback;
     private endedCallback;
     private errorCallback;
     private videoLoadedCallback;
+    private isVideoReady;
+    private isAudioReady;
     setVolume(volume: number): void;
     getVolume(): number;
     private play;
     private pause;
     private renderSeek;
     private seek;
-    renderVideoFrameOutputCallback(frame: VideoFrame): void;
-    getNextRenderPacket(): Promise<void>;
-    searchRenderFrame(videoTime: number): Promise<VideoFrame | null>;
+    private renderVideoFrameOutputCallback;
+    private getNextRenderPacket;
+    private searchRenderFrame;
+    private initializeDecoder;
+    private destroyDecoder;
     onRenderStart(options: ExportOptions): Promise<void>;
     onRenderDone(canceled: boolean): Promise<void>;
     onPlay(currentTime: number): Promise<void>;
@@ -72,12 +77,24 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
             };
             sourceId: string;
         }[];
-        effects: unknown[];
-        warpMode: import('../../../../types').WarpModeEnum;
+        effects: {
+            id: string;
+            options: {
+                textureWidth: number;
+                textureHeight: number;
+                frameWidth: number;
+                frameHeight: number;
+                fragmentSrc?: string | undefined;
+                uniforms?: Record<string, unknown> | undefined;
+            };
+            sourceId: string;
+        }[];
+        isVisible: boolean;
         text?: string | undefined;
         style?: unknown;
         customData?: [string, unknown][] | undefined;
         subtitlesId?: string | undefined;
+        wrapMode?: import('../../../../types').WrapModeEnum | undefined;
         animationController?: {
             animationDataIn?: {
                 name: string;
@@ -144,6 +161,11 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
             animationLoopCount?: number | undefined;
             loopSmoothing?: number | undefined;
         } | undefined;
+        clipMasks?: {
+            id: string;
+            clipId: string;
+            wrapMode: import("../../../filter/MaskFilter").MaskWrapModeEnum;
+        }[] | undefined;
         volume?: number | undefined;
         muted?: boolean | undefined;
     };

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

@@ -1,4 +1,53 @@
 import * as PIXI from "pixi.js";
+import { z } from "zod";
+export declare const EffectSchema: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    options: z.ZodObject<{
+        fragmentSrc: z.ZodOptional<z.ZodString>;
+        uniforms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        textureWidth: z.ZodNumber;
+        textureHeight: z.ZodNumber;
+        frameWidth: z.ZodNumber;
+        frameHeight: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        textureWidth: number;
+        textureHeight: number;
+        frameWidth: number;
+        frameHeight: number;
+        fragmentSrc?: string | undefined;
+        uniforms?: Record<string, unknown> | undefined;
+    }, {
+        textureWidth: number;
+        textureHeight: number;
+        frameWidth: number;
+        frameHeight: number;
+        fragmentSrc?: string | undefined;
+        uniforms?: Record<string, unknown> | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    options: {
+        textureWidth: number;
+        textureHeight: number;
+        frameWidth: number;
+        frameHeight: number;
+        fragmentSrc?: string | undefined;
+        uniforms?: Record<string, unknown> | undefined;
+    };
+    sourceId: string;
+}, {
+    id: string;
+    options: {
+        textureWidth: number;
+        textureHeight: number;
+        frameWidth: number;
+        frameHeight: number;
+        fragmentSrc?: string | undefined;
+        uniforms?: Record<string, unknown> | undefined;
+    };
+    sourceId: string;
+}>;
 export interface EffectOptions {
     sourceId: string;
     fragmentSrc?: string;

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

@@ -0,0 +1,46 @@
+import * as PIXI from "pixi.js";
+import { z } from "zod";
+export declare enum MaskWrapModeEnum {
+    NONE = "none",
+    REPEAT = "repeat",
+    MIRROR = "mirror",
+    CLAMP = "clamp"
+}
+export declare const MaskFilterSchema: z.ZodObject<{
+    id: z.ZodString;
+    clipId: z.ZodString;
+    wrapMode: z.ZodDefault<z.ZodNativeEnum<typeof MaskWrapModeEnum>>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    clipId: string;
+    wrapMode: MaskWrapModeEnum;
+}, {
+    id: string;
+    clipId: string;
+    wrapMode?: MaskWrapModeEnum | undefined;
+}>;
+export interface MaskFilterOptions {
+    id?: string;
+    clipId: string;
+    maskSprite: PIXI.Sprite;
+    wrapMode?: MaskWrapModeEnum;
+}
+export declare class MaskFilter extends PIXI.Filter {
+    private _maskSprite;
+    private _clipId;
+    private _wrapMode;
+    private _tempMatrix;
+    private _id;
+    constructor(options: MaskFilterOptions);
+    private getWrapModeInt;
+    private updateTransformMatrix;
+    updateMaskTexture(): void;
+    get maskSprite(): PIXI.Sprite;
+    set maskSprite(value: PIXI.Sprite);
+    get clipId(): string;
+    set clipId(value: string);
+    get wrapMode(): MaskWrapModeEnum;
+    set wrapMode(value: MaskWrapModeEnum);
+    get id(): string;
+    apply(filterManager: PIXI.FilterSystem, input: PIXI.RenderTexture, output: PIXI.RenderTexture, clearMode?: PIXI.CLEAR_MODES, _currentState?: PIXI.FilterState): void;
+}

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

@@ -1,11 +1,11 @@
 import * as PIXI from "pixi.js";
 import { z } from "zod";
-import { AudioClipOptions, Clip, HtmlTextClipOptions, ImageClipOptions, TextClipOptions, VideoClipOptions } from "../clip";
+import { AudioClipOptions, Clip, ClipOptions, HtmlTextClipOptions, ImageClipOptions, TextClipOptions, VideoClipOptions } from "../clip";
 import { GifClipOptions } from "../clip/clips/gif/GifClip";
+import { LottieClipOptions } from "../clip/clips/lottie/LottieClip";
 import { ShapeClipOptions } from "../clip/clips/shape/ShapeClip";
 import { Transition, TransitionOptions } from "../transition/Transition";
-type ClipOptions = ImageClipOptions | VideoClipOptions | TextClipOptions | AudioClipOptions | GifClipOptions | ShapeClipOptions | HtmlTextClipOptions;
-export type ClipTypeRange = Pick<ClipOptions, "startTime" | "duration">;
+type ClipOptionsUnion = ClipOptions | ImageClipOptions | VideoClipOptions | TextClipOptions | AudioClipOptions | GifClipOptions | ShapeClipOptions | HtmlTextClipOptions | LottieClipOptions;
 export declare const LayerSchema: z.ZodObject<{
     id: z.ZodString;
     visible: z.ZodOptional<z.ZodBoolean>;
@@ -86,7 +86,7 @@ export declare class Layer {
     init(): Promise<void>;
     destroy(): void;
     addClip(options: Clip): Promise<Clip | null>;
-    addClip(options: ClipOptions): Promise<Clip | null>;
+    addClip(options: ClipOptionsUnion): Promise<Clip | null>;
     removeClip(clipId: string): boolean;
     setVolume(volume: number): void;
     getVolume(): number;

package/dist/modules/timeline/Timeline.d.ts

@@ -1,6 +1,11 @@
 import { z } from "zod";
 import { AudioClip, Clip } from "../clip";
 import { Layer } from "../layer";
+export declare enum AlignRoundEnum {
+    NEAREST = "nearest",
+    UP = "up",
+    DOWN = "down"
+}
 export declare const TimelineSchema: z.ZodObject<{
     startTime: z.ZodNumber;
     fps: z.ZodNumber;
@@ -150,7 +155,7 @@ export declare class Timeline {
     removeLayer(layerId: string): boolean;
     moveClipToLayer(clipId: string, newLayerId: string): Promise<void>;
     extractAudio(clip: string | Clip): AudioClip | undefined;
-    alignTime(time: number, roundUp?: boolean): number;
+    alignTime(time: number, roundDirection?: AlignRoundEnum): number;
     adjustClipsLayout(): void;
     getFps(): number;
     setFps(fps: number): void;

package/dist/modules/undo/UndoManager.types.d.ts

@@ -29,6 +29,7 @@ export declare enum UndoActionEnum {
     CLIP_TEXT_WORD_WRAP_WIDTH = "clip-text-word-wrap-width",
     CLIP_TEXT_STROKE_COLOR = "clip-text-stroke-color",
     CLIP_TEXT_STROKE_THICKNESS = "clip-text-stroke-thickness",
+    CLIP_TEXT_PADDING = "clip-text-padding",
     CLIP_HTML_TEXT = "clip-html-text",
     CLIP_HTML_STYLE = "clip-html-style",
     CLIP_LOTTIE_PROPERTY = "clip-lottie-property",
@@ -179,6 +180,11 @@ export type UndoActionMappings = {
         prevStrokeThickness: number;
         strokeThickness: number;
     };
+    [UndoActionEnum.CLIP_TEXT_PADDING]: {
+        clipId: string;
+        prevPadding: number | number[];
+        padding: number | number[];
+    };
     [UndoActionEnum.CLIP_HTML_TEXT]: {
         clipId: string;
         prevText: string;

package/dist/types/clip.types.d.ts

@@ -14,7 +14,7 @@ export declare enum ClipTypeEnum {
     COLOR = "color",
     GRADIENT = "gradient"
 }
-export declare enum WarpModeEnum {
+export declare enum WrapModeEnum {
     CLAMP = "clamp",
     REPEAT = "repeat",
     PING_PONG = "ping_ping",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rendley/sdk",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "license": "LICENSE",
   "author": "Onix Technologies",
   "homepage": "https://rendley.com",