kt-forpro-tools 1.0.0

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "kt-forpro-tools",
+  "version": "1.0.0",
+  "description": "",
+  "author": "Miguel de Mendoza",
+  "main": "src/index.ts",
+  "license": "MIT",
+  "scripts": {
+    "build": "kt-build",
+    "build-tests": "kt-build build-tests",
+    "debug-build-tests": "kt-build debug-build-tests"
+  },
+  "files": [
+    "src",
+    "tsconfig.json"
+  ],
+  "dependencies": {
+    "kt-ae-is-checkers": "^1.0.7",
+    "kt-ae-tools-layers": "^1.0.0",
+    "kt-ae-tools-project": "^1.0.5",
+    "kt-core": "*",
+    "kt-io": "^1.1.0"
+  },
+  "devDependencies": {
+    "kt-extendscript-builder": "*",
+    "kt-testing-suite-ae": "*",
+    "kt-testing-suite-core": "^1.7.7",
+    "prettier": "^3.6.2"
+  }
+}

package/src/KT_ForproTools.ts

@@ -0,0 +1,10 @@
+import { KT_Slides, type KT_SlidesOptions, KT_SlidesAPI } from "./slides";
+
+export class KT_ForproTools {
+    private name = "KtForproTools";
+    private version = "1.0.0";
+    Slides = KT_SlidesAPI;
+    constructor() {
+        $.writeln("KtForproTools constructor");
+    }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+import { KT_Core } from "kt-core";
+import { KT_ForproTools } from "./KT_ForproTools";
+import { KT_Slides } from "./slides";
+
+export { KT_ForproTools, KT_Slides };

package/src/slides.ts

@@ -0,0 +1,377 @@
+import { KT_Project } from "kt-ae-tools-project";
+import { KT_Layers } from "kt-ae-tools-layers";
+import { KT_AeIs as is } from "kt-ae-is-checkers";
+import { IO } from "kt-io";
+
+const colorSelector = () => {
+    let lastColorIndex = -1;
+    const numColors = 16;
+    const colorPool: number[] = [];
+
+    // ✅ Pre-generar pool de colores disponibles
+    for (let i = 0; i < numColors; i++) {
+        colorPool.push(i);
+    }
+
+    return () => {
+        // ✅ Filtrar colores que no sean el último usado
+        const availableColors = colorPool.filter((color) => color !== lastColorIndex);
+
+        // ✅ Seleccionar uno aleatorio del pool disponible
+        const randomIndex = Math.floor(Math.random() * availableColors.length);
+        lastColorIndex = availableColors[randomIndex];
+        return lastColorIndex;
+    };
+};
+export type KT_SlidesOptions = {
+    name?: string;
+    duration?: number;
+    width?: number;
+    height?: number;
+    segments?: number;
+    inDuration?: number;
+    comp?: CompItem;
+    slideMultiplier?: number;
+};
+
+class KT_Slides {
+    footageFolder!: FolderItem;
+    compsFolder!: FolderItem;
+    rootFolder!: FolderItem;
+    backgroundFolder!: FolderItem;
+    backgroundComp!: CompItem;
+    compedSlidesFolder!: FolderItem;
+    duration: number = 30;
+    masterComp: CompItem;
+    slidesFootage: FootageItem[] = [];
+    width: number = 1920;
+    height: number = 1080;
+    segments: number = 6;
+    slides: Layer[] = [];
+    inDuration: number = 1;
+    name: string = "Slides";
+    slideMultiplier: number = 1;
+    backgroundColor: [number, number, number] = [1, 1, 1];
+    private getNextColor = colorSelector();
+
+    constructor(options: KT_SlidesOptions = {}) {
+        const { name, duration, width, height, segments, inDuration, comp, slideMultiplier } = options;
+        this.name = name || this.name;
+        this.duration = duration || this.duration;
+        this.width = width || this.width;
+        this.height = height || this.height;
+        this.segments = segments || this.segments;
+        this.inDuration = inDuration || this.inDuration;
+        this.slideMultiplier = slideMultiplier || this.slideMultiplier;
+        this.initFolders();
+        const compExists = KT_Project.find.comps({ name: this.name + "Master" });
+        if (compExists && compExists.length > 0) {
+            this.masterComp = compExists[0] as CompItem;
+            return;
+        }
+        this.masterComp =
+            comp ||
+            (KT_Project.add.comp({
+                name: this.name + "Master",
+                width: this.width,
+                height: this.height,
+                duration: this.duration,
+                parentFolder: this.rootFolder,
+            }) as CompItem);
+    }
+
+    initFolders = (options: KT_SlidesOptions = {}): void => {
+        const rootFolder = KT_Project.find.folders({ name: this.name + " Project" });
+        if (!rootFolder || rootFolder.length === 0) {
+            this.rootFolder = KT_Project.add.folder({ name: this.name + " Project" });
+        } else {
+            this.rootFolder = rootFolder[0];
+        }
+
+        const footageFolder = KT_Project.find.folders({ name: "Footage", root: this.rootFolder });
+        this.footageFolder =
+            footageFolder && footageFolder.length > 0
+                ? footageFolder[0]
+                : KT_Project.add.folder({ name: "Footage", parentFolder: this.rootFolder });
+        const compsFolder = KT_Project.find.folders({ name: "Premiere Comps", root: this.rootFolder });
+        this.compsFolder =
+            compsFolder && compsFolder.length > 0
+                ? compsFolder[0]
+                : KT_Project.add.folder({ name: "Premiere Comps", parentFolder: this.rootFolder });
+        let backgroundFolder: FolderItem | FolderItem[] = KT_Project.find.folders({
+            name: "Backgrounds",
+            root: this.rootFolder,
+        });
+
+        if (backgroundFolder && backgroundFolder.length > 0) {
+            this.backgroundFolder = backgroundFolder[0];
+            this.backgroundComp = KT_Project.find.comps({
+                name: "Background",
+                root: this.backgroundFolder,
+            })[0] as CompItem;
+        } else {
+            this.backgroundFolder = KT_Project.add.folder({ name: "Backgrounds", parentFolder: this.rootFolder });
+        }
+        const backgroundComp = KT_Project.find.comps({ name: "Background", root: this.backgroundFolder });
+        if (backgroundComp && backgroundComp.length > 0) {
+            this.backgroundComp = backgroundComp[0] as CompItem;
+        } else {
+            this.backgroundComp = KT_Project.add.comp({
+                name: "Background",
+                width: this.width,
+                height: this.height,
+                duration: this.duration,
+                parentFolder: this.backgroundFolder,
+            }) as CompItem;
+
+            this.backgroundComp.layers.addSolid(
+                this.backgroundColor,
+                "Background Solid",
+                this.width,
+                this.height,
+                1,
+                this.duration
+            );
+        }
+
+        const compedSlidesFolder = KT_Project.find.folders({ name: "Comped Slides", root: this.rootFolder });
+        this.compedSlidesFolder =
+            compedSlidesFolder && compedSlidesFolder.length > 0
+                ? compedSlidesFolder[0]
+                : KT_Project.add.folder({ name: "Comped Slides", parentFolder: this.rootFolder });
+    };
+
+    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) {
+            $.writeln("No path selected");
+            return;
+        }
+
+        let footage = KT_Project.import.images({
+            path: path.fsName,
+            footageFolder: this.footageFolder,
+            importAs: "footage",
+            recursive: false,
+            flat: true,
+            toComp: true,
+            compFolder: this.compedSlidesFolder,
+        });
+
+        footage = KT_Project.find.comps({ root: this.compedSlidesFolder });
+        for (const f of footage) {
+            $.writeln("Imported comp: " + f.name);
+        }
+        this.sortSlides(footage);
+        if (footage.length === 0) {
+            $.writeln("No footage imported");
+            return;
+        }
+        this.slidesFootage = footage as FootageItem[];
+
+        this.masterComp.duration = this.inDuration * 2 * (footage.length * this.slideMultiplier) + this.inDuration;
+
+        footage.forEach((item, index) => {
+            const randomColorIndex = this.getNextColor();
+            for (let i = 0; i < this.slideMultiplier; i++) {
+                if (item.name === this.name) $.bp();
+                const subCompName = ((item as FootageItem).name.split(".")[0] + "-" + (i + 1)).replace(
+                    "Artboard ",
+                    "slide"
+                );
+                const subComp = KT_Project.add.compFromFootage(item as FootageItem, {
+                    name: (item as FootageItem).name.split(".")[0] + "-" + (i + 1),
+                    parentFolder: this.compedSlidesFolder,
+                });
+
+                const layer = this.addSlide(
+                    subComp as AVItem,
+                    this.inDuration * 2,
+                    this.masterComp,
+                    (index * this.slideMultiplier + i) * this.inDuration * 2
+                );
+                this.enableTimeRemap(layer as AVLayer);
+                layer.outPoint = this.masterComp.duration;
+                layer.label = randomColorIndex;
+                this.slides.push(layer);
+            }
+        });
+
+        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 layer = batchLayers[j] as AVLayer;
+                const nextLayer = batchLayers[j + 1] as AVLayer;
+                if (layer.inPoint - nextLayer.inPoint > this.inDuration * 3) {
+                    batchLayers.splice(j + 1, batchLayers.length - (j + 1));
+                    break;
+                }
+            }
+            i += batchLayers.length;
+            this.splitSlides(batchLayers);
+        }
+    };
+    splitSlides = (layers?: Layer[]) => {
+        if (!Array.isArray(layers) || layers.length <= 1) {
+            layers = this.masterComp.selectedLayers;
+        }
+
+        if (!layers || layers.length === 0) {
+            $.writeln("No layers selected for precomp");
+            return;
+        }
+
+        const foundComps: { [key: string]: CompItem } = {};
+        const layerNames: string[] = [];
+
+        layers.forEach((pivotLayer, index, collection) => {
+            const invertedIndex = collection.length - index;
+            const slideName = pivotLayer.name.split("-")[0] + "_Slide_" + invertedIndex;
+            layerNames.push(slideName);
+        });
+
+        KT_Project.find.comps({
+            root: this.compsFolder,
+            name: layerNames,
+            callback: (item) => {
+                const comp = item as CompItem;
+                foundComps[comp.name] = comp;
+            },
+        });
+
+        layers.sort((a, b) => a.index - b.index); // Ordenar de menor a mayor
+        let pivotIndex = 0;
+        layers.forEach((pivotLayer, index, collection) => {
+            pivotLayer = pivotLayer as AVLayer;
+            const invertedIndex = collection.length - index;
+            const slideName = pivotLayer.name.split("-")[0] + "_Slide_" + invertedIndex;
+            let precomp = foundComps[slideName];
+            if (precomp instanceof CompItem) {
+                const layersToRemove = KT_Layers.find.layers({ comps: precomp });
+                layersToRemove.forEach((layer) => layer.remove());
+            } else {
+                precomp = KT_Project.add.comp({
+                    name: slideName,
+                    width: this.width,
+                    height: this.height,
+                    duration: this.duration,
+                    parentFolder: this.compsFolder,
+                }) as CompItem;
+            }
+
+            // Obtener todas las capas
+
+            // Eliminar todas las capas posteriores a la capa pivote
+
+            for (let i = collection.length - 1; i >= 0; i--) {
+                const layer = collection[i];
+
+                if (layer.index < pivotLayer.index) {
+                    continue;
+                }
+                layer.copyToComp(precomp);
+                const newLayer = precomp.layers[1];
+                if (i === pivotIndex) {
+                    newLayer.startTime = newLayer.startTime - newLayer.inPoint;
+                } else {
+                    newLayer.startTime = newLayer.startTime - newLayer.inPoint - this.inDuration;
+                }
+
+                newLayer.outPoint = this.duration;
+                newLayer.label = layer.label;
+            }
+
+            pivotIndex += 1;
+            // Ajustar la duración de la precomp
+            const solid = precomp.layers.add(this.backgroundComp);
+            solid.moveToEnd();
+            precomp.duration = this.duration;
+        });
+    };
+
+    private addSlide(
+        source: AVItem,
+        duration: number,
+        comp: CompItem = app.project.activeItem as CompItem,
+        startTime?: number
+    ) {
+        const layer = comp.layers.add(source);
+        layer.startTime = 0;
+        layer.outPoint = duration;
+        this.slideUp(layer);
+        this.disolveIn(layer);
+        layer.startTime = startTime || 0;
+        return layer;
+    }
+
+    private disolveIn = (layer: Layer) => {
+        layer.opacity.setValueAtTime(layer.startTime, 0);
+        layer.opacity.setValueAtTime(layer.startTime + this.inDuration, 100);
+        const easeIn = new KeyframeEase(0, 20);
+        const easeOut = new KeyframeEase(0, 50);
+        layer.opacity.setTemporalEaseAtKey(1, [easeOut], [easeIn]);
+        layer.opacity.setTemporalEaseAtKey(2, [easeOut], [easeIn]);
+    };
+
+    private slideUp = (layer: Layer) => {
+        const finalPosition = layer.position.value;
+        layer.position.setValueAtTime(layer.startTime, [finalPosition[0], finalPosition[1] + 100]);
+        layer.position.setValueAtTime(layer.startTime + this.inDuration, finalPosition);
+        let easeIn = new KeyframeEase(0, 20);
+        let easeOut = new KeyframeEase(0, 50);
+        layer.position.setTemporalEaseAtKey(1, [easeOut], [easeIn]);
+        layer.position.setTemporalEaseAtKey(2, [easeOut], [easeIn]);
+    };
+
+    private sortSlides = (layers: Layer[] | _ItemClasses[]) => {
+        layers.sort((a, b) => {
+            const nameA = a.name.split("-")[0];
+            const nameB = b.name.split("-")[0];
+            return parseInt(nameA) - parseInt(nameB);
+        });
+    };
+
+    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.removeKey(property.numKeys);
+        }
+        return layer;
+    };
+}
+
+export { KT_Slides };
+
+class __KT_SlidesAPI {
+    private slidesInstance: KT_Slides | null = null;
+    static import = (options: KT_SlidesOptions = {}) => {
+        const slides = new KT_Slides(options);
+        slides.import(options.slideMultiplier);
+        return slides;
+    };
+
+    static refreshAll = (slidesInstance: KT_Slides) => {
+        slidesInstance.batchSplitSlides();
+    };
+
+    static refreshSelected = (slidesInstance: KT_Slides) => {
+        slidesInstance.splitSlides();
+    };
+}
+
+export const KT_SlidesAPI = __KT_SlidesAPI;

package/src/tests/index.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect, runTests, beforeAll, afterAll, beforeEach, afterEach } from "kt-testing-suite-core";
+import { KT_Slides } from "../index";
+
+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,
+        });
+        // slides.import();
+        // slides.splitSlides();
+        const startTime = new Date().getTime();
+        // slides.batchSplitSlides();
+        slides.splitSlides();
+
+        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")
+        );
+    });
+});
+
+runTests();

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES3",
+    "module": "CommonJS",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": [],
+    "sourceMap": true,
+    "types": [
+      "./node_modules/kt-core/src/lib/kt-types",
+      "./node_modules/types-for-adobe/shared/global",
+      "./node_modules/types-for-adobe/shared/JavaScript",
+      "./node_modules/types-for-adobe/AfterEffects/23.0"
+    ]
+  },
+  "include": [
+    "src"
+  ]
+}