cloudflare-next-intl 0.13.5 → 0.14.0

package/README.md

@@ -282,7 +282,7 @@ export default defineConfig({
 
    Being text-only and transitive, it can over-flag: any local file the page reaches — however many imports away — that merely *calls* a recognized signal counts, even along a branch that never runs in production (a `Config.isDev`-gated `fetch(..., { cache: "no-store" })`) or one that's optional/best-effort (a `try`/`catch`-wrapped `getAuthUser()` used only to tag a log line). It cannot see that a call is conditional or swallowed. For a page whose only reason for being flagged is that kind of optional read — attaching "whoever's signed in, if anyone" to an error report, analytics event, or log line — switch that read to `resolveOptionalAuthUser()` (`cloudflare-next-intl/resolveOptionalAuthUser`, see Firebase Auth below): it wraps `getAuthUser()` the same way but, being an npm-package import, is a boundary the scan doesn't open, so it contributes no signal. If that read lives in a shared `onError` sink used by many pages at once, `resolveErrorReportingUser(useAuthUser?)` (same subpath) is the more precise fix: it's off (`{ user: null }`, no `getAuthUser()` call) by default, and only a `reportError({ ..., useAuthUser: true })` call site that actually wants the user on that report opts in per-call — instead of every page reaching that sink getting flagged.
 2. **Auto Locale Params for Static Pages (`autoLocaleParams`)**: Automatically scans `page`/`layout`/`loading` files under a `[locale]`-scoped route during `configResolved` and inserts the `locale` param from `params` plus a `setLocale(locale)` call wherever `getTranslations()`/`useTranslations()` is used without one — the common cause of a page reading `NEXT_LOCALE` from cookies (and so implicitly becoming request-dependent) even though it never calls `cookies()` itself. Runs before `autoDynamicPages` so a page fixed this way no longer trips the cookie-derived-locale signal below. The scan (`checkLocaleParams`, also usable standalone from `cloudflare-next-intl/checkLocaleParams`, or via the `cfni-check-locale-params` CLI bin) is a text heuristic like `checkDynamicPages`; pass `mode: "report"` to only log without editing files, or `skip`/`overrides`/`localeParam` to fine-tune per-file.
-4. **Build-Time Image Optimizer (`imageOptimizer`)**: Automatically scans your image directories (`public/images`, `public/icons`), downscales oversized assets, produces sibling formats (`webp` by default; also supports `avif`, `png`, `jpeg`, `gif`, `tiff`, `heif`, `jp2`, `jxl`), generates 8px `.blur.webp` thumbnails with Next.js-matching SVG Gaussian blur placeholders, and provides transparent `<Image placeholder="blur" />` shimming via virtual modules. When more than one format is generated for an image, the shim renders a `<picture>` with one `<source>` per format — ordered exactly as configured — so the browser picks the best format it supports, with the original untouched file as an `onError` fallback if a generated asset fails to load. When the same image is used at different widths across the codebase, each size gets its own generated variant, and each `<Image>` usage automatically resolves to the closest matching size. Remote, `data:` and `blob:` srcs (e.g. upload previews) are never matched against the manifest and pass through untouched. An auto-detected image loader is applied on the client, so `<Image>` stays safe in Server Components; a loader that throws falls back to the original `src`. Runs on production build only by default (`dev: false`) — downscaling/format conversion is a build concern, and re-scanning on every dev server start slows cold starts for no dev-time benefit; the shim degrades cleanly with no manifest (plain, unoptimized `next/image` rendering, no blur placeholder). Pass `dev: true` to also run it in dev and preview real optimized output/blur.
+4. **Build-Time Image Optimizer (`imageOptimizer`)**: Automatically scans your image directories (`public/images`, `public/icons`), downscales oversized assets, produces sibling formats (`webp` by default; also supports `avif`, `png`, `jpeg`, `gif`, `tiff`, `heif`, `jp2`, `jxl`), generates 8px `.blur.webp` thumbnails with Next.js-matching SVG Gaussian blur placeholders, and provides transparent `<Image placeholder="blur" />` shimming via virtual modules. Automatically prunes unoptimized original images from final build output (`pruneOriginalsFromBuild: true` by default) when replaced by optimized assets, while preserving images used in unoptimized contexts (raw `<img>`, CSS, schema). Also rewrites Next.js metadata image URLs (`openGraph`, `twitter`, `icons`) to point to optimized assets (`optimizeMetadata: true` by default). When more than one format is generated for an image, the shim renders a `<picture>` with one `<source>` per format — ordered exactly as configured — so the browser picks the best format it supports, with the original untouched file as an `onError` fallback if a generated asset fails to load. When the same image is used at different widths across the codebase, each size gets its own generated variant, and each `<Image>` usage automatically resolves to the closest matching size. Remote, `data:` and `blob:` srcs (e.g. upload previews) are never matched against the manifest and pass through untouched. An auto-detected image loader is applied on the client, so `<Image>` stays safe in Server Components; a loader that throws falls back to the original `src`. Runs on production build only by default (`dev: false`) — downscaling/format conversion is a build concern, and re-scanning on every dev server start slows cold starts for no dev-time benefit; the shim degrades cleanly with no manifest (plain, unoptimized `next/image` rendering, no blur placeholder). Pass `dev: true` to also run it in dev and preview real optimized output/blur.
 5. **Locale File Bundling & Resolution (`localeFiles`)**: Resolves `@locale-file/*` to your `./messages` directory and transforms dynamic imports into `import.meta.glob('/messages/*.json', { eager: true })` for lightning-fast locale loading on Cloudflare Workers.
 6. **User-Agent Stub (`userAgentStub`)**: Prevents Next.js `user-agent` from importing `node:fs` during workerd runtime execution (which otherwise causes runtime 404 / 500 crashes in Workers proxy/middleware).
 7. **Cloudflare Workers Client Stub (`cfWorkersClientStub`)**: Stubs `cloudflare:workers` in client builds so shared modules can be referenced without client bundling errors.
@@ -314,6 +314,8 @@ export default defineConfig({
                 overrides: {                      // Per-image overrides keyed by public src path (wins over scanned <Image> props)
                     "/images/hero.png": { maxWidth: false, formats: ["webp"], blur: { quality: 80 } },
                 },
+                optimizeMetadata: true,           // Optimize images in Next.js metadata (OG, twitter, icons) & rewrite URLs (default: true)
+                pruneOriginalsFromBuild: true,    // Prune unoptimized originals from build output when replaced (default: true)
                 autoImageLoader: true,            // Auto-detect custom image loader for standalone imageOptimizer usages (default: true, or false/options)
             },
             autoImageLoader: true,                // Auto-detect custom image loader (from next.config.* loaderFile or image-loader.ts; default: true, or options object)

package/dist/src/image_optimizer/index.d.ts

@@ -4,7 +4,9 @@ export { processImage, makeBlurDataURL, toGeneratedPath, toPublicSrc, } from "./
 export { renderManifest, writeManifest, } from "./manifest.js";
 export { isFresh, loadCache, saveCache, type CacheEntry, type CacheData, } from "./cache.js";
 export { collectImages, run, } from "./run.js";
-export { collectUsedImages, findCodeFiles, extractImageReferences, CODE_EXTENSIONS, IGNORED_DIRS, } from "./scan_used.js";
+export { collectUsedImages, findCodeFiles, extractImageReferences, extractImageOverrides, extractImageUsageDetails, classifyImageUsages, getPrunableOriginalPaths, CODE_EXTENSIONS, ASSET_EXTENSIONS, SCANNED_EXTENSIONS, IGNORED_DIRS, IGNORED_FILES, type ImageUsageDetails, type ImageUsageClassification, } from "./scan_used.js";
+export { transformMetadataImageUrls, getMetadataRanges, findBalancedBraces, } from "./metadata_transform.js";
+export { pruneBuildOutput, type PruneResult, } from "./prune_build.js";
 export { getImageBlurSvg, } from "./blur_svg.js";
 export { type ManifestEntry, } from "./next_image_shim.js";
 export { VIRTUAL_IMAGE_LOADER_ID, RESOLVED_IMAGE_LOADER_ID, type AutoImageLoaderOptions, type DetectedImageLoader, findLoaderFileFromNextConfig, findExportedLoaderName, detectImageLoader, generateLoaderVirtualModule, } from "./detect_loader.js";

package/dist/src/image_optimizer/index.js

@@ -4,6 +4,8 @@ export { processImage, makeBlurDataURL, toGeneratedPath, toPublicSrc, } from "./
 export { renderManifest, writeManifest, } from "./manifest.js";
 export { isFresh, loadCache, saveCache, } from "./cache.js";
 export { collectImages, run, } from "./run.js";
-export { collectUsedImages, findCodeFiles, extractImageReferences, CODE_EXTENSIONS, IGNORED_DIRS, } from "./scan_used.js";
+export { collectUsedImages, findCodeFiles, extractImageReferences, extractImageOverrides, extractImageUsageDetails, classifyImageUsages, getPrunableOriginalPaths, CODE_EXTENSIONS, ASSET_EXTENSIONS, SCANNED_EXTENSIONS, IGNORED_DIRS, IGNORED_FILES, } from "./scan_used.js";
+export { transformMetadataImageUrls, getMetadataRanges, findBalancedBraces, } from "./metadata_transform.js";
+export { pruneBuildOutput, } from "./prune_build.js";
 export { getImageBlurSvg, } from "./blur_svg.js";
 export { VIRTUAL_IMAGE_LOADER_ID, RESOLVED_IMAGE_LOADER_ID, findLoaderFileFromNextConfig, findExportedLoaderName, detectImageLoader, generateLoaderVirtualModule, } from "./detect_loader.js";

package/dist/src/image_optimizer/metadata_transform.d.ts

@@ -0,0 +1,8 @@
+export declare function findBalancedBraces(code: string, openIndex: number): number;
+export declare function getMetadataRanges(code: string): {
+    start: number;
+    end: number;
+}[];
+export declare function transformMetadataImageUrls(code: string, manifestImages: Record<string, {
+    src: string;
+}>): string | undefined;

package/dist/src/image_optimizer/metadata_transform.js

@@ -0,0 +1,123 @@
+export function findBalancedBraces(code, openIndex) {
+    if (code[openIndex] !== "{")
+        return -1;
+    let depth = 0;
+    let inString = null;
+    let inComment = null;
+    for (let i = openIndex; i < code.length; i++) {
+        const char = code[i];
+        const next = code[i + 1];
+        if (inComment === "line") {
+            if (char === "\n")
+                inComment = null;
+            continue;
+        }
+        if (inComment === "block") {
+            if (char === "*" && next === "/") {
+                inComment = null;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            if (char === "\\") {
+                i++;
+            }
+            else if (char === inString) {
+                inString = null;
+            }
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            inComment = "line";
+            i++;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inComment = "block";
+            i++;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            inString = char;
+            continue;
+        }
+        if (char === "{") {
+            depth++;
+        }
+        else if (char === "}") {
+            depth--;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+export function getMetadataRanges(code) {
+    const ranges = [];
+    const metadataDeclPattern = /\bmetadata\s*(?::\s*[A-Za-z0-9_$.<>[\]\s]+)?\s*=\s*\{/g;
+    let match;
+    while ((match = metadataDeclPattern.exec(code)) !== null) {
+        const openIndex = match.index + match[0].length - 1;
+        const closeIndex = findBalancedBraces(code, openIndex);
+        if (closeIndex !== -1) {
+            ranges.push({ start: openIndex, end: closeIndex });
+        }
+    }
+    const genMetadataPattern = /(?:async\s+)?function\s+generateMetadata\b[^{]*\{/g;
+    while ((match = genMetadataPattern.exec(code)) !== null) {
+        const openIndex = match.index + match[0].length - 1;
+        const closeIndex = findBalancedBraces(code, openIndex);
+        if (closeIndex !== -1) {
+            ranges.push({ start: openIndex, end: closeIndex });
+        }
+    }
+    const propPattern = /\b(openGraph|twitter|icons)\s*:\s*\{/g;
+    while ((match = propPattern.exec(code)) !== null) {
+        const openIndex = match.index + match[0].length - 1;
+        const insideExisting = ranges.some((r) => openIndex >= r.start && openIndex <= r.end);
+        if (!insideExisting) {
+            const closeIndex = findBalancedBraces(code, openIndex);
+            if (closeIndex !== -1) {
+                ranges.push({ start: openIndex, end: closeIndex });
+            }
+        }
+    }
+    return ranges;
+}
+function normalizeSrcKey(src) {
+    const clean = src.split("?")[0].split("#")[0];
+    return clean.startsWith("/") ? clean : `/${clean}`;
+}
+export function transformMetadataImageUrls(code, manifestImages) {
+    if (Object.keys(manifestImages).length === 0)
+        return undefined;
+    if (!/\b(metadata|generateMetadata|openGraph|twitter|icons)\b/.test(code)) {
+        return undefined;
+    }
+    const ranges = getMetadataRanges(code);
+    if (ranges.length === 0)
+        return undefined;
+    let modified = false;
+    let result = "";
+    let lastIndex = 0;
+    ranges.sort((a, b) => a.start - b.start);
+    for (const range of ranges) {
+        result += code.slice(lastIndex, range.start);
+        const block = code.slice(range.start, range.end + 1);
+        const transformedBlock = block.replace(/(["'`])([^"'`\s\n\r#?]+\.(?:png|jpg|jpeg|webp|avif))(?:\?[^"'`\s]*)?(?:#[^"'`\s]*)?\1/gi, (fullMatch, quote, rawPath) => {
+            const key = normalizeSrcKey(rawPath);
+            const entry = manifestImages[key];
+            if (entry && entry.src) {
+                modified = true;
+                return `${quote}${entry.src}${quote}`;
+            }
+            return fullMatch;
+        });
+        result += transformedBlock;
+        lastIndex = range.end + 1;
+    }
+    result += code.slice(lastIndex);
+    return modified ? result : undefined;
+}

package/dist/src/image_optimizer/next_image_client.d.ts

@@ -5,6 +5,7 @@ type Loader = (props: {
     width: number;
     quality?: number;
 }) => string;
+export declare function preloadLoader(): Promise<void>;
 export declare function safeLoader(loader: Loader): Loader;
 export declare function NextImageClient(props: ImageProps): React.JSX.Element;
 export {};

package/dist/src/image_optimizer/next_image_client.js

@@ -2,13 +2,22 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import NextImage from "next/image.js";
 let defaultCustomLoader;
-try {
-    const loaderMod = (await import("virtual:cloudflare-next-intl-image-loader"));
-    const candidate = loaderMod.defaultLoader ?? loaderMod.default;
-    defaultCustomLoader = typeof candidate === "function" ? candidate : undefined;
+let loaderInitPromise;
+function ensureLoader() {
+    if (!loaderInitPromise) {
+        loaderInitPromise = import("virtual:cloudflare-next-intl-image-loader")
+            .then((mod) => {
+            const loaderMod = mod;
+            const candidate = loaderMod?.defaultLoader ?? loaderMod?.default;
+            defaultCustomLoader = typeof candidate === "function" ? candidate : undefined;
+        })
+            .catch(() => undefined);
+    }
+    return loaderInitPromise;
 }
-catch {
-    defaultCustomLoader = undefined;
+ensureLoader();
+export async function preloadLoader() {
+    await ensureLoader();
 }
 export function safeLoader(loader) {
     return (params) => {
@@ -23,8 +32,8 @@ export function safeLoader(loader) {
         return params.src;
     };
 }
-const safeDefaultLoader = defaultCustomLoader ? safeLoader(defaultCustomLoader) : undefined;
 export function NextImageClient(props) {
-    const loader = typeof props.loader === "function" ? safeLoader(props.loader) : safeDefaultLoader;
+    const loaderCandidate = typeof props.loader === "function" ? props.loader : defaultCustomLoader;
+    const loader = typeof loaderCandidate === "function" ? safeLoader(loaderCandidate) : undefined;
     return _jsx(NextImage, { ...props, loader: loader });
 }

package/dist/src/image_optimizer/plugin.js

@@ -4,9 +4,14 @@ import { fileURLToPath } from "node:url";
 import { run } from "./run.js";
 import { resolveOptions } from "./types.js";
 import { VIRTUAL_IMAGE_LOADER_ID, RESOLVED_IMAGE_LOADER_ID, detectImageLoader, generateLoaderVirtualModule, } from "./detect_loader.js";
+import { transformMetadataImageUrls } from "./metadata_transform.js";
+import { pruneBuildOutput } from "./prune_build.js";
+import { classifyImageUsages, getPrunableOriginalPaths } from "./scan_used.js";
 export const VIRTUAL_IMAGE_SHIM_ID = "virtual:cloudflare-next-intl-image";
 export const VIRTUAL_MANIFEST_ID = "virtual:cloudflare-next-intl-images-manifest";
 const RESOLVED_MANIFEST_ID = "\0" + VIRTUAL_MANIFEST_ID;
+const sharedPrunableByRoot = new Map();
+const sharedManifestByRoot = new Map();
 export function getShimPath(dir = path.dirname(fileURLToPath(import.meta.url))) {
     const jsPath = path.join(dir, "next_image_shim.js");
     if (existsSync(jsPath))
@@ -16,10 +21,12 @@ export function getShimPath(dir = path.dirname(fileURLToPath(import.meta.url)))
 export function imageOptimizerPlugin(options) {
     const resolved = resolveOptions(options);
     let command = "build";
+    let viteConfig;
     return {
         name: "cloudflare-next-intl-image-optimizer",
         enforce: "pre",
         configResolved(config) {
+            viteConfig = config;
             command = config.command === "serve" ? "serve" : "build";
         },
         resolveId(id) {
@@ -60,20 +67,78 @@ export function imageOptimizerPlugin(options) {
                 return undefined;
             if (id === getShimPath())
                 return undefined;
-            if (!/from\s*["']next\/image["']/.test(code))
-                return undefined;
-            const next = code.replace(/(import\s+(?!type\s)[^;]*?from\s*)(["'])next\/image\2/g, `$1$2${VIRTUAL_IMAGE_SHIM_ID}$2`);
-            return next === code ? undefined : { code: next, map: null };
+            let transformedCode = code;
+            const root = process.cwd();
+            const activeManifest = sharedManifestByRoot.get(root);
+            if (command === "build" && resolved.optimizeMetadata && activeManifest && Object.keys(activeManifest).length > 0) {
+                const metaReplaced = transformMetadataImageUrls(transformedCode, activeManifest);
+                if (metaReplaced !== undefined) {
+                    transformedCode = metaReplaced;
+                }
+            }
+            if (/from\s*["']next\/image["']/.test(transformedCode)) {
+                transformedCode = transformedCode.replace(/(import\s+(?!type\s)[^;]*?from\s*)(["'])next\/image\2/g, `$1$2${VIRTUAL_IMAGE_SHIM_ID}$2`);
+            }
+            return transformedCode === code ? undefined : { code: transformedCode, map: null };
         },
         async buildStart() {
             if (!resolved.enabled)
                 return;
+            const root = process.cwd();
+            const manifestPath = path.resolve(root, resolved.manifest);
+            if (existsSync(manifestPath)) {
+                try {
+                    const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+                    if (parsed?.images && typeof parsed.images === "object") {
+                        sharedManifestByRoot.set(root, parsed.images);
+                    }
+                }
+                catch {
+                }
+            }
             if (command === "serve" && !resolved.dev)
                 return;
-            const root = process.cwd();
             const cacheFile = path.resolve(root, resolved.cacheDir, "manifest.json");
             const entries = await run(root, resolved, cacheFile);
+            const manifestImages = {};
+            for (const entry of entries) {
+                manifestImages[entry.originalSrc] = { src: entry.src };
+            }
+            sharedManifestByRoot.set(root, manifestImages);
             this.info?.(`[cloudflare-next-intl] image-optimizer: ${entries.length} images in ${resolved.manifest}`);
+            if (command === "build" && resolved.pruneOriginalsFromBuild) {
+                const classifications = await classifyImageUsages(root, "public");
+                const prunableOriginals = getPrunableOriginalPaths(classifications, manifestImages, resolved.optimizeMetadata);
+                sharedPrunableByRoot.set(root, prunableOriginals);
+            }
+        },
+        closeBundle() {
+            if (command !== "build" || !resolved.enabled || !resolved.pruneOriginalsFromBuild)
+                return;
+            const root = process.cwd();
+            const prunable = sharedPrunableByRoot.get(root);
+            if (!prunable || prunable.length === 0)
+                return;
+            const outDirs = new Set();
+            const clientDir = path.resolve(root, "dist/client");
+            if (existsSync(clientDir)) {
+                outDirs.add(clientDir);
+            }
+            if (viteConfig?.build?.outDir) {
+                const outDir = path.resolve(root, viteConfig.build.outDir);
+                if (!outDir.endsWith("server") && !outDir.endsWith("dist") && existsSync(outDir)) {
+                    outDirs.add(outDir);
+                }
+            }
+            if (outDirs.size === 0)
+                return;
+            const { prunedFiles, bytesSaved } = pruneBuildOutput(Array.from(outDirs), prunable);
+            if (prunedFiles.length > 0) {
+                const mb = (bytesSaved / (1024 * 1024)).toFixed(2);
+                const kb = (bytesSaved / 1024).toFixed(1);
+                const sizeStr = bytesSaved >= 1024 * 1024 ? `${mb} MB` : `${kb} kB`;
+                this.info?.(`[cloudflare-next-intl] image-optimizer: pruned ${prunedFiles.length} unoptimized images from build output (${sizeStr} saved)`);
+            }
         },
     };
 }

package/dist/src/image_optimizer/prune_build.d.ts

@@ -0,0 +1,5 @@
+export interface PruneResult {
+    prunedFiles: string[];
+    bytesSaved: number;
+}
+export declare function pruneBuildOutput(outDirs: string[], prunableRelativePaths: string[]): PruneResult;

package/dist/src/image_optimizer/prune_build.js

@@ -0,0 +1,36 @@
+import { existsSync, readdirSync, rmdirSync, statSync, unlinkSync } from "node:fs";
+import path from "node:path";
+export function pruneBuildOutput(outDirs, prunableRelativePaths) {
+    const prunedFiles = [];
+    let bytesSaved = 0;
+    for (const outDir of outDirs) {
+        if (!existsSync(outDir))
+            continue;
+        for (const relPath of prunableRelativePaths) {
+            const cleanRel = relPath.replace(/^\/+/, "");
+            const fullPath = path.resolve(outDir, cleanRel);
+            if (!fullPath.startsWith(outDir))
+                continue;
+            if (existsSync(fullPath)) {
+                const st = statSync(fullPath);
+                if (st.isFile()) {
+                    bytesSaved += st.size;
+                    unlinkSync(fullPath);
+                    prunedFiles.push(fullPath);
+                    let parent = path.dirname(fullPath);
+                    while (parent !== outDir && parent.startsWith(outDir)) {
+                        const remaining = readdirSync(parent);
+                        if (remaining.length === 0) {
+                            rmdirSync(parent);
+                            parent = path.dirname(parent);
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return { prunedFiles, bytesSaved };
+}

package/dist/src/image_optimizer/scan_used.d.ts

@@ -1,8 +1,27 @@
 import type { ImageOverrideOptions } from "./types.js";
 export declare const CODE_EXTENSIONS: readonly string[];
+export declare const ASSET_EXTENSIONS: readonly string[];
+export declare const SCANNED_EXTENSIONS: readonly string[];
 export declare const IGNORED_DIRS: ReadonlySet<string>;
-export declare function findCodeFiles(dir: string, found?: string[]): Promise<string[]>;
+export declare const IGNORED_FILES: ReadonlySet<string>;
+export declare function findCodeFiles(dir: string, found?: string[], extensions?: readonly string[]): Promise<string[]>;
 export declare function extractImageReferences(code: string): string[];
 export declare function extractImageOverrides(code: string): Record<string, ImageOverrideOptions>;
 export declare function collectUsedImageOverrides(root: string, publicDir?: string): Promise<Record<string, ImageOverrideOptions>>;
 export declare function collectUsedImages(root: string, publicDir?: string): Promise<string[]>;
+export interface ImageUsageDetails {
+    imageComponentRefs: Set<string>;
+    metadataRefs: Set<string>;
+    otherRefs: Set<string>;
+}
+export interface ImageUsageClassification {
+    canonicalSrc: string;
+    inImageComponent: boolean;
+    inMetadata: boolean;
+    inOtherPlace: boolean;
+}
+export declare function extractImageUsageDetails(code: string, filePath?: string): ImageUsageDetails;
+export declare function classifyImageUsages(root: string, publicDir?: string): Promise<Record<string, ImageUsageClassification>>;
+export declare function getPrunableOriginalPaths(classifications: Record<string, ImageUsageClassification>, manifestImages: Record<string, {
+    src: string;
+}>, optimizeMetadata: boolean): string[];

package/dist/src/image_optimizer/scan_used.js

@@ -1,5 +1,6 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
+import { getMetadataRanges } from "./metadata_transform.js";
 export const CODE_EXTENSIONS = [
     ".tsx",
     ".ts",
@@ -13,6 +14,18 @@ export const CODE_EXTENSIONS = [
     ".mdx",
     ".html",
 ];
+export const ASSET_EXTENSIONS = [
+    ".css",
+    ".scss",
+    ".sass",
+    ".less",
+    ".json",
+    ".md",
+];
+export const SCANNED_EXTENSIONS = [
+    ...CODE_EXTENSIONS,
+    ...ASSET_EXTENSIONS,
+];
 export const IGNORED_DIRS = new Set([
     "node_modules",
     ".git",
@@ -20,12 +33,38 @@ export const IGNORED_DIRS = new Set([
     ".vinext",
     "dist",
     "build",
+    "out",
+    "boundled",
+    "bundled",
+    ".wrangler",
+    ".open-next",
     "coverage",
     ".cache",
     ".skeleton-diff",
+    ".superpowers",
+    "scripts",
+    "tmp",
+    ".tmp_figma",
     "generated",
+    "docs",
+    ".agent",
+    ".claude",
+    "screens",
+    "e2e",
+    "test",
+    "tests",
+    ".husky",
+    ".github",
+]);
+export const IGNORED_FILES = new Set([
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "bun.lockb",
+    "shrinkwrap.yaml",
+    "images.json",
 ]);
-export async function findCodeFiles(dir, found = []) {
+export async function findCodeFiles(dir, found = [], extensions = CODE_EXTENSIONS) {
     let items;
     try {
         items = await readdir(dir, { withFileTypes: true });
@@ -36,11 +75,13 @@ export async function findCodeFiles(dir, found = []) {
     for (const item of items) {
         if (IGNORED_DIRS.has(item.name))
             continue;
+        if (IGNORED_FILES.has(item.name))
+            continue;
         const full = path.join(dir, item.name);
         if (item.isDirectory()) {
-            await findCodeFiles(full, found);
+            await findCodeFiles(full, found, extensions);
         }
-        else if (CODE_EXTENSIONS.includes(path.extname(item.name).toLowerCase())) {
+        else if (extensions.includes(path.extname(item.name).toLowerCase())) {
             found.push(full);
         }
     }
@@ -146,7 +187,7 @@ export function extractImageOverrides(code) {
     }
     return overrides;
 }
-async function collectCodeFiles(root, publicDir) {
+async function collectCodeFiles(root, publicDir, extensions = CODE_EXTENSIONS) {
     let rootItems;
     try {
         rootItems = await readdir(root, { withFileTypes: true });
@@ -158,13 +199,15 @@ async function collectCodeFiles(root, publicDir) {
     for (const item of rootItems) {
         if (IGNORED_DIRS.has(item.name))
             continue;
+        if (IGNORED_FILES.has(item.name))
+            continue;
         if (item.name === publicDir)
             continue;
         const full = path.join(root, item.name);
         if (item.isDirectory()) {
-            await findCodeFiles(full, codeFiles);
+            await findCodeFiles(full, codeFiles, extensions);
         }
-        else if (CODE_EXTENSIONS.includes(path.extname(item.name).toLowerCase())) {
+        else if (extensions.includes(path.extname(item.name).toLowerCase())) {
             codeFiles.push(full);
         }
     }
@@ -173,10 +216,13 @@ async function collectCodeFiles(root, publicDir) {
 function resolvePublicSrc(ref) {
     const cleanRef = ref.split("?")[0].split("#")[0];
     let relative = cleanRef;
-    if (relative.startsWith("/"))
+    const publicIdx = relative.indexOf("public/");
+    if (publicIdx !== -1) {
+        relative = relative.slice(publicIdx + "public/".length);
+    }
+    else if (relative.startsWith("/")) {
         relative = relative.slice(1);
-    if (relative.startsWith("public/"))
-        relative = relative.slice("public/".length);
+    }
     return `/${relative}`;
 }
 export async function collectUsedImageOverrides(root, publicDir = "public") {
@@ -207,10 +253,13 @@ export async function collectUsedImages(root, publicDir = "public") {
     for (const ref of referenced) {
         const cleanRef = ref.split("?")[0].split("#")[0];
         let relativeInPublic = cleanRef;
-        if (relativeInPublic.startsWith("/"))
+        const publicIdx = relativeInPublic.indexOf("public/");
+        if (publicIdx !== -1) {
+            relativeInPublic = relativeInPublic.slice(publicIdx + "public/".length);
+        }
+        else if (relativeInPublic.startsWith("/")) {
             relativeInPublic = relativeInPublic.slice(1);
-        if (relativeInPublic.startsWith("public/"))
-            relativeInPublic = relativeInPublic.slice("public/".length);
+        }
         const candidate = path.resolve(publicRoot, relativeInPublic);
         if (candidate.startsWith(publicRoot)) {
             resolvedFiles.add(candidate);
@@ -229,3 +278,135 @@ export async function collectUsedImages(root, publicDir = "public") {
     }
     return existing.sort();
 }
+export function extractImageUsageDetails(code, filePath) {
+    const imageComponentRefs = new Set();
+    const metadataRefs = new Set();
+    const otherRefs = new Set();
+    const ext = path.extname(filePath || "").toLowerCase();
+    const isNonCodeAsset = ASSET_EXTENSIONS.includes(ext);
+    if (isNonCodeAsset) {
+        for (const ref of extractImageReferences(code)) {
+            otherRefs.add(ref);
+        }
+        return { imageComponentRefs, metadataRefs, otherRefs };
+    }
+    const importRanges = [];
+    const importRegex = /(?:import\s+(?:type\s+)?[\w\s{},*]+\s+from\s*|require\s*\(\s*)["'`]([^"'`\s\n\r#?]+\.(?:png|jpg|jpeg|webp|avif))["'`]\)?/g;
+    let impMatch;
+    while ((impMatch = importRegex.exec(code)) !== null) {
+        importRanges.push({ start: impMatch.index, end: impMatch.index + impMatch[0].length });
+        imageComponentRefs.add(impMatch[1]);
+    }
+    const imageRanges = [];
+    const tagPattern = /<Image\b([^>]*)\/?>/gs;
+    let tagMatch;
+    while ((tagMatch = tagPattern.exec(code)) !== null) {
+        imageRanges.push({ start: tagMatch.index, end: tagMatch.index + tagMatch[0].length });
+        const attrs = tagMatch[1];
+        const literalMatch = attrs.match(/\bsrc\s*=\s*(?:["'`]([^"'`]+)["'`]|\{\s*["'`]([^"'`]+)["'`]\s*\})/);
+        if (literalMatch) {
+            const raw = literalMatch[1] ?? literalMatch[2];
+            if (raw)
+                imageComponentRefs.add(raw);
+        }
+        else {
+            const identMatch = attrs.match(/\bsrc\s*=\s*\{\s*([a-zA-Z0-9_$]+)\s*\}/);
+            if (identMatch) {
+                const varName = identMatch[1];
+                const declRegex = new RegExp(`(?:const|let|var)\\s+${varName}\\s*=\\s*["'\`]([^"'\`]+)["'\`]`, "g");
+                const declMatch = declRegex.exec(code);
+                const importRegex = new RegExp(`import\\s+${varName}\\s+from\\s+["'\`]([^"'\`]+)["'\`]`, "g");
+                const importMatch = importRegex.exec(code);
+                const matchedSrc = declMatch?.[1] ?? importMatch?.[1];
+                const matchedRange = declMatch
+                    ? { start: declMatch.index, end: declMatch.index + declMatch[0].length }
+                    : importMatch
+                        ? { start: importMatch.index, end: importMatch.index + importMatch[0].length }
+                        : null;
+                if (matchedSrc && matchedRange) {
+                    const identRegex = new RegExp(`\\b${varName}\\b`, "g");
+                    const totalMatches = code.match(identRegex).length;
+                    let inImageCount = 0;
+                    const allTags = code.matchAll(/<Image\b([^>]*)\/?>/gs);
+                    for (const m of allTags) {
+                        if (m[1].includes(varName))
+                            inImageCount++;
+                    }
+                    if (totalMatches <= inImageCount + 1) {
+                        imageComponentRefs.add(matchedSrc);
+                        imageRanges.push(matchedRange);
+                    }
+                }
+            }
+        }
+    }
+    const metadataRanges = getMetadataRanges(code);
+    for (const range of metadataRanges) {
+        const block = code.slice(range.start, range.end + 1);
+        const refs = extractImageReferences(block);
+        for (const ref of refs) {
+            metadataRefs.add(ref);
+        }
+    }
+    const pattern = /(?:["'`])([^"'`\s\n\r#?]+\.(?:png|jpg|jpeg|webp|avif))(?:\?[^"'`\s]*|#[^"'`\s]*)?(?:["'`])/gi;
+    let match;
+    while ((match = pattern.exec(code)) !== null) {
+        const raw = match[1];
+        const offset = match.index;
+        const inImp = importRanges.some((r) => offset >= r.start && offset < r.end);
+        const inImage = inImp || imageRanges.some((r) => offset >= r.start && offset < r.end);
+        const inMeta = metadataRanges.some((r) => offset >= r.start && offset < r.end);
+        if (!inImage && !inMeta) {
+            otherRefs.add(raw);
+        }
+    }
+    return { imageComponentRefs, metadataRefs, otherRefs };
+}
+export async function classifyImageUsages(root, publicDir = "public") {
+    const codeFiles = await collectCodeFiles(root, publicDir, SCANNED_EXTENSIONS);
+    const classifications = {};
+    function getOrCreate(canonicalSrc) {
+        if (!classifications[canonicalSrc]) {
+            classifications[canonicalSrc] = {
+                canonicalSrc,
+                inImageComponent: false,
+                inMetadata: false,
+                inOtherPlace: false,
+            };
+        }
+        return classifications[canonicalSrc];
+    }
+    for (const file of codeFiles) {
+        const content = await readFile(file, "utf8").catch(() => "");
+        const details = extractImageUsageDetails(content, file);
+        for (const ref of details.imageComponentRefs) {
+            const canonical = resolvePublicSrc(ref);
+            getOrCreate(canonical).inImageComponent = true;
+        }
+        for (const ref of details.metadataRefs) {
+            const canonical = resolvePublicSrc(ref);
+            getOrCreate(canonical).inMetadata = true;
+        }
+        for (const ref of details.otherRefs) {
+            const canonical = resolvePublicSrc(ref);
+            getOrCreate(canonical).inOtherPlace = true;
+        }
+    }
+    return classifications;
+}
+export function getPrunableOriginalPaths(classifications, manifestImages, optimizeMetadata) {
+    const prunable = [];
+    for (const [canonicalSrc, usage] of Object.entries(classifications)) {
+        if (!manifestImages[canonicalSrc])
+            continue;
+        if (usage.inOtherPlace)
+            continue;
+        const canPrune = optimizeMetadata
+            ? (usage.inImageComponent || usage.inMetadata)
+            : (usage.inImageComponent && !usage.inMetadata);
+        if (canPrune) {
+            prunable.push(canonicalSrc.replace(/^\/+/, ""));
+        }
+    }
+    return prunable.sort();
+}

package/dist/src/image_optimizer/types.d.ts

@@ -30,6 +30,8 @@ export interface ImageOptimizerPluginOptions {
     concurrency?: number;
     effort?: number;
     autoImageLoader?: boolean | AutoImageLoaderOptions;
+    optimizeMetadata?: boolean;
+    pruneOriginalsFromBuild?: boolean;
 }
 export interface ResolvedBlurOptions {
     enabled: boolean;
@@ -53,6 +55,8 @@ export interface ResolvedOptions {
     concurrency: number;
     effort: number | undefined;
     autoImageLoader: boolean | AutoImageLoaderOptions;
+    optimizeMetadata: boolean;
+    pruneOriginalsFromBuild: boolean;
 }
 export interface ResolvedImageConfig {
     maxWidth: number | false;

package/dist/src/image_optimizer/types.js

@@ -22,6 +22,8 @@ export const DEFAULT_OPTIONS = {
     concurrency: Math.max(1, Math.min(cpus().length, 8)),
     effort: undefined,
     autoImageLoader: true,
+    optimizeMetadata: true,
+    pruneOriginalsFromBuild: true,
 };
 export function resolveBlurOptions(blur, parentDefault = DEFAULT_BLUR_OPTIONS) {
     if (blur === false) {
@@ -61,6 +63,8 @@ export function resolveOptions(options) {
         concurrency: Math.max(1, raw.concurrency ?? DEFAULT_OPTIONS.concurrency),
         effort: raw.effort,
         autoImageLoader: raw.autoImageLoader ?? DEFAULT_OPTIONS.autoImageLoader,
+        optimizeMetadata: raw.optimizeMetadata ?? DEFAULT_OPTIONS.optimizeMetadata,
+        pruneOriginalsFromBuild: raw.pruneOriginalsFromBuild ?? DEFAULT_OPTIONS.pruneOriginalsFromBuild,
     };
 }
 export function resolveImageConfig(publicSrc, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.13.5",
+  "version": "0.14.0",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -368,7 +368,7 @@
     "cloudflare-next-intl-db": "^0.3.0",
     "cloudflare-next-intl-db-codegen": "^0.1.4",
     "cloudflare-next-intl-errors": "^0.1.0",
-    "cloudflare-next-intl-intl": "^0.2.0",
+    "cloudflare-next-intl-intl": "^0.2.1",
     "cloudflare-next-intl-theme": "^0.1.0",
     "sharp": "^0.34.5 || ^0.35.0"
   },