@marcuth/movie.js 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marcuth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/clips/audio-clip.d.ts

@@ -0,0 +1,24 @@
+import { Path } from "../utils/resolve-path";
+import { RenderContext } from "../render-context";
+import { FFmpegInput } from "../ffmpeg-input";
+import { Clip } from "./clip";
+export type AudioClipOptions<RenderData> = {
+    path: Path<RenderData>;
+    volume?: number;
+    loop?: boolean;
+    subClip?: [number, number];
+    fadeIn?: number;
+    fadeOut?: number;
+};
+export declare class AudioClip<RenderData> extends Clip<RenderData> {
+    readonly path: Path<RenderData>;
+    readonly volume?: number;
+    readonly loop?: boolean;
+    readonly subClip?: [number, number];
+    readonly fadeIn?: number;
+    readonly fadeOut?: number;
+    constructor({ path, volume, loop, subClip, fadeIn, fadeOut, }: AudioClipOptions<RenderData>);
+    protected getInput(path: string, inputIndex: number): FFmpegInput;
+    getDuration(path: string): Promise<number>;
+    build(data: RenderData, context: RenderContext): Promise<void>;
+}

package/dist/clips/audio-clip.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioClip = void 0;
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const resolve_path_1 = require("../utils/resolve-path");
+const clip_1 = require("./clip");
+class AudioClip extends clip_1.Clip {
+    constructor({ path, volume, loop, subClip, fadeIn, fadeOut, }) {
+        super();
+        this.path = path;
+        this.volume = volume;
+        this.loop = loop;
+        this.subClip = subClip;
+        this.fadeIn = fadeIn;
+        this.fadeOut = fadeOut;
+    }
+    getInput(path, inputIndex) {
+        const inputOptions = [];
+        if (this.loop) {
+            inputOptions.push("-stream_loop", "-1");
+        }
+        if (this.subClip) {
+            const [start, end] = this.subClip;
+            inputOptions.push("-ss", `${start}`);
+            inputOptions.push("-to", `${end}`);
+        }
+        return {
+            path: path,
+            aliases: {
+                audio: `[${inputIndex}:a]`,
+            },
+            type: "audio",
+            options: inputOptions,
+            index: inputIndex
+        };
+    }
+    async getDuration(path) {
+        var _a, _b;
+        try {
+            const metadata = await new Promise((resolve, reject) => {
+                fluent_ffmpeg_1.default.ffprobe(path, (err, data) => err ? reject(err) : resolve(data));
+            });
+            return Math.floor((_b = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.format) === null || _a === void 0 ? void 0 : _a.duration) !== null && _b !== void 0 ? _b : 0);
+        }
+        catch (err) {
+            return 0;
+        }
+    }
+    async build(data, context) {
+        const path = (0, resolve_path_1.resolvePath)({ path: this.path, data: data, index: context.clipIndex });
+        const input = this.getInput(path, context.inputIndex);
+        context.command.input(input.path);
+        if (input.options && input.options.length > 0) {
+            context.command.inputOptions(input.options);
+        }
+        let duration = await this.getDuration(path);
+        if (this.subClip) {
+            const [start, end] = this.subClip;
+            duration = Math.max(end - start, 0);
+        }
+        let currentAudioOutput = input.aliases.audio;
+        if (duration > 0 && !this.loop) {
+            const trimOutput = `[trimAudio${context.inputIndex}]`;
+            context.filters.push({
+                filter: "atrim",
+                options: { end: duration },
+                inputs: currentAudioOutput,
+                outputs: trimOutput,
+            });
+            currentAudioOutput = trimOutput;
+        }
+        if (this.fadeIn && this.fadeIn > 0) {
+            const fadeInOutput = `[fadeInAudio${context.inputIndex}]`;
+            context.filters.push({
+                filter: "afade",
+                options: { t: "in", st: 0, d: this.fadeIn },
+                inputs: currentAudioOutput,
+                outputs: fadeInOutput
+            });
+            currentAudioOutput = fadeInOutput;
+        }
+        if (this.fadeOut && this.fadeOut > 0) {
+            const fadeOutOutput = `[fadeOutAudio${context.inputIndex}]`;
+            if (this.loop) {
+                context.filters.push({
+                    filter: "afade",
+                    options: {
+                        t: "out",
+                        d: this.fadeOut
+                    },
+                    inputs: currentAudioOutput,
+                    outputs: fadeOutOutput
+                });
+            }
+            else {
+                const start = Math.max((duration || 0) - this.fadeOut, 0);
+                context.filters.push({
+                    filter: "afade",
+                    options: {
+                        t: "out",
+                        st: start,
+                        d: this.fadeOut
+                    },
+                    inputs: currentAudioOutput,
+                    outputs: fadeOutOutput
+                });
+            }
+            currentAudioOutput = fadeOutOutput;
+        }
+        if (this.volume !== undefined) {
+            const volumeOutput = `[volAudio${context.inputIndex}]`;
+            context.filters.push({
+                filter: "volume",
+                options: `${this.volume}`,
+                inputs: currentAudioOutput,
+                outputs: volumeOutput
+            });
+            currentAudioOutput = volumeOutput;
+        }
+        context.labels.mixAudio.push(currentAudioOutput);
+        context.inputIndex++;
+    }
+}
+exports.AudioClip = AudioClip;

package/dist/clips/clip.d.ts

@@ -0,0 +1,16 @@
+import { FFmpegInput } from "../ffmpeg-input";
+import { RenderContext } from "../render-context";
+export type WhenOptions<Data> = {
+    data: Data;
+    index: number;
+};
+export type WhenFunction<RenderData> = (options: WhenOptions<RenderData>) => boolean;
+export declare abstract class Clip<RenderData> {
+    protected readonly when?: WhenFunction<RenderData> | undefined;
+    constructor(when?: WhenFunction<RenderData> | undefined);
+    readonly videoFilters: string[];
+    readonly audioFilters: string[];
+    shouldRender(data: RenderData, index?: number): boolean;
+    protected getInput(path: string, inputIndex: number, fps?: number): FFmpegInput;
+    abstract build(data: RenderData, context: RenderContext): void | Promise<void>;
+}

package/dist/clips/clip.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clip = void 0;
+class Clip {
+    constructor(when) {
+        this.when = when;
+        this.videoFilters = [];
+        this.audioFilters = [];
+    }
+    shouldRender(data, index = 0) {
+        return this.when ? this.when({ data, index }) : true;
+    }
+    getInput(path, inputIndex, fps) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.Clip = Clip;

package/dist/clips/composition-clip.d.ts

@@ -0,0 +1,10 @@
+import { RenderContext } from "../render-context";
+import { Clip } from "./clip";
+export type CompositionClipOptions<RenderData> = {
+    clips: Clip<RenderData>[];
+};
+export declare class CompositionClip<RenderData> extends Clip<RenderData> {
+    readonly clips: Clip<RenderData>[];
+    constructor({ clips }: CompositionClipOptions<RenderData>);
+    build(data: RenderData, context: RenderContext): Promise<void>;
+}

package/dist/clips/composition-clip.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositionClip = void 0;
+const clip_1 = require("./clip");
+class CompositionClip extends clip_1.Clip {
+    constructor({ clips }) {
+        super();
+        if (clips.length === 0) {
+            throw new Error("CompositionClip: at least one clip is required");
+        }
+        this.clips = clips;
+    }
+    async build(data, context) {
+        const startVideoIndex = context.labels.video.length;
+        const startAudioIndex = context.labels.structuralAudio.length;
+        const startMixAudioIndex = context.labels.mixAudio.length;
+        for (const clip of this.clips) {
+            await clip.build(data, context);
+        }
+        const videoLabels = context.labels.video.slice(startVideoIndex);
+        const audioLabels = context.labels.structuralAudio.slice(startAudioIndex);
+        const mixAudioLabels = context.labels.mixAudio.slice(startMixAudioIndex);
+        if (videoLabels.length !== audioLabels.length) {
+            throw new Error(`CompositionClip: video/audio mismatch (${videoLabels.length} videos, ${audioLabels.length} audios)`);
+        }
+        const outV = `[v${context.labels.video.length}]`;
+        const outBaseA = `[baseA${context.labels.structuralAudio.length}]`;
+        const outA = `[a${context.labels.structuralAudio.length}]`;
+        context.filters.push({
+            filter: "concat",
+            options: {
+                n: videoLabels.length,
+                v: 1,
+                a: 1
+            },
+            inputs: videoLabels.map((v, i) => `${v}${audioLabels[i]}`).join(""),
+            outputs: outV + outBaseA
+        });
+        if (mixAudioLabels.length > 0) {
+            const mixLabel = `[mix${context.labels.structuralAudio.length}]`;
+            context.filters.push({
+                filter: "amix",
+                options: {
+                    inputs: mixAudioLabels.length
+                },
+                inputs: mixAudioLabels.join(""),
+                outputs: mixLabel
+            });
+            context.filters.push({
+                filter: "amix",
+                options: {
+                    inputs: 2,
+                    duration: "first"
+                },
+                inputs: `${outBaseA}${mixLabel}`,
+                outputs: outA
+            });
+        }
+        else {
+            context.filters.push({
+                filter: "anull",
+                inputs: outBaseA,
+                outputs: outA
+            });
+        }
+        context.labels.video.splice(startVideoIndex);
+        context.labels.structuralAudio.splice(startAudioIndex);
+        context.labels.mixAudio.splice(startMixAudioIndex);
+        context.labels.video.push(outV);
+        context.labels.structuralAudio.push(outA);
+    }
+}
+exports.CompositionClip = CompositionClip;

package/dist/clips/concatenation-clip.d.ts

@@ -0,0 +1,10 @@
+import { RenderContext } from "../render-context";
+import { Clip } from "./clip";
+export type ConcatenationClipOptions<RenderData> = {
+    clips: Clip<RenderData>[];
+};
+export declare class ConcatenationClip<RenderData> extends Clip<RenderData> {
+    readonly clips: Clip<RenderData>[];
+    constructor({ clips }: ConcatenationClipOptions<RenderData>);
+    build(data: RenderData, context: RenderContext): Promise<void>;
+}

package/dist/clips/concatenation-clip.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConcatenationClip = void 0;
+const clip_1 = require("./clip");
+class ConcatenationClip extends clip_1.Clip {
+    constructor({ clips }) {
+        super();
+        if (clips.length < 1) {
+            throw new Error("ConcatenationClip: at least one clip is required");
+        }
+        this.clips = clips;
+    }
+    async build(data, context) {
+        const startVideoIndex = context.labels.video.length;
+        const startAudioIndex = context.labels.structuralAudio.length;
+        for (const clip of this.clips) {
+            await clip.build(data, context);
+        }
+        const videoLabels = context.labels.video.slice(startVideoIndex);
+        const audioLabels = context.labels.structuralAudio.slice(startAudioIndex);
+        if (videoLabels.length !== audioLabels.length) {
+            throw new Error(`ConcatenationClip: video/audio mismatch (${videoLabels.length} videos, ${audioLabels.length} audios)`);
+        }
+        const outV = `[v${context.labels.video.length}]`;
+        const outA = `[a${context.labels.structuralAudio.length}]`;
+        context.filters.push({
+            filter: "concat",
+            options: {
+                n: videoLabels.length,
+                v: 1,
+                a: 1
+            },
+            inputs: videoLabels.map((v, i) => `${v}${audioLabels[i]}`).join(""),
+            outputs: outV + outA
+        });
+        context.labels.video.splice(startVideoIndex);
+        context.labels.structuralAudio.splice(startAudioIndex);
+        context.labels.video.push(outV);
+        context.labels.structuralAudio.push(outA);
+    }
+}
+exports.ConcatenationClip = ConcatenationClip;

package/dist/clips/image-clip.d.ts

@@ -0,0 +1,23 @@
+import { RenderContext } from "../render-context";
+import { FFmpegInput } from "../ffmpeg-input";
+import { Clip } from "./clip";
+import { Path } from "../utils/resolve-path";
+export type ImageClipOptions<RenderData> = {
+    path: Path<RenderData>;
+    width?: number;
+    height?: number;
+    duration: number;
+    fadeIn?: number;
+    fadeOut?: number;
+};
+export declare class ImageClip<RenderData> extends Clip<RenderData> {
+    readonly duration: number;
+    readonly path: Path<RenderData>;
+    readonly fadeIn?: number;
+    readonly fadeOut?: number;
+    readonly width?: number;
+    readonly height?: number;
+    constructor({ duration, path, width, height, fadeIn, fadeOut }: ImageClipOptions<RenderData>);
+    protected getInput(path: string, inputIndex: number, fps: number): FFmpegInput;
+    build(data: RenderData, context: RenderContext): void;
+}

package/dist/clips/image-clip.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageClip = void 0;
+const clip_1 = require("./clip");
+const resolve_path_1 = require("../utils/resolve-path");
+class ImageClip extends clip_1.Clip {
+    constructor({ duration, path, width, height, fadeIn, fadeOut }) {
+        super();
+        this.duration = duration;
+        this.path = path;
+        this.fadeIn = fadeIn;
+        this.fadeOut = fadeOut;
+        this.width = width;
+        this.height = height;
+    }
+    getInput(path, inputIndex, fps) {
+        return {
+            path: path,
+            index: Number(inputIndex),
+            aliases: {
+                video: `[${inputIndex}:v]`,
+                audio: `[a${inputIndex}]`
+            },
+            type: "image",
+            options: [
+                "-loop 1",
+                `-t ${this.duration}`,
+                `-framerate ${fps}`
+            ]
+        };
+    }
+    build(data, context) {
+        var _a, _b;
+        const path = (0, resolve_path_1.resolvePath)({ path: this.path, data: data, index: context.clipIndex });
+        const input = this.getInput(path, context.inputIndex, context.fps);
+        let currentVideoOutput = input.aliases.video;
+        const currentAudioOutput = input.aliases.audio;
+        context.command
+            .input(input.path)
+            .inputOptions(input.options);
+        const anullSrcLabel = `[anull${context.inputIndex}]`;
+        context.filters.push({
+            filter: "anullsrc",
+            options: { sample_rate: 44100, channel_layout: "stereo" },
+            outputs: anullSrcLabel,
+        });
+        context.filters.push({
+            filter: "atrim",
+            options: { end: this.duration },
+            inputs: anullSrcLabel,
+            outputs: currentAudioOutput,
+        });
+        if (this.width !== undefined || this.height !== undefined) {
+            const scaleOutput = `scale${context.inputIndex}`;
+            context.filters.push({
+                filter: "scale",
+                options: { w: (_a = this.width) !== null && _a !== void 0 ? _a : -1, h: (_b = this.height) !== null && _b !== void 0 ? _b : -1 },
+                inputs: currentVideoOutput,
+                outputs: scaleOutput,
+            });
+            currentVideoOutput = scaleOutput;
+        }
+        if (this.fadeIn && this.fadeIn > 0) {
+            const fadeInOutput = `fadeIn${context.inputIndex}`;
+            context.filters.push({
+                filter: "fade",
+                options: { t: "in", st: 0, d: this.fadeIn },
+                inputs: currentVideoOutput,
+                outputs: fadeInOutput
+            });
+            currentVideoOutput = fadeInOutput;
+        }
+        if (this.fadeOut && this.fadeOut > 0) {
+            const start = Math.max(this.duration - this.fadeOut, 0);
+            const fadeOutOutput = `[v${context.inputIndex}]`;
+            context.filters.push({
+                filter: "fade",
+                options: { t: "out", st: start, d: this.fadeOut },
+                inputs: currentVideoOutput,
+                outputs: fadeOutOutput
+            });
+            currentVideoOutput = fadeOutOutput;
+        }
+        if (!this.fadeOut || this.fadeOut <= 0) {
+            context.filters.push({
+                filter: "null",
+                inputs: currentVideoOutput,
+                outputs: `[v${context.inputIndex}]`
+            });
+        }
+        context.labels.video.push(`[v${context.inputIndex}]`);
+        context.labels.structuralAudio.push(currentAudioOutput);
+        context.inputIndex++;
+    }
+}
+exports.ImageClip = ImageClip;

package/dist/clips/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./clip";
+export * from "./image-clip";
+export * from "./video-clip";
+export * from "./audio-clip";
+export * from "./composition-clip";
+export * from "./repeat-clip";
+export * from "./concatenation-clip";

package/dist/clips/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./clip"), exports);
+__exportStar(require("./image-clip"), exports);
+__exportStar(require("./video-clip"), exports);
+__exportStar(require("./audio-clip"), exports);
+__exportStar(require("./composition-clip"), exports);
+__exportStar(require("./repeat-clip"), exports);
+__exportStar(require("./concatenation-clip"), exports);

package/dist/clips/repeat-clip.d.ts

@@ -0,0 +1,23 @@
+import { RenderContext } from "../render-context";
+import { Clip } from "./clip";
+export type EachOptions<Data> = {
+    data: Data;
+    index: number;
+};
+export type ClipFunctionOptions = {
+    index: number;
+    length: number;
+};
+export type ClipFunction<RenderData, Item> = (item: Item, options: ClipFunctionOptions) => Clip<RenderData>;
+export type RepeatClipOptions<RenderData, Item> = {
+    each: EachFunction<RenderData, Item>;
+    clip: ClipFunction<RenderData, Item>;
+};
+export type EachFunction<Data, Item> = (options: EachOptions<Data>) => Item[];
+export declare class RepeatClip<RenderData, Item> extends Clip<RenderData> {
+    readonly each: EachFunction<RenderData, Item>;
+    readonly clip: ClipFunction<RenderData, Item>;
+    constructor({ each, clip, }: RepeatClipOptions<RenderData, Item>);
+    build(data: RenderData, context: RenderContext): Promise<void>;
+    private runBuildWithProgress;
+}

package/dist/clips/repeat-clip.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepeatClip = void 0;
+const cli_progress_1 = __importDefault(require("cli-progress"));
+const clip_1 = require("./clip");
+class RepeatClip extends clip_1.Clip {
+    constructor({ each, clip, }) {
+        super();
+        this.each = each;
+        this.clip = clip;
+    }
+    async build(data, context) {
+        const items = this.each({ data: data, index: 0 });
+        await this.runBuildWithProgress(items, data, context);
+    }
+    async runBuildWithProgress(items, data, context) {
+        const buildBar = new cli_progress_1.default.SingleBar({ format: "Repeat Clip Build  |{bar}| {value}/{total} clips", hideCursor: true }, cli_progress_1.default.Presets.shades_classic);
+        buildBar.start(items.length, 0);
+        const length = items.length;
+        for (let i = 0; i < length; i++) {
+            const clip = this.clip(items[i], { index: i, length: length });
+            await clip.build(data, context);
+            buildBar.increment();
+        }
+        buildBar.stop();
+    }
+}
+exports.RepeatClip = RepeatClip;

package/dist/clips/video-clip.d.ts

@@ -0,0 +1,18 @@
+import { Path } from "../utils/resolve-path";
+import { RenderContext } from "../render-context";
+import { FFmpegInput } from "../ffmpeg-input";
+import { Clip } from "./clip";
+export type VideoClipOptions<RenderData> = {
+    path: Path<RenderData>;
+    fadeIn?: number;
+    fadeOut?: number;
+};
+export declare class VideoClip<RenderData> extends Clip<RenderData> {
+    readonly path: Path<RenderData>;
+    readonly fadeIn?: number;
+    readonly fadeOut?: number;
+    constructor({ path, fadeIn, fadeOut }: VideoClipOptions<RenderData>);
+    protected getInput(path: string, inputIndex: number): FFmpegInput;
+    getDuration(path: string): Promise<number>;
+    build(data: RenderData, context: RenderContext): Promise<void>;
+}

package/dist/clips/video-clip.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoClip = void 0;
+const fluent_ffmpeg_1 = require("fluent-ffmpeg");
+const resolve_path_1 = require("../utils/resolve-path");
+const clip_1 = require("./clip");
+class VideoClip extends clip_1.Clip {
+    constructor({ path, fadeIn, fadeOut }) {
+        super();
+        this.path = path;
+        this.fadeIn = fadeIn;
+        this.fadeOut = fadeOut;
+    }
+    getInput(path, inputIndex) {
+        return {
+            path: path,
+            aliases: {
+                video: `[${inputIndex}:v]`,
+                audio: `[${inputIndex}:a]`
+            },
+            type: "video",
+            index: inputIndex,
+        };
+    }
+    async getDuration(path) {
+        return await new Promise((resolve, reject) => {
+            (0, fluent_ffmpeg_1.ffprobe)(path, (error, data) => {
+                if (error) {
+                    reject(error);
+                }
+                resolve(data.format.duration || 0);
+            });
+        });
+    }
+    async build(data, context) {
+        const path = (0, resolve_path_1.resolvePath)({ path: this.path, data: data, index: context.clipIndex });
+        const input = this.getInput(path, context.inputIndex);
+        let currentVideoOutput = input.aliases.video;
+        let currentAudioOutput = input.aliases.audio;
+        const duration = await this.getDuration(path);
+        context.command.input(path);
+        if (this.fadeIn !== undefined && this.fadeIn > 0) {
+            const fadeInOutput = `[fadeIn${context.inputIndex}]`;
+            const fadeInAudioOutput = `[fadeInAudio${context.inputIndex}]`;
+            context.filters.push({
+                filter: "fade",
+                options: { t: "in", st: 0, d: this.fadeIn },
+                inputs: currentVideoOutput,
+                outputs: fadeInOutput
+            });
+            context.filters.push({
+                filter: "afade",
+                options: { t: "in", st: 0, d: this.fadeIn },
+                inputs: currentAudioOutput,
+                outputs: fadeInAudioOutput
+            });
+            currentVideoOutput = fadeInOutput;
+            currentAudioOutput = fadeInAudioOutput;
+        }
+        if (this.fadeOut !== undefined && this.fadeOut > 0) {
+            const start = Math.max(duration - this.fadeOut, 0);
+            const fadeOutOutput = `[v${context.inputIndex}]`;
+            const fadeOutAudioOutput = `[fadeOutAudio${context.inputIndex}]`;
+            context.filters.push({
+                filter: "fade",
+                options: { t: "out", st: start, d: this.fadeOut },
+                inputs: currentVideoOutput,
+                outputs: fadeOutOutput
+            });
+            context.filters.push({
+                filter: "afade",
+                options: { t: "out", st: start, d: this.fadeOut },
+                inputs: currentAudioOutput,
+                outputs: fadeOutAudioOutput
+            });
+            currentVideoOutput = fadeOutOutput;
+            currentAudioOutput = fadeOutAudioOutput;
+        }
+        else {
+            context.filters.push({
+                filter: "null",
+                inputs: currentVideoOutput,
+                outputs: `[v${context.inputIndex}]`
+            });
+        }
+        context.labels.video.push(`[v${context.inputIndex}]`);
+        context.labels.structuralAudio.push(currentAudioOutput);
+        context.inputIndex++;
+    }
+}
+exports.VideoClip = VideoClip;

package/dist/ffmpeg-filter-spec.d.ts

@@ -0,0 +1,7 @@
+export type FFmpegFilterOptions = string | string[] | Record<string, any>;
+export type FFmpegFilterSpec = {
+    filter: string;
+    inputs?: string | string[];
+    outputs?: string | string[];
+    options?: FFmpegFilterOptions;
+};

package/dist/ffmpeg-filter-spec.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ffmpeg-input.d.ts

@@ -0,0 +1,10 @@
+export type FFmpegInput = {
+    path: string;
+    index: number;
+    aliases: {
+        video?: string;
+        audio: string;
+    };
+    type: "video" | "audio" | "image" | "rectangle";
+    options?: string[];
+};

package/dist/ffmpeg-input.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { AudioClip, AudioClipOptions, ImageClip, ImageClipOptions, VideoClipOptions, CompositionClip, CompositionClipOptions, RepeatClip, RepeatClipOptions, VideoClip, ConcatenationClip, ConcatenationClipOptions } from "./clips";
+import { Template, TemplateOptions } from "./template";
+export * from "./clips";
+export * from "./template";
+declare const movie: {
+    template<RenderData>(options: TemplateOptions<RenderData>): Template<RenderData>;
+    audio<RenderData>(options: AudioClipOptions<RenderData>): AudioClip<RenderData>;
+    image<RenderData>(options: ImageClipOptions<RenderData>): ImageClip<RenderData>;
+    video<RenderData>(options: VideoClipOptions<RenderData>): VideoClip<RenderData>;
+    composition<RenderData>(options: CompositionClipOptions<RenderData>): CompositionClip<RenderData>;
+    repeat<RenderData, Item>(options: RepeatClipOptions<RenderData, Item>): RepeatClip<RenderData, Item>;
+    concatenation<RenderData>(options: ConcatenationClipOptions<RenderData>): ConcatenationClip<RenderData>;
+};
+export default movie;

package/dist/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const clips_1 = require("./clips");
+const template_1 = require("./template");
+__exportStar(require("./clips"), exports);
+__exportStar(require("./template"), exports);
+const movie = {
+    template(options) {
+        return new template_1.Template(options);
+    },
+    audio(options) {
+        return new clips_1.AudioClip(options);
+    },
+    image(options) {
+        return new clips_1.ImageClip(options);
+    },
+    video(options) {
+        return new clips_1.VideoClip(options);
+    },
+    composition(options) {
+        return new clips_1.CompositionClip(options);
+    },
+    repeat(options) {
+        return new clips_1.RepeatClip(options);
+    },
+    concatenation(options) {
+        return new clips_1.ConcatenationClip(options);
+    }
+};
+exports.default = movie;

package/dist/render-context.d.ts

@@ -0,0 +1,14 @@
+import ffmpeg from "fluent-ffmpeg";
+import { FFmpegFilterSpec } from "./ffmpeg-filter-spec";
+export type RenderContext = {
+    command: ffmpeg.FfmpegCommand;
+    fps: number;
+    inputIndex: number;
+    clipIndex: number;
+    filters: FFmpegFilterSpec[];
+    labels: {
+        video: string[];
+        structuralAudio: string[];
+        mixAudio: string[];
+    };
+};

package/dist/render-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/render-result.d.ts

@@ -0,0 +1,9 @@
+import ffmpeg from "fluent-ffmpeg";
+export declare class RenderResult {
+    private readonly format;
+    private readonly command;
+    constructor(format: string, command: ffmpeg.FfmpegCommand);
+    toStream(): import("node:stream").Writable | import("node:stream").PassThrough;
+    toBuffer(): Promise<Buffer>;
+    toFile(filePath: string): Promise<void>;
+}

package/dist/render-result.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderResult = void 0;
+class RenderResult {
+    constructor(format, command) {
+        this.format = format;
+        this.command = command;
+    }
+    toStream() {
+        return this.command.format(this.format).pipe();
+    }
+    async toBuffer() {
+        const chunks = [];
+        const stream = this.toStream();
+        return new Promise((resolve, reject) => {
+            stream.on("data", chunk => chunks.push(chunk));
+            stream.on("end", () => resolve(Buffer.concat(chunks)));
+            stream.on("error", reject);
+        });
+    }
+    async toFile(filePath) {
+        return new Promise((resolve, reject) => {
+            this.command
+                .format(this.format)
+                .save(filePath)
+                .on("end", () => resolve())
+                .on("error", reject);
+        });
+    }
+}
+exports.RenderResult = RenderResult;

package/dist/template.d.ts

@@ -0,0 +1,17 @@
+import { Clip } from "./clips";
+import { RenderResult } from "./render-result";
+export type TemplateOptions<RenderData> = {
+    clips: Clip<RenderData>[];
+    config: {
+        format: string;
+        fps: number;
+        outputOptions?: string[];
+    };
+    debug?: boolean;
+};
+export declare class Template<RenderData> {
+    private readonly options;
+    constructor(options: TemplateOptions<RenderData>);
+    render(data: RenderData): Promise<RenderResult>;
+    private runBuildWithProgress;
+}

package/dist/template.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Template = void 0;
+const cli_progress_1 = __importDefault(require("cli-progress"));
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const render_result_1 = require("./render-result");
+class Template {
+    constructor(options) {
+        this.options = options;
+    }
+    async render(data) {
+        var _a;
+        const command = (0, fluent_ffmpeg_1.default)();
+        const context = {
+            command: command,
+            fps: this.options.config.fps,
+            inputIndex: 0,
+            clipIndex: 0,
+            filters: [],
+            labels: {
+                structuralAudio: [],
+                mixAudio: [],
+                video: []
+            },
+        };
+        // if (this.options.debug) {
+        //     command
+        //         .on("start", (commandLine) => {
+        //             console.log("Spawned Ffmpeg with command: " + commandLine)
+        //         })
+        //         .on("error", (err, stdout, stderr) => {
+        //             console.error("Error: " + err.message)
+        //             console.error("ffmpeg stderr: " + stderr)
+        //         })
+        // }
+        await this.runBuildWithProgress(data, context);
+        const concatFilter = context.labels.video
+            .map((v, i) => `${v}${context.labels.structuralAudio[i]}`)
+            .join("") +
+            `concat=n=${context.labels.video.length}:v=1:a=1[outv][basea]`;
+        const mixFilter = context.labels.mixAudio.length > 0
+            ? `${context.labels.mixAudio.join("")}amix=inputs=${context.labels.mixAudio.length}[mixa]`
+            : null;
+        const finalAudioFilter = mixFilter
+            ? `[basea][mixa]amix=inputs=2[outa]`
+            : `[basea]anull[outa]`;
+        const filterComplex = [
+            ...context.filters,
+            concatFilter,
+            mixFilter,
+            finalAudioFilter
+        ].filter((filter) => filter !== null);
+        // console.dir({
+        //     concatFilter,
+        //     finalAudioFilter,
+        //     mixFilter,
+        //     filterComplex,
+        //     context: {
+        //         ...context,
+        //         command: "<command>"
+        //     }
+        // }, {
+        //     depth: null
+        // })
+        command.complexFilter(filterComplex);
+        command.outputOptions([
+            "-map [outv]",
+            "-map [outa]",
+            "-c:v libx264",
+            "-c:a aac",
+            "-pix_fmt yuv420p",
+            ...((_a = this.options.config.outputOptions) !== null && _a !== void 0 ? _a : [])
+        ]);
+        return new render_result_1.RenderResult(this.options.config.format, command);
+    }
+    async runBuildWithProgress(data, context) {
+        const buildBar = new cli_progress_1.default.SingleBar({ format: "Template Build  |{bar}| {value}/{total} clips", hideCursor: true }, cli_progress_1.default.Presets.shades_classic);
+        buildBar.start(this.options.clips.length, 0);
+        for (let i = 0; i < this.options.clips.length; i++) {
+            const clip = this.options.clips[i];
+            await clip.build(data, context);
+            buildBar.increment();
+        }
+        buildBar.stop();
+    }
+}
+exports.Template = Template;

package/dist/utils/font-config.d.ts

@@ -0,0 +1,9 @@
+export type FontConfigOptions = {
+    color?: string;
+    filePath?: string;
+};
+export type PartialFontOptions = {
+    size: number;
+    color?: string;
+};
+export declare function fontConfig(options: FontConfigOptions): (partialOptions: PartialFontOptions) => TextClipFontOptions;

package/dist/utils/font-config.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fontConfig = fontConfig;
+function fontConfig(options) {
+    return (partialOptions) => {
+        var _a;
+        const color = (_a = options.color) !== null && _a !== void 0 ? _a : partialOptions.color;
+        const filePath = options.filePath;
+        const size = partialOptions.size;
+        if (!color) {
+            throw new Error("Font color is required");
+        }
+        return {
+            size: size,
+            color: color,
+            filePath: filePath,
+        };
+    };
+}

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./font-config";

package/dist/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./font-config"), exports);

package/dist/utils/resolve-path.d.ts

@@ -0,0 +1,12 @@
+export type ComputePathOptions<RenderData> = {
+    data: RenderData;
+    index: number;
+};
+export type ComputePath<RenderData> = (options: ComputePathOptions<RenderData>) => string;
+export type Path<RenderData> = ComputePath<RenderData> | string;
+export type ResolvePathOptions<RenderData> = {
+    path: Path<RenderData>;
+    data: RenderData;
+    index: number;
+};
+export declare function resolvePath<RenderData>({ path, ...params }: ResolvePathOptions<RenderData>): string;

package/dist/utils/resolve-path.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePath = resolvePath;
+function resolvePath({ path, ...params }) {
+    if (typeof path === "function") {
+        return path(params);
+    }
+    return path;
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@marcuth/movie.js",
+  "version": "0.0.1",
+  "description": "Video template builder",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/*",
+    "!/**/__tests__"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "moviepy",
+    "video",
+    "ffmpeg wrapper",
+    "video template builder"
+  ],
+  "author": "Marcuth",
+  "license": "MIT",
+  "type": "commonjs",
+  "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
+    "@types/fluent-ffmpeg": "^2.1.28",
+    "@types/node": "^25.0.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "cli-progress": "^3.12.0",
+    "fluent-ffmpeg": "^2.1.3"
+  }
+}