kt-forpro-tools 1.1.0 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "kt-forpro-tools",
-    "version": "1.1.0",
+    "version": "1.1.2",
     "description": "",
     "author": "Miguel de Mendoza",
     "main": "src/index.ts",

package/src/slides.ts

@@ -3,6 +3,8 @@ import { KT_Layers } from "kt-ae-tools-layers";
 import { KT_AeIs as is } from "kt-ae-is-checkers";
 import { IO } from "kt-io";
 
+const BACKGROUND_LABEL = 13;
+
 const colorSelector = () => {
     let lastColorIndex = -1;
     const numColors = 16;
@@ -10,6 +12,9 @@ const colorSelector = () => {
 
     // ✅ Pre-generar pool de colores disponibles
     for (let i = 0; i < numColors; i++) {
+        if (i === BACKGROUND_LABEL) {
+            continue;
+        }
         colorPool.push(i);
     }
 
@@ -33,6 +38,7 @@ export type KT_SlidesOptions = {
     comp?: CompItem;
     slideMultiplier?: number;
     slideDistance?: number;
+    lazyInit?: boolean;
 };
 
 class KT_Slides {
@@ -43,7 +49,7 @@ class KT_Slides {
     backgroundComp!: CompItem;
     compedSlidesFolder!: FolderItem;
     duration: number = 30;
-    masterComp: CompItem;
+    masterComp!: CompItem;
     slidesFootage: FootageItem[] = [];
     width: number = 1920;
     height: number = 1080;
@@ -54,6 +60,9 @@ class KT_Slides {
     name: string = "Slides";
     slideMultiplier: number = 1;
     backgroundColor: [number, number, number] = [1, 1, 1];
+    backgroundPivotPrefix: string = "_BG_";
+    private initialized: boolean = false;
+    private initialComp?: CompItem;
     private getNextColor = colorSelector();
 
     constructor(options: KT_SlidesOptions = {}) {
@@ -67,6 +76,7 @@ class KT_Slides {
             comp,
             slideMultiplier,
             slideDistance,
+            lazyInit = true,
         } = options;
         this.name = name || this.name;
         this.duration = duration || this.duration;
@@ -76,14 +86,27 @@ class KT_Slides {
         this.inDuration = inDuration || this.inDuration;
         this.slideMultiplier = slideMultiplier || this.slideMultiplier;
         this.slideDistance = slideDistance || this.slideDistance;
+
+        this.initialComp = comp;
+        if (lazyInit === false) {
+            this.ensureInitialized();
+        }
+    }
+
+    private ensureInitialized = () => {
+        if (this.initialized) {
+            return;
+        }
+
         this.initFolders();
         const compExists = KT_Project.find.comps({ name: this.name + " Master" });
         if (compExists && compExists.length > 0) {
             this.masterComp = compExists[0] as CompItem;
+            this.initialized = true;
             return;
         }
         this.masterComp =
-            comp ||
+            this.initialComp ||
             (KT_Project.add.comp({
                 name: this.name + " Master",
                 width: this.width,
@@ -91,7 +114,8 @@ class KT_Slides {
                 duration: this.duration,
                 parentFolder: this.rootFolder,
             }) as CompItem);
-    }
+        this.initialized = true;
+    };
 
     initFolders = (options: KT_SlidesOptions = {}): void => {
         const rootFolder = KT_Project.find.folders({ name: this.name + " Project" });
@@ -154,7 +178,7 @@ class KT_Slides {
                 this.width,
                 this.height,
                 1,
-                this.duration
+                this.duration,
             );
         }
 
@@ -169,10 +193,6 @@ class KT_Slides {
     };
 
     import = (slideMultiplier?: number) => {
-        if (!this.masterComp) {
-            $.writeln("Master comp not found");
-            return;
-        }
         this.slideMultiplier = slideMultiplier || this.slideMultiplier;
         const path = IO.fs.openFolderDialog("Select Slides Folder");
         if (!path) {
@@ -180,6 +200,13 @@ class KT_Slides {
             return;
         }
 
+        this.ensureInitialized();
+
+        if (!this.masterComp) {
+            $.writeln("Master comp not found");
+            return;
+        }
+
         let footage = KT_Project.import.images({
             path: path.fsName,
             footageFolder: this.footageFolder,
@@ -206,6 +233,8 @@ class KT_Slides {
 
         footage.forEach((item, index) => {
             const randomColorIndex = this.getNextColor();
+            const groupStartTime = (index * this.slideMultiplier + 0) * this.inDuration * 2;
+            let lowerGroupLayer: Layer | null = null;
             for (let i = 0; i < this.slideMultiplier; i++) {
                 const subComp = this.precompSlide(item as FootageItem, i);
 
@@ -213,31 +242,128 @@ class KT_Slides {
                     subComp as AVItem,
                     this.inDuration * 2,
                     this.masterComp,
-                    (index * this.slideMultiplier + i) * this.inDuration * 2
+                    (index * this.slideMultiplier + i) * this.inDuration * 2,
                 );
                 this.enableTimeRemap(layer as AVLayer);
                 layer.outPoint = this.masterComp.duration;
                 layer.label = randomColorIndex;
                 if (i === 0) {
-                    const backgroundlayer = layer.source.layers.add(this.backgroundComp);
-                    backgroundlayer.selected = false;
-                    backgroundlayer.moveToEnd();
-                    layer.source.layers[1].selected = true;
+                    lowerGroupLayer = layer;
                 }
                 this.slides.push(layer);
             }
-        });
 
+            const bgPivot = this.masterComp.layers.add(this.backgroundComp);
+
+            this.fitLayerToComp(bgPivot, this.masterComp);
+            bgPivot.name = this.backgroundPivotPrefix + item.name.split("-")[0];
+            bgPivot.startTime = groupStartTime;
+            bgPivot.outPoint = this.masterComp.duration;
+            bgPivot.label = BACKGROUND_LABEL;
+            this.enableTimeRemap(bgPivot as AVLayer);
+            if (lowerGroupLayer) {
+                bgPivot.moveAfter(lowerGroupLayer);
+            }
+        });
+        this.batchSplitSlides();
         return this;
     };
     batchSplitSlides = () => {
-        const slides = KT_Layers.find.layers({ comps: this.masterComp });
-        const totalSlides = slides.length;
-        let batchSize = this.slideMultiplier;
-        for (let i = 0; i < totalSlides; i) {
-            const batchLayers = slides.slice(i, i + batchSize);
-            //reduce batchlayers if next layer inPoint is more than inDuration * 3 away
-            for (let j = 0; j < batchLayers.length - 2; j++) {
+        const layers = KT_Layers.find.layers({ comps: this.masterComp });
+        const backgroundPivots = this.getBackgroundPivots(layers);
+
+        if (backgroundPivots.length === 0) {
+            const legacyBatches = this.getLegacySlideBatches(layers);
+            legacyBatches.forEach((batchLayers) => {
+                this.splitSlides(batchLayers);
+            });
+            return;
+        }
+
+        backgroundPivots.forEach((pivotLayer, index, collection) => {
+            const nextPivot = collection[index + 1];
+            const nextPivotStart = nextPivot ? nextPivot.startTime : Number.MAX_VALUE;
+
+            const groupSlides = layers.filter((layer) => {
+                if (this.isBackgroundPivot(layer)) {
+                    return false;
+                }
+                return layer.startTime >= pivotLayer.startTime && layer.startTime < nextPivotStart;
+            });
+
+            if (groupSlides.length === 0) {
+                return;
+            }
+
+            this.splitSlides(groupSlides);
+        });
+    };
+
+    migrateBackgroundPivots = () => {
+        const layers = KT_Layers.find.layers({ comps: this.masterComp });
+        const backgroundPivots = this.getBackgroundPivots(layers);
+        if (backgroundPivots.length > 0) {
+            return 0;
+        }
+
+        const batches = this.getLegacySlideBatches(layers);
+        let addedPivots = 0;
+
+        batches.forEach((batchLayers) => {
+            if (!batchLayers || batchLayers.length === 0) {
+                return;
+            }
+
+            let firstLayer = batchLayers[0];
+            let lowerGroupLayer = batchLayers[0];
+            batchLayers.forEach((layer) => {
+                if (layer.startTime < firstLayer.startTime) {
+                    firstLayer = layer;
+                }
+                if (layer.index > lowerGroupLayer.index) {
+                    lowerGroupLayer = layer;
+                }
+            });
+
+            const bgPivot = this.masterComp.layers.add(this.backgroundComp);
+            this.fitLayerToComp(bgPivot, this.masterComp);
+            bgPivot.name = this.backgroundPivotPrefix + firstLayer.name.split("-")[0];
+            bgPivot.startTime = firstLayer.startTime;
+            bgPivot.outPoint = this.masterComp.duration;
+            bgPivot.label = BACKGROUND_LABEL;
+            this.enableTimeRemap(bgPivot as AVLayer);
+            bgPivot.moveAfter(lowerGroupLayer);
+            addedPivots += 1;
+        });
+
+        return addedPivots;
+    };
+
+    private getBackgroundPivots = (layers: Layer[]) => {
+        const pivots = layers.filter((layer) => this.isBackgroundPivot(layer));
+        pivots.sort((a, b) => a.startTime - b.startTime);
+        return pivots;
+    };
+
+    private isBackgroundPivot = (layer: Layer) => {
+        const avLayer = layer as AVLayer;
+        if (avLayer.source && avLayer.source === this.backgroundComp) {
+            return true;
+        }
+        return layer.name.indexOf(this.backgroundPivotPrefix) === 0;
+    };
+
+    private getLegacySlideBatches = (layers: Layer[]) => {
+        const batches: Layer[][] = [];
+        const batchSize = this.slideMultiplier > 0 ? this.slideMultiplier : 1;
+
+        for (let i = 0; i < layers.length; ) {
+            const batchLayers = layers.slice(i, i + batchSize);
+            if (batchLayers.length === 0) {
+                break;
+            }
+
+            for (let j = 0; j < batchLayers.length - 1; j++) {
                 const layer = batchLayers[j] as AVLayer;
                 const nextLayer = batchLayers[j + 1] as AVLayer;
                 if (layer.inPoint - nextLayer.inPoint > this.inDuration * 3) {
@@ -245,15 +371,23 @@ class KT_Slides {
                     break;
                 }
             }
+
+            batches.push(batchLayers);
             i += batchLayers.length;
-            this.splitSlides(batchLayers);
         }
+
+        return batches;
     };
+
     splitSlides = (layers?: Layer[]) => {
         if (!Array.isArray(layers) || layers.length <= 1) {
             layers = this.masterComp.selectedLayers;
         }
 
+        if (layers) {
+            layers = layers.filter((layer) => !this.isBackgroundPivot(layer));
+        }
+
         if (!layers || layers.length === 0) {
             $.writeln("No layers selected for precomp");
             return;
@@ -322,6 +456,7 @@ class KT_Slides {
             pivotIndex += 1;
             // Ajustar la duración de la precomp
             const solid = precomp.layers.add(this.backgroundComp);
+            this.fitLayerToComp(solid, precomp);
             solid.moveToEnd();
             precomp.duration = this.duration;
         });
@@ -333,6 +468,9 @@ class KT_Slides {
         const compsToKeep: string[] = [];
         for (let i = 1; i <= layers.length; i++) {
             const layer = layers[i];
+            if (this.isBackgroundPivot(layer)) {
+                continue;
+            }
             const nameSplit = layer.name.split("-");
             const slideIndex = parseInt(nameSplit[nameSplit.length - 1]) - 1;
             const slideName = this.getSlideName(layer, slideIndex, "_Slide_");
@@ -345,7 +483,10 @@ class KT_Slides {
                 const keep = compsToKeep.indexOf(item.name) >= 0;
                 if (!keep) {
                     $.writeln(
-                        "Removing comp: " + item.name + "indexof: " + compsToKeep.indexOf(item.name)
+                        "Removing comp: " +
+                            item.name +
+                            "indexof: " +
+                            compsToKeep.indexOf(item.name),
                     );
                     item.remove();
                 }
@@ -357,11 +498,12 @@ class KT_Slides {
         source: AVItem,
         duration: number,
         comp: CompItem = app.project.activeItem as CompItem,
-        startTime?: number
+        startTime?: number,
     ) {
         const layer = comp.layers.add(source);
         layer.startTime = 0;
         layer.outPoint = duration;
+        this.fitLayerToComp(layer, comp);
         this.slideUp(layer);
         this.disolveIn(layer);
         layer.startTime = startTime || 0;
@@ -380,7 +522,7 @@ class KT_Slides {
     private getSlideName = (
         item: _ItemClasses | Layer,
         index: number,
-        infix: string = "-"
+        infix: string = "-",
     ): string => {
         return item.name.split("-")[0] + infix + (index + 1);
     };
@@ -414,13 +556,32 @@ class KT_Slides {
         });
     };
 
+    private fitLayerToComp = (layer: Layer, comp: CompItem): Layer => {
+        const avLayer = layer as AVLayer;
+        if (!avLayer.source) return layer;
+        const src = avLayer.source as CompItem | FootageItem;
+        const sourceWidth = src.width;
+        const sourceHeight = src.height;
+        if (!sourceWidth || !sourceHeight) return layer;
+        const scalePercent = Math.min(comp.width / sourceWidth, comp.height / sourceHeight) * 100;
+        const currentScale = layer.scale.value as number[];
+        const newScale: number[] = [scalePercent, scalePercent];
+        if (currentScale.length > 2) newScale.push(currentScale[2]);
+        layer.scale.setValue(newScale as any);
+        const center: number[] = [comp.width / 2, comp.height / 2];
+        const currentPos = layer.position.value as number[];
+        if (currentPos.length > 2) center.push(currentPos[2]);
+        layer.position.setValue(center as any);
+        return layer;
+    };
+
     private enableTimeRemap = (layer: AVLayer) => {
         layer.timeRemapEnabled = true;
         const property = layer.property("ADBE Time Remapping") as Property;
         if (!is.layer || layer.canSetTimeRemapEnabled === false) return layer;
         if (property) {
             property.addKey(
-                property.keyTime(property.numKeys) - layer.containingComp.frameDuration
+                property.keyTime(property.numKeys) - layer.containingComp.frameDuration,
             );
             property.removeKey(property.numKeys);
         }
@@ -433,24 +594,44 @@ export { KT_Slides };
 class __KT_SlidesAPI {
     private slidesInstance: KT_Slides | null = null;
     static import = (options: KT_SlidesOptions = {}) => {
-        const slides = new KT_Slides(options);
+        const slides = new KT_Slides({
+            ...options,
+            lazyInit: true,
+        });
         slides.import(options.slideMultiplier);
         return slides;
     };
 
     static refreshAll = (options: KT_SlidesOptions) => {
-        const slidesInstance = new KT_Slides(options);
+        const slidesInstance = new KT_Slides({
+            ...options,
+            lazyInit: false,
+        });
         slidesInstance.batchSplitSlides();
     };
 
     static refreshSelected = (options: KT_SlidesOptions) => {
-        const slidesInstance = new KT_Slides(options);
+        const slidesInstance = new KT_Slides({
+            ...options,
+            lazyInit: false,
+        });
         slidesInstance.splitSlides();
     };
     static cleanUp = (options: KT_SlidesOptions) => {
-        const slidesInstance = new KT_Slides(options);
+        const slidesInstance = new KT_Slides({
+            ...options,
+            lazyInit: false,
+        });
         slidesInstance.cleanUp();
     };
+
+    static migrate = (options: KT_SlidesOptions) => {
+        const slidesInstance = new KT_Slides({
+            ...options,
+            lazyInit: false,
+        });
+        return slidesInstance.migrateBackgroundPivots();
+    };
 }
 
 export const KT_SlidesAPI = __KT_SlidesAPI;

package/src/tests/batchSplitSlides.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from "kt-testing-suite-core";
+import { KT_Slides } from "../index";
+
+describe("KT_Slides Tests", () => {
+    it("should batch split slides correctly", () => {
+        const duration = 30;
+        const slideMultiplier = 10;
+        const width = 3840;
+        const height = 2160;
+
+        const slides = new KT_Slides({
+            name: "Test Slides",
+            duration: duration,
+            width: width,
+            height: height,
+            comp: app.project.activeItem as CompItem,
+            slideMultiplier: slideMultiplier,
+        });
+
+        slides.batchSplitSlides();
+        slides.cleanUp();
+    });
+});

package/src/tests/index.test.ts

@@ -9,80 +9,84 @@ import {
     afterEach,
 } from "kt-testing-suite-core";
 import { KT_Slides, KT_ForproTools, KT_SlidesFreeze } from "../index";
-import "./freezer.test";
-describe("KtForproTools Tests", () => {
-    it("should import the slides module", () => {
-        const duration = 30;
-        const slideMultiplier = 16;
-        const width = 3840;
-        const height = 2160;
+// import "./freezer.test";
+import "./slides.test";
+// import "./batchSplitSlides.test";
+// import "./splitSlides.test";
 
-        // KT_ForproTools.Cleanup();
-        // KT_ForproTools.utils.cleanNamePrecomp();
-        // KT_ForproTools.utils.sendCleanupToMediaEncoder(["esp", "cat"]);
-        // KT_ForproTools.utils.sendLanguagesToMediaEncoder();
-        // KT_ForproTools.utils.sendCleanupToMediaEncoder();
-        // KT_ForproTools.utils.autoPrecompAndKeyOut();
-        // KT_ForproTools.utils.copyMarkersToComp(app.project.activeItem as CompItem);
-        // KT_ForproTools.utils.copyMasksFromMasterToLayer();
-        // const folder = Folder.selectDialog("Select a folder with language subfolders");
-        // $.writeln("Selected folder: " + folder?.fsName);
-        // KT_ForproTools.utils.precompAndKeyOut("cat");
-        // KT_ForproTools.utils.createCleanupStructure();
+// describe("KtForproTools Tests", () => {
+//     it("should import the slides module", () => {
+//         const duration = 30;
+//         const slideMultiplier = 16;
+//         const width = 3840;
+//         const height = 2160;
 
-        // const slides = new KT_Slides({
-        //     name: "Test Slides",
-        //     duration: duration,
-        //     width: width,
-        //     height: height,
-        //     comp: app.project.activeItem as CompItem,
-        //     slideMultiplier: slideMultiplier,
-        // });
+// KT_ForproTools.Cleanup();
+// KT_ForproTools.utils.cleanNamePrecomp();
+// KT_ForproTools.utils.sendCleanupToMediaEncoder(["esp", "cat"]);
+// KT_ForproTools.utils.sendLanguagesToMediaEncoder();
+// KT_ForproTools.utils.sendCleanupToMediaEncoder();
+// KT_ForproTools.utils.autoPrecompAndKeyOut();
+// KT_ForproTools.utils.copyMarkersToComp(app.project.activeItem as CompItem);
+// KT_ForproTools.utils.copyMasksFromMasterToLayer();
+// const folder = Folder.selectDialog("Select a folder with language subfolders");
+// $.writeln("Selected folder: " + folder?.fsName);
+// KT_ForproTools.utils.precompAndKeyOut("cat");
+// KT_ForproTools.utils.createCleanupStructure();
 
-        // slides.cleanUp();
-        // slides.import();
-        // slides.splitSlides();
-        // const startTime = new Date().getTime();
-        // slides.batchSplitSlides();
-        // // slides.splitSlides();
+// const slides = new KT_Slides({
+//     name: "Test Slides",
+//     duration: duration,
+//     width: width,
+//     height: height,
+//     comp: app.project.activeItem as CompItem,
+//     slideMultiplier: slideMultiplier,
+// });
 
-        // const endTime = new Date().getTime();
-        // const timeTaken = endTime - startTime;
-        // //display time taken in minutes and seconds format mm:ss
-        // $.writeln(
-        //     "Time taken: "
-        //         .concat(Math.floor(timeTaken / 60000).toFixed(0), ":")
-        //         .concat(((timeTaken % 60000) / 1000).toFixed(0), "s")
-        // );
+// slides.cleanUp();
+// slides.import();
+// slides.splitSlides();
+// const startTime = new Date().getTime();
+// slides.batchSplitSlides();
+// // slides.splitSlides();
 
-        // const comp = app.project.activeItem as CompItem;
-        // const layer = comp.layers[1];
-        // const masks = layer.mask;
-        // const mask1 = masks.property(1);
-        // const maskShape = mask1.property("Mask Path").value;
+// const endTime = new Date().getTime();
+// const timeTaken = endTime - startTime;
+// //display time taken in minutes and seconds format mm:ss
+// $.writeln(
+//     "Time taken: "
+//         .concat(Math.floor(timeTaken / 60000).toFixed(0), ":")
+//         .concat(((timeTaken % 60000) / 1000).toFixed(0), "s")
+// );
 
-        // const layer2 = comp.layers[2];
-        // const masks2 = layer2.Masks.addProperty("Mask");
+// const comp = app.project.activeItem as CompItem;
+// const layer = comp.layers[1];
+// const masks = layer.mask;
+// const mask1 = masks.property(1);
+// const maskShape = mask1.property("Mask Path").value;
 
-        // var newMask = masks2.property("maskShape");
-        // var theShape = newMask.value;
-        // var inspectProps = [];
-        // for (let i = 1; i <= mask1.numProperties; i++) {
-        //     inspectProps.push(mask1.property(i));
-        // }
+// const layer2 = comp.layers[2];
+// const masks2 = layer2.Masks.addProperty("Mask");
 
-        // const newShape = new Shape();
-        // newShape.vertices = maskShape.vertices;
-        // newShape.inTangents = maskShape.inTangents;
-        // newShape.outTangents = maskShape.outTangents;
-        // newShape.isClosed = maskShape.isClosed;
-        // newMask.setValue(newShape);
-        // masks2.inverted = mask1.inverted;
-        // masks2.maskMode = mask1.maskMode;
-        // expect(maskShape).toBeGreaterThan(0);
+// var newMask = masks2.property("maskShape");
+// var theShape = newMask.value;
+// var inspectProps = [];
+// for (let i = 1; i <= mask1.numProperties; i++) {
+//     inspectProps.push(mask1.property(i));
+// }
 
-        // expect(maskShape).toBeGreaterThan(0);
-    });
-});
+// const newShape = new Shape();
+// newShape.vertices = maskShape.vertices;
+// newShape.inTangents = maskShape.inTangents;
+// newShape.outTangents = maskShape.outTangents;
+// newShape.isClosed = maskShape.isClosed;
+// newMask.setValue(newShape);
+// masks2.inverted = mask1.inverted;
+// masks2.maskMode = mask1.maskMode;
+// expect(maskShape).toBeGreaterThan(0);
+
+// expect(maskShape).toBeGreaterThan(0);
+//     });
+// });
 
 runTests();

package/src/tests/slides.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "kt-testing-suite-core";
+import { KT_Slides } from "../index";
+
+describe("KT_Slides Tests", () => {
+    it("should configure slides module", () => {
+        const duration = 30;
+        const slideMultiplier = 10;
+        const width = 3840;
+        const height = 2160;
+
+        const slides = new KT_Slides({
+            name: "Test Slides",
+            duration: duration,
+            width: width,
+            height: height,
+            comp: app.project.activeItem as CompItem,
+            slideMultiplier: slideMultiplier,
+        });
+
+        // slides.cleanUp();
+        slides.import();
+        // slides.splitSlides();
+        // const startTime = new Date().getTime();
+        // slides.batchSplitSlides();
+
+        // const endTime = new Date().getTime();
+        // const timeTaken = endTime - startTime;
+        // $.writeln(
+        //     "Time taken: "
+        //         .concat(Math.floor(timeTaken / 60000).toFixed(0), ":")
+        //         .concat(((timeTaken % 60000) / 1000).toFixed(0), "s")
+        // );
+
+        expect(duration).toBe(30);
+        expect(slideMultiplier).toBe(16);
+        expect(width).toBe(3840);
+        expect(height).toBe(2160);
+        expect(!!KT_Slides).toBe(true);
+    });
+});

package/src/tests/splitSlides.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from "kt-testing-suite-core";
+import { KT_Slides } from "../index";
+
+describe("KT_Slides Tests", () => {
+    it("should split selectedslides correctly", () => {
+        const duration = 30;
+        const slideMultiplier = 10;
+        const width = 3840;
+        const height = 2160;
+
+        const slides = new KT_Slides({
+            name: "Test Slides",
+            duration: duration,
+            width: width,
+            height: height,
+            comp: app.project.activeItem as CompItem,
+            slideMultiplier: slideMultiplier,
+        });
+
+        slides.splitSlides();
+        // slides.cleanUp();
+    });
+});