@bariskuran/base 0.0.0-stage → 0.0.1

package/src/libs/createImageCatalog/vars.js

@@ -0,0 +1,875 @@
+/* eslint-disable no-undef */
+const fs = require("fs");
+const path = require("path");
+
+const IMAGE_SCRIPT_NAME = "images:index";
+const IMAGE_SCRIPT_COMMAND =
+    "node node_modules/@bariskuran/base/src/libs/createImageCatalog/tools/base-image-index.cjs";
+const SUPPORTED_EXTENSIONS = new Set([".webp", ".jpg", ".jpeg", ".png", ".gif"]);
+const GENERATED_HEADER = "// Auto Generated by `yarn images:index`";
+const ROOT_PROPS_TO_DROP = new Set(["imageSet", "images", "name", "originalName", "originalPath"]);
+const KNOWN_VARIANT_ORDER = [
+    "placeholder",
+    "thumb",
+    "small",
+    "medium",
+    "large",
+    "ultra",
+    "original",
+];
+const IMAGE_CATALOG_DIR_NAME = "imageCatalog";
+const ARATIO_DECIMALS = 1;
+// Keep generated catalog modules comfortably below Vite's default chunk warning.
+const IMAGE_CATALOG_CHUNK_SIZE_LIMIT = 220 * 1024;
+
+function getARatio(naturalWidth, naturalHeight) {
+    if (!naturalWidth || !naturalHeight) return null;
+    const factor = 10 ** ARATIO_DECIMALS;
+    return Math.round((naturalWidth / naturalHeight) * factor) / factor;
+}
+
+function getSrcImageCatalogDir(projectRoot) {
+    return path.join(projectRoot, "src", IMAGE_CATALOG_DIR_NAME);
+}
+
+function getPublicImageCatalogDir(projectRoot) {
+    return path.join(projectRoot, "public", IMAGE_CATALOG_DIR_NAME);
+}
+
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function readText(filePath) {
+    if (!fs.existsSync(filePath)) return "";
+    return fs.readFileSync(filePath, "utf8");
+}
+
+function writeTextIfChanged(filePath, content) {
+    const current = readText(filePath);
+    if (current === content) return false;
+    fs.writeFileSync(filePath, content);
+    return true;
+}
+
+function getMimeType(ext) {
+    const cleanExt = ext.toLowerCase();
+    if (cleanExt === ".webp") return "image/webp";
+    if (cleanExt === ".jpg" || cleanExt === ".jpeg") return "image/jpeg";
+    if (cleanExt === ".png") return "image/png";
+    if (cleanExt === ".gif") return "image/gif";
+    return "application/octet-stream";
+}
+
+function getShape(naturalWidth, naturalHeight) {
+    if (!naturalWidth || !naturalHeight) return "unknown";
+    if (naturalWidth === naturalHeight) return "square";
+    return naturalWidth > naturalHeight ? "landscape" : "portrait";
+}
+
+function normalizeShape(value) {
+    const cleanValue = String(value || "")
+        .replace(/^["'`]|["'`]$/g, "")
+        .trim()
+        .toLowerCase();
+
+    if (cleanValue === "horizontal" || cleanValue === "landscape") return "landscape";
+    if (cleanValue === "vertical" || cleanValue === "portrait") return "portrait";
+    if (cleanValue === "square") return "square";
+    return cleanValue || "unknown";
+}
+
+function getPngSize(buffer) {
+    if (buffer.length < 24 || buffer.toString("ascii", 1, 4) !== "PNG") return null;
+    return {
+        naturalWidth: buffer.readUInt32BE(16),
+        naturalHeight: buffer.readUInt32BE(20),
+    };
+}
+
+function getGifSize(buffer) {
+    if (buffer.length < 10) return null;
+    const signature = buffer.toString("ascii", 0, 6);
+    if (signature !== "GIF87a" && signature !== "GIF89a") return null;
+    return {
+        naturalWidth: buffer.readUInt16LE(6),
+        naturalHeight: buffer.readUInt16LE(8),
+    };
+}
+
+function getJpegSize(buffer) {
+    if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8) return null;
+
+    let offset = 2;
+    while (offset < buffer.length) {
+        if (buffer[offset] !== 0xff) {
+            offset += 1;
+            continue;
+        }
+
+        const marker = buffer[offset + 1];
+        offset += 2;
+
+        if (marker === 0xd9 || marker === 0xda) break;
+        if (offset + 2 > buffer.length) break;
+
+        const blockLength = buffer.readUInt16BE(offset);
+        const isSizeMarker =
+            (marker >= 0xc0 && marker <= 0xc3) ||
+            (marker >= 0xc5 && marker <= 0xc7) ||
+            (marker >= 0xc9 && marker <= 0xcb) ||
+            (marker >= 0xcd && marker <= 0xcf);
+
+        if (isSizeMarker && offset + 7 < buffer.length) {
+            return {
+                naturalHeight: buffer.readUInt16BE(offset + 3),
+                naturalWidth: buffer.readUInt16BE(offset + 5),
+            };
+        }
+
+        offset += blockLength;
+    }
+
+    return null;
+}
+
+function getWebpSize(buffer) {
+    if (buffer.length < 30) return null;
+    if (buffer.toString("ascii", 0, 4) !== "RIFF" || buffer.toString("ascii", 8, 12) !== "WEBP") {
+        return null;
+    }
+
+    const chunkType = buffer.toString("ascii", 12, 16);
+    if (chunkType === "VP8 ") {
+        return {
+            naturalWidth: buffer.readUInt16LE(26) & 0x3fff,
+            naturalHeight: buffer.readUInt16LE(28) & 0x3fff,
+        };
+    }
+
+    if (chunkType === "VP8L") {
+        const bits =
+            buffer[21] |
+            (buffer[22] << 8) |
+            (buffer[23] << 16) |
+            (buffer[24] << 24);
+        return {
+            naturalWidth: (bits & 0x3fff) + 1,
+            naturalHeight: ((bits >> 14) & 0x3fff) + 1,
+        };
+    }
+
+    if (chunkType === "VP8X") {
+        return {
+            naturalWidth: buffer.readUIntLE(24, 3) + 1,
+            naturalHeight: buffer.readUIntLE(27, 3) + 1,
+        };
+    }
+
+    return null;
+}
+
+function getImageSize(filePath) {
+    const buffer = fs.readFileSync(filePath);
+    const ext = path.extname(filePath).toLowerCase();
+    const size =
+        ext === ".png"
+            ? getPngSize(buffer)
+            : ext === ".gif"
+              ? getGifSize(buffer)
+              : ext === ".jpg" || ext === ".jpeg"
+                ? getJpegSize(buffer)
+                : ext === ".webp"
+                  ? getWebpSize(buffer)
+                  : null;
+
+    return size || { naturalWidth: null, naturalHeight: null };
+}
+
+function compareImageFileNames(a, b) {
+    const aKey = path.basename(a, path.extname(a)).toLowerCase();
+    const bKey = path.basename(b, path.extname(b)).toLowerCase();
+    const aIndex = KNOWN_VARIANT_ORDER.indexOf(aKey);
+    const bIndex = KNOWN_VARIANT_ORDER.indexOf(bKey);
+
+    if (aIndex !== -1 || bIndex !== -1) {
+        if (aIndex === -1) return 1;
+        if (bIndex === -1) return -1;
+        return aIndex - bIndex;
+    }
+
+    return a.localeCompare(b);
+}
+
+function toIdentifier(value, fallback = "imageFile") {
+    const normalized = String(value)
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-zA-Z0-9_$]/g, "_")
+        .replace(/^([^a-zA-Z_$])/, "_$1");
+
+    return normalized || fallback;
+}
+
+function createUniqueIdentifier(baseIdentifier, usedIdentifiers) {
+    let identifier = baseIdentifier;
+    let counter = 2;
+
+    while (usedIdentifiers.has(identifier)) {
+        identifier = `${baseIdentifier}_${counter}`;
+        counter += 1;
+    }
+
+    usedIdentifiers.add(identifier);
+    return identifier;
+}
+
+function findObjectBody(source) {
+    const constMatch = source.match(/const\s+image\s*=\s*\{/);
+    const exportMatch = source.match(/export\s+default\s*\{/);
+    const match = constMatch || exportMatch;
+    if (!match) return "";
+
+    const openIndex = match.index + match[0].lastIndexOf("{");
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    let lineComment = false;
+    let blockComment = false;
+
+    for (let index = openIndex; index < source.length; index += 1) {
+        const char = source[index];
+        const next = source[index + 1];
+
+        if (lineComment) {
+            if (char === "\n") lineComment = false;
+            continue;
+        }
+
+        if (blockComment) {
+            if (char === "*" && next === "/") {
+                blockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+
+        if (quote) {
+            if (escaped) escaped = false;
+            else if (char === "\\") escaped = true;
+            else if (char === quote) quote = null;
+            continue;
+        }
+
+        if (char === "/" && next === "/") {
+            lineComment = true;
+            index += 1;
+            continue;
+        }
+
+        if (char === "/" && next === "*") {
+            blockComment = true;
+            index += 1;
+            continue;
+        }
+
+        if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+
+        if (char === "{") depth += 1;
+        if (char === "}") depth -= 1;
+
+        if (depth === 0) return source.slice(openIndex + 1, index);
+    }
+
+    return "";
+}
+
+function splitTopLevelProperties(objectBody) {
+    const props = [];
+    let start = 0;
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    let lineComment = false;
+    let blockComment = false;
+
+    for (let index = 0; index < objectBody.length; index += 1) {
+        const char = objectBody[index];
+        const next = objectBody[index + 1];
+
+        if (lineComment) {
+            if (char === "\n") lineComment = false;
+            continue;
+        }
+
+        if (blockComment) {
+            if (char === "*" && next === "/") {
+                blockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+
+        if (quote) {
+            if (escaped) escaped = false;
+            else if (char === "\\") escaped = true;
+            else if (char === quote) quote = null;
+            continue;
+        }
+
+        if (char === "/" && next === "/") {
+            lineComment = true;
+            index += 1;
+            continue;
+        }
+
+        if (char === "/" && next === "*") {
+            blockComment = true;
+            index += 1;
+            continue;
+        }
+
+        if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+
+        if (char === "{" || char === "[" || char === "(") depth += 1;
+        if (char === "}" || char === "]" || char === ")") depth -= 1;
+
+        if (char === "," && depth === 0) {
+            const prop = objectBody.slice(start, index).trim();
+            if (prop) props.push(prop);
+            start = index + 1;
+        }
+    }
+
+    const lastProp = objectBody.slice(start).trim();
+    if (lastProp) props.push(lastProp);
+    return props;
+}
+
+function getPropertyKey(prop) {
+    const match = prop.match(/^((?:["'`][^"'`]+["'`])|(?:[a-zA-Z_$][\w$-]*))\s*:/);
+    if (!match) return null;
+    return match[1].replace(/^["'`]|["'`]$/g, "");
+}
+
+function getPropertyValue(prop) {
+    const colonIndex = prop.indexOf(":");
+    if (colonIndex === -1) return "";
+    return prop.slice(colonIndex + 1).trim();
+}
+
+function createProperty(key, value) {
+    return `    ${key}: ${value}`;
+}
+
+function normalizeExistingProps(source, generatedKeys = new Set()) {
+    const objectBody = findObjectBody(source);
+    const props = objectBody ? splitTopLevelProperties(objectBody) : [];
+    const nextProps = [];
+    let hasAlt = false;
+    let descriptionValue = null;
+
+    for (const prop of props) {
+        const key = getPropertyKey(prop);
+        if (!key) continue;
+        if (ROOT_PROPS_TO_DROP.has(key) || generatedKeys.has(key)) continue;
+
+        if (key === "description") {
+            descriptionValue = getPropertyValue(prop);
+            continue;
+        }
+
+        if (key === "orientation" || key === "shape") {
+            continue;
+        }
+
+        if (key === "alt") hasAlt = true;
+        nextProps.push(createProperty(key, getPropertyValue(prop)));
+    }
+
+    if (!hasAlt) nextProps.unshift(createProperty("alt", descriptionValue || '""'));
+    return nextProps;
+}
+
+function getImageFiles(folderPath) {
+    if (!fs.existsSync(folderPath)) return [];
+    return fs
+        .readdirSync(folderPath, { withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .filter((fileName) => SUPPORTED_EXTENSIONS.has(path.extname(fileName).toLowerCase()))
+        .sort(compareImageFileNames);
+}
+
+function createImageSetData(folderPath, imageFiles, options = {}) {
+    const usedIdentifiers = new Set();
+
+    return imageFiles.map((fileName) => {
+        const ext = path.extname(fileName).toLowerCase();
+        const key = path.basename(fileName, ext);
+        const importName = createUniqueIdentifier(toIdentifier(key, "imageFile"), usedIdentifiers);
+        const filePath = path.join(folderPath, fileName);
+        const stats = fs.statSync(filePath);
+        const size = getImageSize(filePath);
+
+        return {
+            key,
+            fileName,
+            importName,
+            srcExpression:
+                options.sourceType === "public"
+                    ? JSON.stringify(`/${IMAGE_CATALOG_DIR_NAME}/${path.basename(folderPath)}/${fileName}`)
+                    : importName,
+            naturalWidth: size.naturalWidth,
+            naturalHeight: size.naturalHeight,
+            aRatio: getARatio(size.naturalWidth, size.naturalHeight),
+            type: getMimeType(ext),
+            sizeBytes: stats.size,
+            shape: getShape(size.naturalWidth, size.naturalHeight),
+        };
+    });
+}
+
+function formatMaybeNumber(value) {
+    return value === null || value === undefined ? "null" : String(value);
+}
+
+function createImageSetEntry(item) {
+    return `        ${JSON.stringify(item.key)}: {
+            key: ${JSON.stringify(item.key)},
+            src: ${item.srcExpression},
+            naturalWidth: ${formatMaybeNumber(item.naturalWidth)},
+            naturalHeight: ${formatMaybeNumber(item.naturalHeight)},
+            aRatio: ${formatMaybeNumber(item.aRatio)},
+            type: ${JSON.stringify(item.type)},
+            sizeBytes: ${item.sizeBytes},
+            sizeKBytes: ${Number((item.sizeBytes / 1024).toFixed(2))},
+            sizeMBytes: ${Number((item.sizeBytes / 1024 / 1024).toFixed(3))},
+            shape: ${JSON.stringify(item.shape)},
+        }`;
+}
+
+function getRepresentativeImage(imageSetData) {
+    return imageSetData
+        .filter((item) => item.naturalWidth && item.naturalHeight)
+        .sort((a, b) => b.naturalWidth * b.naturalHeight - a.naturalWidth * a.naturalHeight)[0];
+}
+
+function createImageObjectContent(currentSource, imageFiles, folderPath, options = {}) {
+    const generatedKeys = new Set(imageFiles.map((fileName) => path.basename(fileName, path.extname(fileName))));
+    const existingProps = normalizeExistingProps(currentSource, generatedKeys);
+    const imageSetData = createImageSetData(folderPath, imageFiles, options);
+    const representativeImage = getRepresentativeImage(imageSetData);
+    const props = [...existingProps];
+
+    props.push(`
+    ${GENERATED_HEADER}
+    shape: ${JSON.stringify(representativeImage?.shape || "unknown")},
+    imageSet: {
+${imageSetData.map(createImageSetEntry).join(",\n")}
+    }`);
+
+    return `{
+${props.join(",\n")}
+}`;
+}
+
+function createImageIndexContent(folderName, currentSource, imageFiles, folderPath, options = {}) {
+    const imageSetData = createImageSetData(folderPath, imageFiles, options);
+    const imports =
+        options.sourceType === "public"
+            ? []
+            : imageSetData.map((item) => `import ${item.importName} from "./${item.fileName}";`);
+    const imageObject = createImageObjectContent(currentSource, imageFiles, folderPath, options);
+
+    return `${GENERATED_HEADER}
+${imports.join("\n")}
+
+const image = ${imageObject};
+
+export default image;
+`;
+}
+
+function createFolderIndexIfMissing(folderPath) {
+    const indexPath = path.join(folderPath, "index.js");
+    if (fs.existsSync(indexPath)) return false;
+
+    fs.writeFileSync(
+        indexPath,
+        `const image = {
+    alt: "",
+};
+
+export default image;
+`,
+    );
+    return true;
+}
+
+function updateImageFolderIndex(folderPath, options = {}) {
+    createFolderIndexIfMissing(folderPath);
+
+    const imageFiles = getImageFiles(folderPath);
+    if (imageFiles.length === 0) return { changed: false, imageCount: 0 };
+
+    const indexPath = path.join(folderPath, "index.js");
+    const currentSource = readText(indexPath);
+    const content = createImageIndexContent(
+        path.basename(folderPath),
+        currentSource,
+        imageFiles,
+        folderPath,
+        options,
+    );
+    const changed = writeTextIfChanged(indexPath, content);
+
+    return { changed, imageCount: imageFiles.length };
+}
+
+function getImageFolders(imagesDir) {
+    if (!fs.existsSync(imagesDir)) return [];
+    return fs
+        .readdirSync(imagesDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .filter((folderName) => getImageFiles(path.join(imagesDir, folderName)).length > 0)
+        .sort((a, b) => a.localeCompare(b));
+}
+
+function createCatalogIndexContent(imageFolders) {
+    const usedIdentifiers = new Set();
+    const imports = [];
+    const entries = imageFolders.map((folder) => {
+        if (folder.sourceType === "public") {
+            const imageFiles = getImageFiles(folder.folderPath);
+            const currentSource = readText(path.join(folder.folderPath, "index.js"));
+            return {
+                folderName: folder.folderName,
+                expression: createImageObjectContent(currentSource, imageFiles, folder.folderPath, {
+                    sourceType: "public",
+                }),
+            };
+        }
+
+        const importName = createUniqueIdentifier(toIdentifier(folder.folderName, "image"), usedIdentifiers);
+        imports.push({
+            folderName: folder.folderName,
+            importName,
+            line: `import ${importName} from "./${folder.folderName}";`,
+        });
+        return { folderName: folder.folderName, expression: importName };
+    });
+
+    return `${GENERATED_HEADER}
+${imports.map((item) => item.line).join("\n")}
+
+export default {
+${entries.map((item) => `    ${JSON.stringify(item.folderName)}: ${item.expression}`).join(",\n")}
+};
+`;
+}
+
+function updateCatalogIndex(imagesDir, imageFolders) {
+    const indexPath = path.join(imagesDir, "index.js");
+    return writeTextIfChanged(indexPath, createCatalogIndexContent(imageFolders));
+}
+
+function findCatalogExportObject(source) {
+    const marker = "export default";
+    const exportIndex = source.indexOf(marker);
+    if (exportIndex < 0) return null;
+
+    const openIndex = source.indexOf("{", exportIndex);
+    if (openIndex < 0) return null;
+
+    let depth = 0;
+    let quote = null;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+
+    for (let index = openIndex; index < source.length; index += 1) {
+        const char = source[index];
+        const next = source[index + 1];
+
+        if (inLineComment) {
+            if (char === "\n") inLineComment = false;
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === "*" && next === "/") {
+                inBlockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (quote) {
+            if (escaped) escaped = false;
+            else if (char === "\\") escaped = true;
+            else if (char === quote) quote = null;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            inLineComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inBlockComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === "{") depth += 1;
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return { prefix: source.slice(0, exportIndex), body: source.slice(openIndex + 1, index) };
+            }
+        }
+    }
+
+    return null;
+}
+
+function splitCatalogEntries(body) {
+    const entries = [];
+    let start = 0;
+    let depth = 0;
+    let quote = null;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+
+    for (let index = 0; index < body.length; index += 1) {
+        const char = body[index];
+        const next = body[index + 1];
+
+        if (inLineComment) {
+            if (char === "\n") inLineComment = false;
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === "*" && next === "/") {
+                inBlockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (quote) {
+            if (escaped) escaped = false;
+            else if (char === "\\") escaped = true;
+            else if (char === quote) quote = null;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            inLineComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inBlockComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === "{" || char === "[" || char === "(") depth += 1;
+        if (char === "}" || char === "]" || char === ")") depth -= 1;
+        if (char === "," && depth === 0) {
+            const entry = body.slice(start, index).trim();
+            if (entry) entries.push(entry);
+            start = index + 1;
+        }
+    }
+
+    const lastEntry = body.slice(start).trim();
+    if (lastEntry) entries.push(lastEntry);
+    return entries;
+}
+
+function removeCatalogChunks(chunksDir) {
+    if (!fs.existsSync(chunksDir)) return;
+    for (const fileName of fs.readdirSync(chunksDir)) {
+        if (/^catalog_\d+\.js$/.test(fileName)) fs.unlinkSync(path.join(chunksDir, fileName));
+    }
+}
+
+function splitImageCatalog(imagesDir, chunkSizeLimit = IMAGE_CATALOG_CHUNK_SIZE_LIMIT) {
+    const indexPath = path.join(imagesDir, "index.js");
+    const source = readText(indexPath);
+    const chunksDir = path.join(imagesDir, "_chunks");
+
+    if (!source || Buffer.byteLength(source, "utf8") <= chunkSizeLimit) {
+        removeCatalogChunks(chunksDir);
+        return { split: false, chunkCount: 0 };
+    }
+
+    const parsed = findCatalogExportObject(source);
+    if (!parsed) throw new Error(`Could not split generated image catalog: ${indexPath}`);
+
+    const entries = splitCatalogEntries(parsed.body);
+    if (entries.length === 0) return { split: false, chunkCount: 0 };
+
+    const chunks = [];
+    let currentEntries = [];
+    let currentSize = 0;
+
+    for (const entry of entries) {
+        const entrySize = Buffer.byteLength(entry, "utf8");
+        if (currentEntries.length > 0 && currentSize + entrySize > chunkSizeLimit) {
+            chunks.push(currentEntries);
+            currentEntries = [];
+            currentSize = 0;
+        }
+        currentEntries.push(entry);
+        currentSize += entrySize;
+    }
+    if (currentEntries.length > 0) chunks.push(currentEntries);
+
+    ensureDir(chunksDir);
+    removeCatalogChunks(chunksDir);
+
+    chunks.forEach((chunkEntries, index) => {
+        const usesPlaceholder = chunkEntries.some((entry) => /\b_placeholder\b/.test(entry));
+        const imports = usesPlaceholder
+            ? `${GENERATED_HEADER}\nimport _placeholder from "../_placeholder";\n\n`
+            : `${GENERATED_HEADER}\n\n`;
+        const content = `${imports}export default {\n${chunkEntries.map((entry) => `    ${entry}`).join(",\n")}\n};\n`;
+        writeTextIfChanged(path.join(chunksDir, `catalog_${index}.js`), content);
+    });
+
+    const imports = chunks.map((_, index) => `import catalog_${index} from "./_chunks/catalog_${index}.js";`);
+    const entriesContent = chunks.map((_, index) => `    ...catalog_${index},`);
+    const nextIndex = `${GENERATED_HEADER}\n${imports.join("\n")}\n\nexport default {\n${entriesContent.join("\n")}\n};\n`;
+    writeTextIfChanged(indexPath, nextIndex);
+
+    return { split: true, chunkCount: chunks.length };
+}
+
+function generateImageIndexes(projectRoot) {
+    const srcCatalogDir = getSrcImageCatalogDir(projectRoot);
+    const publicCatalogDir = getPublicImageCatalogDir(projectRoot);
+    ensureDir(srcCatalogDir);
+    ensureDir(publicCatalogDir);
+
+    const srcImageFolders = getImageFolders(srcCatalogDir).map((folderName) => ({
+        folderName,
+        folderPath: path.join(srcCatalogDir, folderName),
+        sourceType: "src",
+    }));
+    const publicImageFolders = getImageFolders(publicCatalogDir).map((folderName) => ({
+        folderName,
+        folderPath: path.join(publicCatalogDir, folderName),
+        sourceType: "public",
+    }));
+    const imageFolders = [...srcImageFolders, ...publicImageFolders].sort((a, b) =>
+        a.folderName.localeCompare(b.folderName),
+    );
+    let totalImages = 0;
+    const changedFolders = [];
+
+    for (const folder of imageFolders) {
+        const result = updateImageFolderIndex(folder.folderPath, { sourceType: folder.sourceType });
+        totalImages += result.imageCount;
+        if (result.changed) changedFolders.push(folder.folderName);
+    }
+
+    const catalogChanged = updateCatalogIndex(srcCatalogDir, imageFolders);
+    const catalogSplit = splitImageCatalog(srcCatalogDir);
+
+    return {
+        imagesDir: srcCatalogDir,
+        srcCatalogDir,
+        publicCatalogDir,
+        imageFolders: imageFolders.map((folder) => folder.folderName),
+        changedFolders,
+        totalImages,
+        catalogChanged,
+        catalogSplit,
+    };
+}
+
+function readPackageJson(projectRoot) {
+    const packageJsonPath = path.join(projectRoot, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        throw new Error(`package.json not found at ${packageJsonPath}`);
+    }
+
+    return {
+        packageJsonPath,
+        packageJson: JSON.parse(fs.readFileSync(packageJsonPath, "utf8")),
+    };
+}
+
+function setupImageCatalog(projectRoot) {
+    const imagesDir = getSrcImageCatalogDir(projectRoot);
+    const publicImagesDir = getPublicImageCatalogDir(projectRoot);
+    const imagesDirCreated = !fs.existsSync(imagesDir);
+    ensureDir(imagesDir);
+    ensureDir(publicImagesDir);
+
+    const indexPath = path.join(imagesDir, "index.js");
+    if (!fs.existsSync(indexPath)) {
+        fs.writeFileSync(
+            indexPath,
+            `${GENERATED_HEADER}
+
+export default {};
+`,
+        );
+    }
+
+    const { packageJsonPath, packageJson } = readPackageJson(projectRoot);
+    const currentScripts = packageJson.scripts || {};
+    const shouldReplaceImageScript =
+        !currentScripts[IMAGE_SCRIPT_NAME] || currentScripts[IMAGE_SCRIPT_NAME] === "base-image-index";
+    const nextPackageJson = {
+        ...packageJson,
+        scripts: {
+            ...currentScripts,
+            [IMAGE_SCRIPT_NAME]: shouldReplaceImageScript
+                ? IMAGE_SCRIPT_COMMAND
+                : currentScripts[IMAGE_SCRIPT_NAME],
+        },
+    };
+
+    const packageJsonUpdated = writeTextIfChanged(
+        packageJsonPath,
+        `${JSON.stringify(nextPackageJson, null, 4)}\n`,
+    );
+
+    return {
+        imagesDir,
+        imagesDirCreated,
+        packageJsonUpdated,
+    };
+}
+
+module.exports = {
+    GENERATED_HEADER,
+    IMAGE_SCRIPT_COMMAND,
+    IMAGE_SCRIPT_NAME,
+    SUPPORTED_EXTENSIONS,
+    createCatalogIndexContent,
+    createImageIndexContent,
+    generateImageIndexes,
+    getARatio,
+    getImageSize,
+    getShape,
+    normalizeShape,
+    splitImageCatalog,
+    setupImageCatalog,
+};