@adaptive-ds/assets-optimizer 0.1.0 → 0.2.1

package/dist/image/imageFormats.js

@@ -0,0 +1 @@
+export const imageFormats = new Set(["jpg", "png", "webp", "avif"]);

package/dist/image/isImageFormat.d.ts

@@ -0,0 +1,3 @@
+import { type ImageFormat } from "./ImageFormat.js";
+export declare function isImageFormat(value: string): value is ImageFormat;
+//# sourceMappingURL=isImageFormat.d.ts.map

package/dist/image/isImageFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isImageFormat.d.ts","sourceRoot":"","sources":["../../src/image/isImageFormat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,WAAW,CAEjE"}

package/dist/image/isImageFormat.js

@@ -0,0 +1,5 @@
+import {} from "./ImageFormat.js";
+import { imageFormats } from "./imageFormats.js";
+export function isImageFormat(value) {
+    return imageFormats.has(value);
+}

package/dist/image/parseTransformSpec.d.ts

@@ -0,0 +1,3 @@
+import type { TransformSpec } from "./TransformSpec.js";
+export declare function parseTransformSpec(dirName: string): TransformSpec | null;
+//# sourceMappingURL=parseTransformSpec.d.ts.map

package/dist/image/parseTransformSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseTransformSpec.d.ts","sourceRoot":"","sources":["../../src/image/parseTransformSpec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CA4BxE"}

package/dist/image/parseTransformSpec.js

@@ -0,0 +1,26 @@
+import { isImageFormat } from "./isImageFormat.js";
+export function parseTransformSpec(dirName) {
+    const match = /^(?<width>\d+)x(?<height>\d+)_(?<format>jpg|png|webp|avif)$/.exec(dirName);
+    if (!match?.groups) {
+        return null;
+    }
+    const { width: widthValue, height: heightValue, format: formatValue } = match.groups;
+    if (!widthValue || !heightValue || !formatValue) {
+        return null;
+    }
+    const width = Number.parseInt(widthValue, 10);
+    const height = Number.parseInt(heightValue, 10);
+    if (!isImageFormat(formatValue)) {
+        return null;
+    }
+    const format = formatValue;
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+        return null;
+    }
+    return {
+        width,
+        height,
+        format,
+        normalized: `${width}x${height}_${format}`,
+    };
+}

package/dist/image/processImage.d.ts

@@ -0,0 +1,3 @@
+import type { TransformSpec } from "./TransformSpec.js";
+export declare function processImage(sourceBuffer: Buffer, outputPath: string, transform: TransformSpec, quality?: number): Promise<void>;
+//# sourceMappingURL=processImage.d.ts.map

package/dist/image/processImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processImage.d.ts","sourceRoot":"","sources":["../../src/image/processImage.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD,wBAAsB,YAAY,CAChC,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,aAAa,EACxB,OAAO,SAAiB,GACvB,OAAO,CAAC,IAAI,CAAC,CA0Bf"}

package/dist/image/processImage.js

@@ -0,0 +1,28 @@
+import sharp from "sharp";
+import { assertNever } from "../shared/assertNever.js";
+import { defaultQuality } from "./defaultQuality.js";
+export async function processImage(sourceBuffer, outputPath, transform, quality = defaultQuality) {
+    let pipeline = sharp(sourceBuffer, { animated: false }).rotate().resize({
+        width: transform.width,
+        height: transform.height,
+        fit: "inside",
+        withoutEnlargement: true,
+    });
+    switch (transform.format) {
+        case "jpg":
+            pipeline = pipeline.jpeg({ quality });
+            break;
+        case "png":
+            pipeline = pipeline.png({ quality });
+            break;
+        case "webp":
+            pipeline = pipeline.webp({ quality });
+            break;
+        case "avif":
+            pipeline = pipeline.avif({ quality });
+            break;
+        default:
+            assertNever(transform.format);
+    }
+    await pipeline.toFile(outputPath);
+}

package/dist/image/processImages.d.ts

@@ -0,0 +1,3 @@
+import type { ProcessImagesOptions } from "./ProcessImagesOptions.js";
+export declare function processImages(options: ProcessImagesOptions): Promise<void>;
+//# sourceMappingURL=processImages.d.ts.map

package/dist/image/processImages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processImages.d.ts","sourceRoot":"","sources":["../../src/image/processImages.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAErE,wBAAsB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBhF"}

package/dist/image/processImages.js

@@ -0,0 +1,19 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { listLocalFiles } from "../shared/listLocalFiles.js";
+import { buildExpectedImages } from "./buildExpectedImages.js";
+export async function processImages(options) {
+    const { allowRootImageFiles, imageOptimizedDir, imageOriginalsDir, result } = options;
+    await fs.mkdir(imageOriginalsDir, { recursive: true });
+    await fs.mkdir(imageOptimizedDir, { recursive: true });
+    const expectedImages = await buildExpectedImages(imageOriginalsDir, imageOptimizedDir, result, allowRootImageFiles);
+    const expectedFileNames = new Set(expectedImages.map((image) => image.fileName));
+    const localOptimizedFiles = await listLocalFiles(imageOptimizedDir);
+    for (const localFile of localOptimizedFiles) {
+        const relativeFile = path.relative(imageOptimizedDir, localFile);
+        if (!expectedFileNames.has(relativeFile) && !relativeFile.startsWith(".")) {
+            await fs.rm(localFile, { force: true });
+            result.deletedLocal.push(relativeFile);
+        }
+    }
+}

package/dist/image/supportedSourceExtensions.d.ts

@@ -0,0 +1,2 @@
+export declare const supportedSourceExtensions: Set<string>;
+//# sourceMappingURL=supportedSourceExtensions.d.ts.map

package/dist/image/supportedSourceExtensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supportedSourceExtensions.d.ts","sourceRoot":"","sources":["../../src/image/supportedSourceExtensions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB,aAAgF,CAAA"}

package/dist/image/supportedSourceExtensions.js

@@ -0,0 +1 @@
+export const supportedSourceExtensions = new Set([".jpg", ".jpeg", ".png", ".webp", ".avif", ".tif", ".tiff", ".gif"]);

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+export * from "./AssetsOptimizeOptions.js";
+export * from "./AssetsOptimizeResult.js";
+export * from "./image/buildExpectedImages.js";
+export * from "./image/createOutputHash.js";
+export * from "./image/defaultQuality.js";
+export * from "./image/ExpectedImage.js";
+export * from "./image/ImageFormat.js";
+export * from "./image/parseTransformSpec.js";
+export * from "./image/processImage.js";
+export * from "./image/processImages.js";
+export * from "./image/ProcessImagesOptions.js";
+export * from "./image/supportedSourceExtensions.js";
+export * from "./image/TransformSpec.js";
+export * from "./list/AssetListTypes.js";
+export * from "./list/generateImageList.js";
+export * from "./list/generateVideoList.js";
+export * from "./assetsOptimize.js";
+export * from "./rclone/bisync.js";
+export * from "./rclone/runRclone.js";
+export * from "./shared/listLocalFiles.js";
+export * from "./shared/printSummary.js";
+export * from "./shared/walkFiles.js";
+export * from "./video/createVideoPreviewPath.js";
+export * from "./video/ensureVideoPreviews.js";
+export * from "./video/processVideos.js";
+export * from "./video/ProcessVideosOptions.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,2BAA2B,CAAA;AACzC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,2BAA2B,CAAA;AACzC,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA;AACtC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,yBAAyB,CAAA;AACvC,cAAc,0BAA0B,CAAA;AACxC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sCAAsC,CAAA;AACpD,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AACxC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,0BAA0B,CAAA;AACxC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mCAAmC,CAAA;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,0BAA0B,CAAA;AACxC,cAAc,iCAAiC,CAAA"}

package/dist/index.js

@@ -0,0 +1,26 @@
+export * from "./AssetsOptimizeOptions.js";
+export * from "./AssetsOptimizeResult.js";
+export * from "./image/buildExpectedImages.js";
+export * from "./image/createOutputHash.js";
+export * from "./image/defaultQuality.js";
+export * from "./image/ExpectedImage.js";
+export * from "./image/ImageFormat.js";
+export * from "./image/parseTransformSpec.js";
+export * from "./image/processImage.js";
+export * from "./image/processImages.js";
+export * from "./image/ProcessImagesOptions.js";
+export * from "./image/supportedSourceExtensions.js";
+export * from "./image/TransformSpec.js";
+export * from "./list/AssetListTypes.js";
+export * from "./list/generateImageList.js";
+export * from "./list/generateVideoList.js";
+export * from "./assetsOptimize.js";
+export * from "./rclone/bisync.js";
+export * from "./rclone/runRclone.js";
+export * from "./shared/listLocalFiles.js";
+export * from "./shared/printSummary.js";
+export * from "./shared/walkFiles.js";
+export * from "./video/createVideoPreviewPath.js";
+export * from "./video/ensureVideoPreviews.js";
+export * from "./video/processVideos.js";
+export * from "./video/ProcessVideosOptions.js";

package/dist/list/AssetListTypes.d.ts

@@ -0,0 +1,13 @@
+export interface ImageType {
+    path: string;
+    width: number;
+    height: number;
+    alt: string;
+    mimeType?: string;
+}
+export interface VideoType {
+    path: string;
+    mimeType?: string;
+    image: ImageType;
+}
+//# sourceMappingURL=AssetListTypes.d.ts.map

package/dist/list/AssetListTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssetListTypes.d.ts","sourceRoot":"","sources":["../../src/list/AssetListTypes.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,SAAS,CAAA;CACjB"}

package/dist/list/AssetListTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/list/formatGeneratedCodeFile.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from "../shared/logger.js";
+export declare function formatGeneratedCodeFile(outputPath: string, logger?: Logger): Promise<void>;
+//# sourceMappingURL=formatGeneratedCodeFile.d.ts.map

package/dist/list/formatGeneratedCodeFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatGeneratedCodeFile.d.ts","sourceRoot":"","sources":["../../src/list/formatGeneratedCodeFile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,wBAAsB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiChG"}

package/dist/list/formatGeneratedCodeFile.js

@@ -0,0 +1,32 @@
+export async function formatGeneratedCodeFile(outputPath, logger) {
+    const command = ["bunx", "biome", "check", "--write", outputPath];
+    logger?.cli(command.join(" "));
+    const process = Bun.spawn(command, {
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const exitCode = await process.exited;
+    if (exitCode !== 0) {
+        const stderr = await new Response(process.stderr).text();
+        const message = `Failed to format generated file ${outputPath}: ${stderr}`;
+        if (logger) {
+            logger.warn(message);
+        }
+        else {
+            console.warn(message);
+        }
+        return;
+    }
+    if (logger?.isEnabled(3)) {
+        const [stdout, stderr] = await Promise.all([
+            new Response(process.stdout).text(),
+            new Response(process.stderr).text(),
+        ]);
+        if (stdout.trim()) {
+            logger.verbose(stdout.trim());
+        }
+        if (stderr.trim()) {
+            logger.verbose(stderr.trim());
+        }
+    }
+}

package/dist/list/generateImageList.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from "../shared/logger.js";
+export declare function generateImageList(imageDirectory: string, outputPath: string, imageTypeImportPath?: string, logger?: Logger): Promise<void>;
+//# sourceMappingURL=generateImageList.d.ts.map

package/dist/list/generateImageList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateImageList.d.ts","sourceRoot":"","sources":["../../src/list/generateImageList.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAUjD,wBAAsB,iBAAiB,CACrC,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,EAClB,mBAAmB,CAAC,EAAE,MAAM,EAC5B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAWf"}

package/dist/list/generateImageList.js

@@ -0,0 +1,85 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { imageSize } from "image-size";
+import { getOwnPackageName } from "../shared/getOwnPackageName.js";
+import { walkFiles } from "../shared/walkFiles.js";
+import { formatGeneratedCodeFile } from "./formatGeneratedCodeFile.js";
+import { getAssetKey } from "./getAssetKey.js";
+import { loadExistingAssetList } from "./loadExistingAssetList.js";
+import { sortAssetMap } from "./sortAssetMap.js";
+const IMAGE_EXTENSIONS = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".avif", ".tiff", ".svg"]);
+export async function generateImageList(imageDirectory, outputPath, imageTypeImportPath, logger) {
+    const resolvedImageTypeImportPath = imageTypeImportPath ?? (await getOwnPackageName(import.meta.url));
+    const existingImages = await loadExistingAssetList(outputPath, "imageList");
+    const imageMap = await processImageFiles(imageDirectory, existingImages, logger);
+    const sorted = sortAssetMap(imageMap);
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await Bun.write(outputPath, createGeneratedImageListContent(sorted, resolvedImageTypeImportPath));
+    await formatGeneratedCodeFile(outputPath, logger);
+    logger?.files(`generated image list: ${outputPath}`);
+    logger?.summary(`Generated ${Object.keys(sorted).length} images to ${outputPath}`);
+}
+async function processImageFiles(directory, existingImages, logger) {
+    const imageMap = {};
+    for (const filePath of await walkFiles(directory)) {
+        const extension = path.extname(filePath).toLowerCase();
+        if (!IMAGE_EXTENSIONS.has(extension)) {
+            continue;
+        }
+        try {
+            const buffer = await fs.readFile(filePath);
+            const dimensions = imageSize(buffer);
+            if (!dimensions.width || !dimensions.height) {
+                continue;
+            }
+            const relativePath = path.relative(directory, filePath);
+            const key = normalizeGeneratedImageKey(getAssetKey(filePath));
+            const fileName = path.basename(filePath, extension);
+            imageMap[key] = {
+                path: relativePath,
+                width: dimensions.width,
+                height: dimensions.height,
+                alt: existingImages[key]?.alt || formatGeneratedImageAlt(fileName),
+                mimeType: getImageMimeType(extension),
+            };
+        }
+        catch (error) {
+            logger?.error(`Error processing ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return imageMap;
+}
+function normalizeGeneratedImageKey(key) {
+    return key.replace(/_[0-9a-f]{8}$/i, "");
+}
+function formatGeneratedImageAlt(fileName) {
+    return normalizeGeneratedImageKey(fileName).replace(/[-_]/g, " ");
+}
+function createGeneratedImageListContent(imageMap, imageTypeImportPath) {
+    return `import type { ImageType } from "${imageTypeImportPath}"
+
+// Auto-generated, manual changes will be lost, generated by optimizeAssets from @adaptive-ds/assets-optimizer
+export const imageList = ${JSON.stringify(imageMap, null, 2)} as const satisfies Record<string, ImageType>
+`;
+}
+function getImageMimeType(extension) {
+    switch (extension) {
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".png":
+            return "image/png";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        case ".avif":
+            return "image/avif";
+        case ".tiff":
+            return "image/tiff";
+        case ".svg":
+            return "image/svg+xml";
+        default:
+            return "application/octet-stream";
+    }
+}

package/dist/list/generateVideoList.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from "../shared/logger.js";
+export declare function generateVideoList(videosDirectory: string, outputPath: string, videoTypeImportPath?: string, logger?: Logger): Promise<void>;
+//# sourceMappingURL=generateVideoList.d.ts.map

package/dist/list/generateVideoList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateVideoList.d.ts","sourceRoot":"","sources":["../../src/list/generateVideoList.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAUjD,wBAAsB,iBAAiB,CACrC,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,mBAAmB,CAAC,EAAE,MAAM,EAC5B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/dist/list/generateVideoList.js

@@ -0,0 +1,87 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { imageSize } from "image-size";
+import { getOwnPackageName } from "../shared/getOwnPackageName.js";
+import { isMissingDirError } from "../shared/isMissingDirError.js";
+import { walkFiles } from "../shared/walkFiles.js";
+import { createVideoPreviewPath } from "../video/createVideoPreviewPath.js";
+import { supportedVideoSourceExtensions } from "../video/supportedVideoSourceExtensions.js";
+import { formatGeneratedCodeFile } from "./formatGeneratedCodeFile.js";
+import { getAssetKey } from "./getAssetKey.js";
+import { loadExistingAssetList } from "./loadExistingAssetList.js";
+import { sortAssetMap } from "./sortAssetMap.js";
+export async function generateVideoList(videosDirectory, outputPath, videoTypeImportPath, logger) {
+    const resolvedVideoTypeImportPath = videoTypeImportPath ?? (await getOwnPackageName(import.meta.url));
+    const existingVideos = await loadExistingAssetList(outputPath, "videoList");
+    const videoMap = sortAssetMap(await processVideoFiles(videosDirectory, existingVideos));
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await Bun.write(outputPath, createGeneratedVideoListContent(videoMap, resolvedVideoTypeImportPath));
+    await formatGeneratedCodeFile(outputPath, logger);
+    logger?.files(`generated video list: ${outputPath}`);
+    logger?.summary(`Generated ${Object.keys(videoMap).length} videos to ${outputPath}`);
+}
+async function processVideoFiles(directory, existingVideos) {
+    const videoMap = {};
+    let filePaths;
+    try {
+        filePaths = await walkFiles(directory);
+    }
+    catch (error) {
+        if (isMissingDirError(error)) {
+            return videoMap;
+        }
+        throw error;
+    }
+    for (const filePath of filePaths) {
+        const extension = path.extname(filePath).toLowerCase();
+        if (!supportedVideoSourceExtensions.has(extension)) {
+            continue;
+        }
+        const relativePath = path.relative(directory, filePath);
+        const key = getAssetKey(filePath);
+        const previewPath = createVideoPreviewPath(filePath);
+        const previewBuffer = await fs.readFile(previewPath);
+        const previewDimensions = imageSize(previewBuffer);
+        if (!previewDimensions.width || !previewDimensions.height) {
+            continue;
+        }
+        const fileName = path.basename(filePath, extension);
+        const existingPreview = existingVideos[key]?.image;
+        videoMap[key] = {
+            path: relativePath,
+            mimeType: getVideoMimeType(extension),
+            image: {
+                path: path.relative(directory, previewPath),
+                width: previewDimensions.width,
+                height: previewDimensions.height,
+                alt: existingPreview?.alt || fileName.replace(/[-_]/g, " "),
+                mimeType: "image/jpeg",
+            },
+        };
+    }
+    return videoMap;
+}
+function createGeneratedVideoListContent(videoMap, videoTypeImportPath) {
+    return `import type { VideoType } from "${videoTypeImportPath}"
+
+// Auto-generated, manual changes will be lost, generated by optimizeAssets from @adaptive-ds/assets-optimizer
+export const videoList = ${JSON.stringify(videoMap, null, 2)} as const satisfies Record<string, VideoType>
+`;
+}
+function getVideoMimeType(extension) {
+    switch (extension) {
+        case ".mp4":
+        case ".m4v":
+            return "video/mp4";
+        case ".mov":
+            return "video/quicktime";
+        case ".webm":
+            return "video/webm";
+        case ".avi":
+            return "video/x-msvideo";
+        case ".mkv":
+            return "video/x-matroska";
+        default:
+            return "application/octet-stream";
+    }
+}

package/dist/list/getAssetKey.d.ts

@@ -0,0 +1,2 @@
+export declare function getAssetKey(filePath: string): string;
+//# sourceMappingURL=getAssetKey.d.ts.map

package/dist/list/getAssetKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAssetKey.d.ts","sourceRoot":"","sources":["../../src/list/getAssetKey.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAUpD"}

package/dist/list/getAssetKey.js

@@ -0,0 +1,10 @@
+import path from "node:path";
+export function getAssetKey(filePath) {
+    const extension = path.extname(filePath);
+    const fileName = path.basename(filePath, extension);
+    let key = fileName.replace(/-/g, "_");
+    if (/^\d/.test(key)) {
+        key = `i${key}`;
+    }
+    return key;
+}

package/dist/list/loadExistingAssetList.d.ts

@@ -0,0 +1,2 @@
+export declare function loadExistingAssetList<T>(filePath: string, exportName: string): Promise<Record<string, T>>;
+//# sourceMappingURL=loadExistingAssetList.d.ts.map

package/dist/list/loadExistingAssetList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadExistingAssetList.d.ts","sourceRoot":"","sources":["../../src/list/loadExistingAssetList.ts"],"names":[],"mappings":"AAGA,wBAAsB,qBAAqB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAgB/G"}

package/dist/list/loadExistingAssetList.js

@@ -0,0 +1,23 @@
+import fs from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+export async function loadExistingAssetList(filePath, exportName) {
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        return {};
+    }
+    try {
+        const moduleUrl = `${pathToFileURL(filePath).href}?t=${Date.now()}`;
+        const existingModule = (await import(moduleUrl));
+        const existingList = existingModule[exportName];
+        return isRecord(existingList) ? existingList : {};
+    }
+    catch (error) {
+        console.warn(`Failed to load existing ${exportName} from ${filePath}:`, error);
+        return {};
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/list/sortAssetMap.d.ts

@@ -0,0 +1,2 @@
+export declare function sortAssetMap<T>(assetMap: Record<string, T>): Record<string, T>;
+//# sourceMappingURL=sortAssetMap.d.ts.map

package/dist/list/sortAssetMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortAssetMap.d.ts","sourceRoot":"","sources":["../../src/list/sortAssetMap.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAU9E"}

package/dist/list/sortAssetMap.js

@@ -0,0 +1,8 @@
+export function sortAssetMap(assetMap) {
+    return Object.keys(assetMap)
+        .sort()
+        .reduce((sorted, key) => {
+        sorted[key] = assetMap[key];
+        return sorted;
+    }, {});
+}

package/dist/rclone/bisync.d.ts

@@ -0,0 +1,9 @@
+export interface BisyncOptions {
+    cwd?: string;
+    resync?: boolean;
+}
+/**
+ * https://rclone.org/bisync/#limitations
+ */
+export declare function bisync(localPath: string, remotePath: string, options?: BisyncOptions): Promise<void>;
+//# sourceMappingURL=bisync.d.ts.map

package/dist/rclone/bisync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bisync.d.ts","sourceRoot":"","sources":["../../src/rclone/bisync.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED;;GAEG;AACH,wBAAsB,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAa9G"}

package/dist/rclone/bisync.js

@@ -0,0 +1,17 @@
+import fs from "node:fs/promises";
+import { dirExists } from "../shared/dirExists.js";
+import { runRclone } from "./runRclone.js";
+/**
+ * https://rclone.org/bisync/#limitations
+ */
+export async function bisync(localPath, remotePath, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const localDirExists = await dirExists(localPath);
+    await fs.mkdir(localPath, { recursive: true });
+    await runRclone(["mkdir", remotePath], cwd);
+    const args = ["bisync", localPath, remotePath, "--create-empty-src-dirs", "--resilient", "--recover"];
+    if (options.resync === true || !localDirExists) {
+        args.push("--resync");
+    }
+    await runRclone(args, cwd);
+}

package/dist/rclone/runRclone.d.ts

@@ -0,0 +1,2 @@
+export declare function runRclone(args: string[], cwd?: string): Promise<void>;
+//# sourceMappingURL=runRclone.d.ts.map

package/dist/rclone/runRclone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runRclone.d.ts","sourceRoot":"","sources":["../../src/rclone/runRclone.ts"],"names":[],"mappings":"AAAA,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,SAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAclF"}

package/dist/rclone/runRclone.js

@@ -0,0 +1,13 @@
+export async function runRclone(args, cwd = process.cwd()) {
+    const command = ["rclone", ...args];
+    console.log(command.join(" "));
+    const proc = Bun.spawn(command, {
+        cwd,
+        stdout: "inherit",
+        stderr: "inherit",
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+        throw new Error(`rclone ${args.join(" ")} failed with exit code ${exitCode}`);
+    }
+}

package/dist/shared/assertNever.d.ts

@@ -0,0 +1,2 @@
+export declare function assertNever(value: never): never;
+//# sourceMappingURL=assertNever.d.ts.map

package/dist/shared/assertNever.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertNever.d.ts","sourceRoot":"","sources":["../../src/shared/assertNever.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAE/C"}

package/dist/shared/assertNever.js

@@ -0,0 +1,3 @@
+export function assertNever(value) {
+    throw new Error(`Unhandled value: ${String(value)}`);
+}

package/dist/shared/dirExists.d.ts

@@ -0,0 +1,2 @@
+export declare function dirExists(dir: string): Promise<boolean>;
+//# sourceMappingURL=dirExists.d.ts.map

package/dist/shared/dirExists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dirExists.d.ts","sourceRoot":"","sources":["../../src/shared/dirExists.ts"],"names":[],"mappings":"AAEA,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO7D"}

package/dist/shared/dirExists.js

@@ -0,0 +1,10 @@
+import fs from "node:fs/promises";
+export async function dirExists(dir) {
+    try {
+        const stat = await fs.stat(dir);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/shared/getOwnPackageName.d.ts

@@ -0,0 +1,2 @@
+export declare function getOwnPackageName(moduleUrl: string): Promise<string>;
+//# sourceMappingURL=getOwnPackageName.d.ts.map

package/dist/shared/getOwnPackageName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOwnPackageName.d.ts","sourceRoot":"","sources":["../../src/shared/getOwnPackageName.ts"],"names":[],"mappings":"AAIA,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAoB1E"}