kt-forpro-tools 1.1.0 → 1.1.1

package/package.json

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

package/src/slides.ts

@@ -54,6 +54,7 @@ class KT_Slides {
     name: string = "Slides";
     slideMultiplier: number = 1;
     backgroundColor: [number, number, number] = [1, 1, 1];
+    backgroundPivotPrefix: string = "_BG_";
     private getNextColor = colorSelector();
 
     constructor(options: KT_SlidesOptions = {}) {
@@ -154,7 +155,7 @@ class KT_Slides {
                 this.width,
                 this.height,
                 1,
-                this.duration
+                this.duration,
             );
         }
 
@@ -206,6 +207,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 +216,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 = randomColorIndex;
+            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 = firstLayer.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 +345,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 +430,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 +442,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 +457,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 +472,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 +496,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 +530,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);
+        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);
+        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);
         }
@@ -451,6 +586,11 @@ class __KT_SlidesAPI {
         const slidesInstance = new KT_Slides(options);
         slidesInstance.cleanUp();
     };
+
+    static migrate = (options: KT_SlidesOptions) => {
+        const slidesInstance = new KT_Slides(options);
+        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();
+    });
+});