capcut-cli 0.1.0

package/dist/factory.js

@@ -0,0 +1,370 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { findMaterialGlobal } from "./draft.js";
+// --- UUID generation ---
+export function uuid() {
+    return randomUUID();
+}
+export function createCompanionMaterials(trackType) {
+    const speed = { id: uuid(), type: "speed", speed: 1, mode: 0, curve_speed: null };
+    const placeholder = {
+        id: uuid(), type: "placeholder_info",
+        error_path: "", error_text: "", meta_type: "none", res_path: "", res_text: "",
+    };
+    const scm = {
+        id: uuid(), type: "none",
+        audio_channel_mapping: 0, is_config_open: false,
+    };
+    const vocal = {
+        id: uuid(), type: "vocal_separation",
+        choice: 0, enter_from: "", final_algorithm: "",
+        production_path: "", removed_sounds: [], time_range: null,
+    };
+    const refs = {
+        ids: [speed.id, placeholder.id, scm.id, vocal.id],
+        materials: [
+            { type: "speeds", data: speed },
+            { type: "placeholder_infos", data: placeholder },
+            { type: "sound_channel_mappings", data: scm },
+            { type: "vocal_separations", data: vocal },
+        ],
+    };
+    if (trackType === "video") {
+        const canvas = {
+            id: uuid(), type: "canvas_color",
+            album_image: "", blur: 0, color: "", image: "",
+            image_id: "", image_name: "", source_platform: 0, team_id: "",
+        };
+        const matColor = {
+            id: uuid(), type: "material_color",
+            gradient_angle: 90, gradient_colors: [], gradient_percents: [],
+            height: 0, is_color_clip: false, is_gradient: false, solid_color: "", width: 0,
+        };
+        refs.ids.push(canvas.id, matColor.id);
+        refs.materials.push({ type: "canvases", data: canvas }, { type: "material_colors", data: matColor });
+    }
+    return refs;
+}
+export function registerCompanions(draft, companions) {
+    for (const { type, data } of companions.materials) {
+        if (!draft.materials[type])
+            draft.materials[type] = [];
+        draft.materials[type].push(data);
+    }
+}
+// --- Base segment ---
+function baseSegment(id, materialId, trackId, timerange, companionIds, renderIndex) {
+    return {
+        id,
+        material_id: materialId,
+        raw_segment_id: trackId,
+        target_timerange: { ...timerange },
+        source_timerange: { start: 0, duration: timerange.duration },
+        speed: 1,
+        volume: 1,
+        visible: true,
+        reverse: false,
+        clip: {
+            alpha: 1,
+            rotation: 0,
+            scale: { x: 1, y: 1 },
+            transform: { x: 0, y: 0 },
+            flip: { horizontal: false, vertical: false },
+        },
+        render_index: renderIndex,
+        track_render_index: 0,
+        track_attribute: 0,
+        extra_material_refs: companionIds,
+        common_keyframes: [],
+        keyframe_refs: [],
+    };
+}
+function hexToRgb(hex) {
+    const h = hex.replace("#", "");
+    return [
+        parseInt(h.slice(0, 2), 16) / 255,
+        parseInt(h.slice(2, 4), 16) / 255,
+        parseInt(h.slice(4, 6), 16) / 255,
+    ];
+}
+function buildTextContent(text, fontSize, color) {
+    const encoded = Buffer.from(text, "utf16le");
+    return JSON.stringify({
+        styles: [{
+                range: [0, encoded.length],
+                size: fontSize,
+                bold: false,
+                italic: false,
+                underline: false,
+                fill: {
+                    alpha: 1,
+                    content: {
+                        render_type: "solid",
+                        solid: { alpha: 1, color },
+                    },
+                },
+            }],
+        text,
+    });
+}
+export function addText(draft, filePath, opts) {
+    const segId = uuid();
+    const matId = uuid();
+    const fontSize = opts.fontSize ?? 15;
+    const color = opts.color ?? "#FFFFFF";
+    const rgb = hexToRgb(color);
+    const alignment = opts.alignment ?? 1;
+    const trackName = opts.trackName ?? "text";
+    // Find or create text track
+    let track = draft.tracks.find(t => t.type === "text" && (t.name === trackName || !opts.trackName));
+    if (!track) {
+        track = {
+            id: uuid(),
+            type: "text",
+            name: trackName,
+            attribute: 0,
+            segments: [],
+            is_default_name: false,
+            flag: 0,
+        };
+        draft.tracks.push(track);
+    }
+    // Create companion materials
+    const companions = createCompanionMaterials("text");
+    registerCompanions(draft, companions);
+    // Create text material
+    const textMaterial = {
+        id: matId,
+        type: "text",
+        content: buildTextContent(opts.text, fontSize, rgb),
+        alignment,
+        font_size: fontSize,
+        text_color: color,
+        typesetting: 0,
+        letter_spacing: 0,
+        line_spacing: 0.02,
+        line_feed: 1,
+        line_max_width: 0.82,
+        force_apply_line_max_width: false,
+        check_flag: 7,
+        fixed_width: -1,
+        fixed_height: -1,
+    };
+    draft.materials.texts.push(textMaterial);
+    // Create segment
+    const timerange = { start: opts.start, duration: opts.duration };
+    const seg = baseSegment(segId, matId, track.id, timerange, companions.ids, 15000);
+    if (opts.x !== undefined || opts.y !== undefined) {
+        seg.clip.transform = { x: opts.x ?? 0, y: opts.y ?? 0 };
+    }
+    track.segments.push(seg);
+    return { segmentId: segId, materialId: matId, trackId: track.id };
+}
+export function cutProject(draft, opts) {
+    const { start, end } = opts;
+    const duration = end - start;
+    let kept = 0;
+    let removed = 0;
+    // Collect material IDs to remove
+    const removedMaterialIds = new Set();
+    const removedExtraRefs = new Set();
+    for (const track of draft.tracks) {
+        const surviving = [];
+        for (const seg of track.segments) {
+            const segStart = seg.target_timerange.start;
+            const segEnd = segStart + seg.target_timerange.duration;
+            // Skip segments entirely outside the range
+            if (segEnd <= start || segStart >= end) {
+                removedMaterialIds.add(seg.material_id);
+                for (const ref of seg.extra_material_refs)
+                    removedExtraRefs.add(ref);
+                removed++;
+                continue;
+            }
+            // Clip segment to range
+            const clippedStart = Math.max(segStart, start);
+            const clippedEnd = Math.min(segEnd, end);
+            const trimFromStart = clippedStart - segStart;
+            const newDuration = clippedEnd - clippedStart;
+            // Adjust source_timerange for the trim
+            if (seg.source_timerange) {
+                seg.source_timerange.start += Math.round(trimFromStart * seg.speed);
+                seg.source_timerange.duration = Math.round(newDuration * seg.speed);
+            }
+            seg.target_timerange.start = clippedStart - start; // rebase to 0
+            seg.target_timerange.duration = newDuration;
+            surviving.push(seg);
+            kept++;
+        }
+        track.segments = surviving;
+    }
+    // Remove empty tracks
+    draft.tracks = draft.tracks.filter(t => t.segments.length > 0);
+    // Clean up orphaned materials (only if not referenced by surviving segments)
+    const survivingMatIds = new Set();
+    const survivingExtraRefs = new Set();
+    for (const track of draft.tracks) {
+        for (const seg of track.segments) {
+            survivingMatIds.add(seg.material_id);
+            for (const ref of seg.extra_material_refs)
+                survivingExtraRefs.add(ref);
+        }
+    }
+    for (const [key, arr] of Object.entries(draft.materials)) {
+        if (!Array.isArray(arr))
+            continue;
+        draft.materials[key] = arr.filter((m) => {
+            if (!m || typeof m.id !== "string")
+                return true;
+            const id = m.id;
+            // Keep if referenced by any surviving segment
+            if (survivingMatIds.has(id) || survivingExtraRefs.has(id))
+                return true;
+            // Remove if only referenced by removed segments
+            if (removedMaterialIds.has(id) || removedExtraRefs.has(id))
+                return false;
+            // Keep anything not directly tracked (safety)
+            return true;
+        });
+    }
+    // Update project duration
+    draft.duration = duration;
+    return { kept, removed };
+}
+export function saveTemplate(draft, segId, name, outPath) {
+    const shortId = segId.toLowerCase();
+    let foundSeg = null;
+    let foundTrack = null;
+    for (const track of draft.tracks) {
+        for (const seg of track.segments) {
+            if (seg.id === segId || seg.id.toLowerCase().startsWith(shortId)) {
+                foundSeg = seg;
+                foundTrack = track;
+                break;
+            }
+        }
+        if (foundSeg)
+            break;
+    }
+    if (!foundSeg || !foundTrack)
+        throw new Error(`Segment not found: ${segId}`);
+    // Resolve primary material
+    const mat = findMaterialGlobal(draft, foundSeg.material_id);
+    if (!mat)
+        throw new Error(`Material not found for segment: ${segId}`);
+    // Resolve extra material refs
+    const extras = [];
+    for (const refId of foundSeg.extra_material_refs) {
+        const extra = findMaterialGlobal(draft, refId);
+        if (extra)
+            extras.push({ type: extra.type, data: { ...extra.material } });
+    }
+    const template = {
+        name,
+        type: foundTrack.type,
+        segment: { ...foundSeg },
+        material: { type: mat.type, data: { ...mat.material } },
+        extra_materials: extras,
+    };
+    writeFileSync(outPath, JSON.stringify(template, null, 2), "utf-8");
+    return template;
+}
+export function applyTemplate(draft, templatePath, start, duration, overrides) {
+    const template = JSON.parse(readFileSync(templatePath, "utf-8"));
+    // Generate new IDs for everything
+    const idMap = new Map();
+    function remapId(oldId) {
+        if (!idMap.has(oldId))
+            idMap.set(oldId, uuid());
+        return idMap.get(oldId);
+    }
+    const newSegId = uuid();
+    const newMatId = uuid();
+    // Clone and remap the material
+    const newMat = deepCloneWithIdRemap(template.material.data, remapId);
+    newMat.id = newMatId;
+    // If text and override provided, update content
+    if (overrides?.text && template.type === "text" && typeof newMat.content === "string") {
+        try {
+            const parsed = JSON.parse(newMat.content);
+            if (parsed.text !== undefined) {
+                parsed.text = overrides.text;
+                if (parsed.styles && parsed.styles.length > 0) {
+                    const encoded = Buffer.from(overrides.text, "utf16le");
+                    parsed.styles[0].range = [0, encoded.length];
+                }
+                newMat.content = JSON.stringify(parsed);
+            }
+        }
+        catch { /* keep original content */ }
+    }
+    // Register primary material
+    if (!draft.materials[template.material.type])
+        draft.materials[template.material.type] = [];
+    draft.materials[template.material.type].push(newMat);
+    // Clone and register extra materials
+    const newExtraIds = [];
+    for (const extra of template.extra_materials) {
+        const newExtra = deepCloneWithIdRemap(extra.data, remapId);
+        newExtraIds.push(newExtra.id);
+        if (!draft.materials[extra.type])
+            draft.materials[extra.type] = [];
+        draft.materials[extra.type].push(newExtra);
+    }
+    // Also add companion materials if the template didn't have them
+    if (newExtraIds.length === 0) {
+        const companions = createCompanionMaterials(template.type);
+        registerCompanions(draft, companions);
+        newExtraIds.push(...companions.ids);
+    }
+    // Find or create track
+    let track = draft.tracks.find(t => t.type === template.type);
+    if (!track) {
+        track = {
+            id: uuid(),
+            type: template.type,
+            name: template.name || template.type,
+            attribute: 0,
+            segments: [],
+            is_default_name: true,
+            flag: 0,
+        };
+        draft.tracks.push(track);
+    }
+    // Clone segment with new IDs and timing
+    const newSeg = { ...template.segment };
+    newSeg.id = newSegId;
+    newSeg.material_id = newMatId;
+    newSeg.raw_segment_id = track.id;
+    newSeg.target_timerange = { start, duration };
+    if (template.segment.source_timerange) {
+        newSeg.source_timerange = { start: 0, duration };
+    }
+    newSeg.extra_material_refs = newExtraIds;
+    // Apply position/scale overrides
+    if (overrides && newSeg.clip && typeof newSeg.clip === "object") {
+        const clip = newSeg.clip;
+        if (overrides.x !== undefined || overrides.y !== undefined) {
+            clip.transform = {
+                x: overrides.x ?? clip.transform?.x ?? 0,
+                y: overrides.y ?? clip.transform?.y ?? 0,
+            };
+        }
+        if (overrides.scaleX !== undefined || overrides.scaleY !== undefined) {
+            clip.scale = {
+                x: overrides.scaleX ?? clip.scale?.x ?? 1,
+                y: overrides.scaleY ?? clip.scale?.y ?? 1,
+            };
+        }
+    }
+    track.segments.push(newSeg);
+    return { segmentId: newSegId, materialId: newMatId, trackId: track.id };
+}
+function deepCloneWithIdRemap(obj, remapId) {
+    const clone = JSON.parse(JSON.stringify(obj));
+    // Remap the id field
+    if (typeof clone.id === "string") {
+        clone.id = remapId(clone.id);
+    }
+    return clone;
+}