@shotstack/shotstack-studio 1.0.0

package/LICENSE

@@ -0,0 +1,164 @@
+# PolyForm Shield License 1.0.0
+
+<https://polyformproject.org/licenses/shield/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose. However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software. Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software. For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncompete
+
+Any purpose is a permitted purpose, except for providing any
+product that competes with the software or any product the
+licensor or any of its affiliates provides using the software.
+
+## Competition
+
+Goods and services compete even when they provide functionality
+through different kinds of interfaces or for different technical
+platforms. Applications can compete with services, libraries
+with plugins, frameworks with development tools, and so on,
+even if they're written in different programming languages
+or for different computer architectures. Goods and services
+compete even when provided free of charge. If you market a
+product as a practical substitute for the software or another
+product, it definitely competes.
+
+## New Products
+
+If you are using the software to provide a product that does
+not compete, but the licensor or any of its affiliates brings
+your product into competition by providing a new version of
+the software or another product using the software, you may
+continue using versions of the software available under these
+terms beforehand to provide your competing product, but not
+any later versions.
+
+## Discontinued Products
+
+You may begin using the software to compete with a product
+or service that the licensor or any of its affiliates has
+stopped providing, unless the licensor includes a plain-text
+line beginning with `Licensor Line of Business:` with the
+software that mentions that line of business. For example:
+
+> Licensor Line of Business: YoyodyneCMS Content Management
+> System (http://example.com/cms)
+
+## Sales of Business
+
+If the licensor or any of its affiliates sells a line of
+business developing the software or using the software
+to provide a product, the buyer can also enforce
+[Noncompete](#noncompete) for that product.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else. These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice. Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+**_As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim._**
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+A **product** can be a good or service, or a combination
+of them.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+its affiliates.
+
+**Affiliates** means the other organizations than an
+organization has control over, is under the control of, or is
+under common control with.
+
+**Control** means ownership of substantially all the assets of
+an entity, or the power to direct its management and policies
+by vote, contract, or otherwise. Control can be direct or
+indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.

package/dist/core/animations/curve-interpolator.d.ts

@@ -0,0 +1,6 @@
+export declare class CurveInterpolator {
+    private curves;
+    constructor();
+    private initializeCurves;
+    getValue(from: number, to: number, progress: number, easing?: string): number;
+}

package/dist/core/animations/effect-preset-builder.d.ts

@@ -0,0 +1,18 @@
+import { type Size } from "../layouts/geometry";
+import { type Clip } from "../schemas/clip";
+import { type Keyframe } from "../schemas/keyframe";
+export type EffectKeyframeSet = {
+    offsetXKeyframes: Keyframe[];
+    offsetYKeyframes: Keyframe[];
+    opacityKeyframes: Keyframe[];
+    scaleKeyframes: Keyframe[];
+    rotationKeyframes: Keyframe[];
+};
+export declare class EffectPresetBuilder {
+    private clipConfiguration;
+    constructor(clipConfiguration: Clip);
+    build(editSize: Size, clipSize: Size): EffectKeyframeSet;
+    private getPresetName;
+    private getZoomSpeed;
+    private getSlideStart;
+}

package/dist/core/animations/keyframe-builder.d.ts

@@ -0,0 +1,12 @@
+import { type Keyframe } from "../schemas/keyframe";
+export declare class KeyframeBuilder {
+    private readonly property;
+    private readonly length;
+    private readonly cubicBuilder;
+    constructor(value: Keyframe[] | number, length: number, initialValue?: number);
+    getValue(time: number): number;
+    private createKeyframes;
+    private createNormalizedKeyframes;
+    private validateKeyframes;
+    private insertFillerKeyframes;
+}

package/dist/core/animations/transition-preset-builder.d.ts

@@ -0,0 +1,20 @@
+import { type Clip } from "../schemas/clip";
+import { type Keyframe } from "../schemas/keyframe";
+export type TransitionKeyframeSet = {
+    offsetXKeyframes: Keyframe[];
+    offsetYKeyframes: Keyframe[];
+    opacityKeyframes: Keyframe[];
+    scaleKeyframes: Keyframe[];
+    rotationKeyframes: Keyframe[];
+};
+export declare class TransitionPresetBuilder {
+    private clipConfiguration;
+    constructor(clipConfiguration: Clip);
+    build(): TransitionKeyframeSet;
+    private buildInPreset;
+    private buildOutPreset;
+    private getInPresetName;
+    private getOutPresetName;
+    private getInPresetLength;
+    private getOutPresetLength;
+}

package/dist/core/entities/audio-player.d.ts

@@ -0,0 +1,17 @@
+import { type Size } from "../layouts/geometry";
+import { type Clip } from "../schemas/clip";
+import type { Edit } from "./edit";
+import { Player } from "./player";
+export declare class AudioPlayer extends Player {
+    private audioResource;
+    private isPlaying;
+    private volumeKeyframeBuilder;
+    private syncTimer;
+    constructor(edit: Edit, clipConfiguration: Clip);
+    load(): Promise<void>;
+    update(deltaTime: number, elapsed: number): void;
+    draw(): void;
+    dispose(): void;
+    getSize(): Size;
+    getVolume(): number;
+}

package/dist/core/entities/edit.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { EventEmitter } from "../events/event-emitter";
+import type { Size } from "../layouts/geometry";
+import { AssetLoader } from "../loaders/asset-loader";
+import { ClipSchema } from "../schemas/clip";
+import { EditSchema } from "../schemas/edit";
+import { TrackSchema } from "../schemas/track";
+import { Entity } from "./entity";
+type EditType = z.infer<typeof EditSchema>;
+type ClipType = z.infer<typeof ClipSchema>;
+type TrackType = z.infer<typeof TrackSchema>;
+export declare class Edit extends Entity {
+    private static readonly ZIndexPadding;
+    assetLoader: AssetLoader;
+    events: EventEmitter;
+    private edit;
+    private tracks;
+    private clipsToDispose;
+    private clips;
+    playbackTime: number;
+    totalDuration: number;
+    constructor(size: Size, backgroundColor?: string);
+    load(): Promise<void>;
+    play(): void;
+    pause(): void;
+    seek(target: number): void;
+    stop(): void;
+    loadEdit(edit: EditType): Promise<void>;
+    getEdit(): EditType;
+    addClip(trackIdx: number, clip: ClipType): void;
+    getClip(trackIdx: number, clipIdx: number): ClipType | null;
+    deleteClip(trackIdx: number, clipIdx: number): void;
+    addTrack(trackIdx: number, track: TrackType): void;
+    getTrack(trackIdx: number): TrackType | null;
+    deleteTrack(trackIdx: number): void;
+    getTotalDuration(): number;
+    private queueDisposeClip;
+    protected disposeClips(): void;
+    private disposeClip;
+    private unloadClipAssets;
+    protected clearClips(): void;
+    private updateTotalDuration;
+    private createPlayerFromAssetType;
+    private addPlayer;
+}
+export {};

package/dist/core/entities/entity.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class Entity {
+    private readonly container;
+    constructor();
+    abstract load(): Promise<void>;
+}

package/dist/core/entities/html-player.d.ts

@@ -0,0 +1,17 @@
+import { type Size } from "../layouts/geometry";
+import { type Clip } from "../schemas/clip";
+import type { Edit } from "./edit";
+import { Player } from "./player";
+export declare class HtmlPlayer extends Player {
+    private background;
+    private text;
+    constructor(timeline: Edit, clipConfiguration: Clip);
+    load(): Promise<void>;
+    update(deltaTime: number, elapsed: number): void;
+    draw(): void;
+    dispose(): void;
+    getSize(): Size;
+    protected getFitScale(): number;
+    private parseDocument;
+    private parseAlignment;
+}

package/dist/core/entities/image-player.d.ts

@@ -0,0 +1,15 @@
+import { type Size } from "../layouts/geometry";
+import { type Clip } from "../schemas/clip";
+import type { Edit } from "./edit";
+import { Player } from "./player";
+export declare class ImagePlayer extends Player {
+    private texture;
+    private sprite;
+    constructor(timeline: Edit, clipConfiguration: Clip);
+    load(): Promise<void>;
+    update(deltaTime: number, elapsed: number): void;
+    draw(): void;
+    dispose(): void;
+    getSize(): Size;
+    private createCroppedTexture;
+}

package/dist/core/entities/inspector.d.ts

@@ -0,0 +1,18 @@
+import { Entity } from "./entity";
+export declare class Inspector extends Entity {
+    private static readonly Width;
+    private static readonly Height;
+    fps: number;
+    playbackTime: number;
+    playbackDuration: number;
+    isPlaying: boolean;
+    private background;
+    private text;
+    constructor();
+    load(): Promise<void>;
+    update(_: number, __: number): void;
+    draw(): void;
+    dispose(): void;
+    private getMemoryInfo;
+    private bytesToMegabytes;
+}

package/dist/core/entities/luma-player.d.ts

@@ -0,0 +1,18 @@
+import * as pixi from "pixi.js";
+import { type Size } from "../layouts/geometry";
+import { type Clip } from "../schemas/clip";
+import type { Edit } from "./edit";
+import { Player } from "./player";
+export declare class LumaPlayer extends Player {
+    private texture;
+    private sprite;
+    private isPlaying;
+    constructor(edit: Edit, clipConfiguration: Clip);
+    load(): Promise<void>;
+    update(deltaTime: number, elapsed: number): void;
+    draw(): void;
+    dispose(): void;
+    getSize(): Size;
+    getVolume(): number;
+    getMask(): pixi.Sprite | null;
+}

package/dist/core/entities/player.d.ts

@@ -0,0 +1,73 @@
+import { type Size, type Vector } from "../layouts/geometry";
+import { type Clip } from "../schemas/clip";
+import { type Edit } from "./edit";
+import { Entity } from "./entity";
+/**
+ * TODO: Move handles on UI level (screen space)
+ * TODO: Handle overlapping frames - ex: length of a clip is 1.5s but there's an in (1s) and out (1s) transition
+ * TODO: Scale X and Y needs to be implemented separately for getFitScale cover
+ * TODO: Move animation effects and transitions out of player
+ * TODO: On pointer down and custom keyframe, add a keyframe at the current time. Get current and time and push a keyframe into the state, and then reconfigure the keyframes.
+ * TODO: Move bounding box to a separate entity
+ */
+export declare abstract class Player extends Entity {
+    private static readonly SnapThreshold;
+    private static readonly DiscardedFrameCount;
+    private static readonly ScaleHandleRadius;
+    private static readonly RotationHandleRadius;
+    private static readonly RotationHandleOffset;
+    private static readonly OutlineWidth;
+    private static readonly MinScale;
+    private static readonly MaxScale;
+    layer: number;
+    shouldDispose: boolean;
+    protected edit: Edit;
+    clipConfiguration: Clip;
+    private positionBuilder;
+    private offsetXKeyframeBuilder?;
+    private offsetYKeyframeBuilder?;
+    private scaleKeyframeBuilder?;
+    private opacityKeyframeBuilder?;
+    private rotationKeyframeBuilder?;
+    private outline;
+    private topLeftScaleHandle;
+    private topRightScaleHandle;
+    private bottomLeftScaleHandle;
+    private bottomRightScaleHandle;
+    private rotationHandle;
+    private isHovering;
+    private isDragging;
+    private dragOffset;
+    private scaleDirection;
+    private scaleStart;
+    private scaleOffset;
+    private isRotating;
+    private rotationStart;
+    private rotationOffset;
+    constructor(edit: Edit, clipConfiguration: Clip);
+    protected configureKeyframes(): void;
+    load(): Promise<void>;
+    update(_: number, __: number): void;
+    draw(): void;
+    dispose(): void;
+    getStart(): number;
+    getLength(): number;
+    getEnd(): number;
+    getPlaybackTime(): number;
+    abstract getSize(): Size;
+    getOpacity(): number;
+    getPosition(): Vector;
+    getPivot(): Vector;
+    protected getFitScale(): number;
+    getScale(): number;
+    getRotation(): number;
+    isActive(): boolean;
+    shouldDiscardFrame(): boolean;
+    private onPointerStart;
+    private onPointerMove;
+    private onPointerUp;
+    private onPointerOver;
+    private onPointerOut;
+    private clipHasPresets;
+    private clipHasKeyframes;
+}

package/dist/core/entities/shape-player.d.ts

@@ -0,0 +1,15 @@
+import { type Size } from "../layouts/geometry";
+import { type Clip } from "../schemas/clip";
+import type { Edit } from "./edit";
+import { Player } from "./player";
+export declare class ShapePlayer extends Player {
+    private shape;
+    private shapeBackground;
+    constructor(timeline: Edit, clipConfiguration: Clip);
+    load(): Promise<void>;
+    update(deltaTime: number, elapsed: number): void;
+    draw(): void;
+    dispose(): void;
+    getSize(): Size;
+    protected getFitScale(): number;
+}

package/dist/core/entities/text-player.d.ts

@@ -0,0 +1,18 @@
+import { type Size } from "../layouts/geometry";
+import { type Clip } from "../schemas/clip";
+import type { Edit } from "./edit";
+import { Player } from "./player";
+/**
+ * TODO: Add constants for text defaults
+ */
+export declare class TextPlayer extends Player {
+    private background;
+    private text;
+    constructor(timeline: Edit, clipConfiguration: Clip);
+    load(): Promise<void>;
+    update(deltaTime: number, elapsed: number): void;
+    draw(): void;
+    dispose(): void;
+    getSize(): Size;
+    protected getFitScale(): number;
+}

package/dist/core/entities/video-player.d.ts

@@ -0,0 +1,22 @@
+import { type Size } from "../layouts/geometry";
+import { type Clip } from "../schemas/clip";
+import type { Edit } from "./edit";
+import { Player } from "./player";
+export declare class VideoPlayer extends Player {
+    private texture;
+    private sprite;
+    private isPlaying;
+    private volumeKeyframeBuilder;
+    private syncTimer;
+    constructor(edit: Edit, clipConfiguration: Clip);
+    /**
+     * TODO: Add support for .mov and .webm files
+     */
+    load(): Promise<void>;
+    update(deltaTime: number, elapsed: number): void;
+    draw(): void;
+    dispose(): void;
+    getSize(): Size;
+    getVolume(): number;
+    private createCroppedTexture;
+}

package/dist/core/events/asset-load-tracker.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from "./event-emitter";
+export type AssetLoadInfoStatus = "pending" | "loading" | "success" | "failed";
+export type AssetLoadInfo = {
+    progress: number;
+    status: AssetLoadInfoStatus;
+};
+export type AssetLoadInfoUpdatedPayload = {
+    registry: Record<string, AssetLoadInfo>;
+};
+export type AssetEventMap = {
+    onAssetLoadInfoUpdated: AssetLoadInfoUpdatedPayload;
+};
+export declare class AssetLoadTracker extends EventEmitter<AssetEventMap> {
+    registry: Record<string, AssetLoadInfo>;
+    constructor();
+}

package/dist/core/events/event-emitter.d.ts

@@ -0,0 +1,10 @@
+export type Listener<TPayload = any> = (payload: TPayload) => void;
+export type EventPayloadMap<TPayload = any> = Record<string, TPayload>;
+export declare class EventEmitter<TEventPayloadMap extends EventPayloadMap = EventPayloadMap> {
+    private readonly events;
+    constructor();
+    on<TEventName extends keyof TEventPayloadMap>(name: TEventName, listener: Listener<TEventPayloadMap[TEventName]>): void;
+    off<TEventName extends keyof TEventPayloadMap>(name: TEventName, listener: Listener<TEventPayloadMap[TEventName]>): void;
+    clear(name: keyof TEventPayloadMap): void;
+    emit<TEventName extends keyof TEventPayloadMap>(name: TEventName, payload: TEventPayloadMap[TEventName]): void;
+}

package/dist/core/export/video-exporter.d.ts

@@ -0,0 +1,17 @@
+import { Edit } from "../entities/edit";
+import { Canvas } from "../shotstack-canvas";
+export declare class VideoExporter {
+    private readonly ffmpeg;
+    private isReady;
+    private readonly edit;
+    private readonly application;
+    constructor(edit: Edit, canvas: Canvas);
+    private init;
+    export(filename?: string, fps?: number): Promise<void>;
+    private findAudioPlayers;
+    private searchContainerForPlayers;
+    private processAudioTrack;
+    private createProgressOverlay;
+    private updateProgressOverlay;
+    private removeProgressOverlay;
+}

package/dist/core/inputs/controls.d.ts

@@ -0,0 +1,11 @@
+import { Edit } from "../entities/edit";
+export declare class Controls {
+    private edit;
+    private seekDistance;
+    private seekDistanceLarge;
+    private frameTime;
+    constructor(timeline: Edit);
+    load(): Promise<void>;
+    private handleKeyDown;
+    private handleKeyUp;
+}

package/dist/core/inputs/pointer.d.ts

@@ -0,0 +1,4 @@
+export declare class Pointer {
+    static readonly ButtonLeftClick = 0;
+    static readonly ButtonRightClick = 3;
+}

package/dist/core/layouts/geometry.d.ts

@@ -0,0 +1,8 @@
+export type Vector = {
+    x: number;
+    y: number;
+};
+export type Size = {
+    width: number;
+    height: number;
+};

package/dist/core/layouts/position-builder.d.ts

@@ -0,0 +1,8 @@
+import { type ClipAnchor } from "../schemas/clip";
+import { type Size, type Vector } from "./geometry";
+export declare class PositionBuilder {
+    private containerSize;
+    constructor(containerSize: Size);
+    relativeToAbsolute(entitySize: Size, anchor: ClipAnchor, relativePosition: Vector): Vector;
+    absoluteToRelative(entitySize: Size, anchor: ClipAnchor, absolutePosition: Vector): Vector;
+}

package/dist/core/loaders/asset-loader.d.ts

@@ -0,0 +1,9 @@
+import * as pixi from "pixi.js";
+import { AssetLoadTracker } from "../events/asset-load-tracker";
+export declare class AssetLoader {
+    loadTracker: AssetLoadTracker;
+    constructor();
+    load<TResolvedAsset>(identifier: string, loadOptions: pixi.UnresolvedAsset): Promise<TResolvedAsset | null>;
+    getProgress(): number;
+    private updateAssetLoadMetadata;
+}

package/dist/core/loaders/audio-load-parser.d.ts

@@ -0,0 +1,11 @@
+import * as pixi from "pixi.js";
+export declare class AudioLoadParser implements pixi.LoaderParser<Howl | null> {
+    static readonly Name = "AudioLoadParser";
+    name: string;
+    extension: pixi.ExtensionFormat;
+    private validAudioExtensions;
+    constructor();
+    test(url: string): boolean;
+    load(url: string, _?: pixi.ResolvedAsset<Howl>, __?: pixi.Loader): Promise<Howl | null>;
+    unload(asset: Howl | null): void;
+}

package/dist/core/loaders/font-load-parser.d.ts

@@ -0,0 +1,13 @@
+import * as pixi from "pixi.js";
+export declare class FontLoadParser implements pixi.LoaderParser<FontFace | null> {
+    static readonly Name = "FontLoadParser";
+    name: string;
+    extension: pixi.ExtensionFormat;
+    private validFontExtensions;
+    private woff2Decompressor;
+    constructor();
+    test(url: string): boolean;
+    load(url: string, _?: pixi.ResolvedAsset<FontFace>, __?: pixi.Loader): Promise<FontFace | null>;
+    private loadWoff2Decompressor;
+    unload(asset: FontFace | null): void;
+}