@monkeyplus/flow 6.0.6 → 6.0.8

package/modules/content/module.mjs

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
-import { defineFlowModule } from "../../src/runtime/config.mjs";
 import { resolvePackageFile, resolvePackagePath } from "../../src/public/shared.mjs";
+import { defineFlowModule } from "../../src/runtime/config.mjs";
 export default defineFlowModule({
   meta: {
     name: "content",
@@ -12,21 +12,36 @@ export default defineFlowModule({
   },
   setup(options, context) {
     const contentDir = resolve(context.projectRoot, options.dir);
+    const publicConfig = {
+      apiBase: options.apiBase
+    };
     const queryHandlerPath = context.projectRoot === resolvePackagePath() ? resolve(context.projectRoot, "modules/content/query.ts") : resolvePackageFile("modules/content/query.ts", "modules/content/query.mjs", "modules/content/query.js");
     context.nitro.handlers.push({
       method: "get",
       route: `${options.apiBase}/query`,
       handler: queryHandlerPath
     });
+    context.nitro.handlers.push({
+      method: "get",
+      route: `${options.apiBase}/tree`,
+      handler: queryHandlerPath
+    });
     context.nitro.routeRules[`${options.apiBase}/**`] = {
       cors: true
     };
     context.nitro.runtimeConfig.flow = {
       ...typeof context.nitro.runtimeConfig.flow === "object" && context.nitro.runtimeConfig.flow ? context.nitro.runtimeConfig.flow : {},
       content: {
-        apiBase: options.apiBase,
+        ...publicConfig,
         dir: contentDir
       }
     };
+    context.nitro.runtimeConfig.public = {
+      ...typeof context.nitro.runtimeConfig.public === "object" && context.nitro.runtimeConfig.public ? context.nitro.runtimeConfig.public : {},
+      flow: {
+        ...typeof context.nitro.runtimeConfig.public?.flow === "object" && context.nitro.runtimeConfig.public.flow ? context.nitro.runtimeConfig.public.flow : {},
+        content: publicConfig
+      }
+    };
   }
 });

package/modules/content/query.d.ts

@@ -1,2 +1,27 @@
+export interface ContentEntry {
+    path: string;
+    stem: string;
+    dir: string;
+    name: string;
+    extension: string;
+    title?: string;
+    body: string;
+    data: Record<string, unknown>;
+}
+export interface ContentDirectoryNode {
+    kind: 'directory';
+    name: string;
+    path: string;
+    stem: string;
+    children: ContentTreeNode[];
+}
+export interface ContentFileNode extends ContentEntry {
+    kind: 'file';
+}
+export type ContentTreeNode = ContentDirectoryNode | ContentFileNode;
+export declare function findContentEntries(entries: ContentEntry[], path?: string): ContentEntry[];
+export declare function readContentEntries(contentDir: string): ContentEntry[];
+export declare function buildContentTree(entries: ContentEntry[]): ContentTreeNode[];
+export declare function findContentTree(tree: ContentTreeNode[], path?: string): ContentTreeNode[];
 declare const _default: any;
 export default _default;

package/modules/content/query.mjs

@@ -1,6 +1,6 @@
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { extname, relative, resolve } from "node:path";
-import { defineEventHandler, getQuery } from "nitro/h3";
+import { defineEventHandler, getQuery, getRequestURL } from "nitro/h3";
 import { useRuntimeConfig } from "nitro/runtime-config";
 function collectFiles(rootDir, currentDir = rootDir) {
   const entries = readdirSync(currentDir, { withFileTypes: true });
@@ -22,9 +22,30 @@ function collectFiles(rootDir, currentDir = rootDir) {
   }
   return files.sort((left, right) => left.localeCompare(right));
 }
+function normalizeQueryPath(path) {
+  if (!path) {
+    return "/";
+  }
+  const normalized = `/${path}`.replace(/\/+/g, "/");
+  return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+export function findContentEntries(entries, path) {
+  const normalizedPath = normalizeQueryPath(path);
+  if (normalizedPath === "/") {
+    return entries;
+  }
+  return entries.filter((entry) => entry.path === normalizedPath || entry.path.startsWith(`${normalizedPath}/`));
+}
 function normalizeContentPath(rootDir, filePath) {
   const shortPath = relative(rootDir, filePath).replaceAll("\\", "/");
-  return `/${shortPath.replace(/\.(md|json|ya?ml|txt)$/i, "")}`;
+  const stem = shortPath.replace(/\.(md|json|ya?ml|txt)$/i, "");
+  const segments = stem.split("/").filter(Boolean);
+  return {
+    path: `/${stem}`,
+    stem,
+    dir: segments.length > 1 ? `/${segments.slice(0, -1).join("/")}` : "/",
+    name: segments[segments.length - 1] || stem
+  };
 }
 function parseKeyValueBlock(block) {
   return block.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).reduce((data, line) => {
@@ -41,26 +62,21 @@ function parseKeyValueBlock(block) {
 function parseContentFile(rootDir, filePath) {
   const raw = readFileSync(filePath, "utf8");
   const extension = extname(filePath).toLowerCase();
-  const path = normalizeContentPath(rootDir, filePath);
+  const normalizedPath = normalizeContentPath(rootDir, filePath);
   if (extension === ".json") {
     const parsed = JSON.parse(raw);
     return {
-      path,
+      ...normalizedPath,
       extension,
       title: typeof parsed.title === "string" ? parsed.title : void 0,
-      body: JSON.stringify(parsed, null, 2),
-      data: Object.entries(parsed).reduce((result, [key, value]) => {
-        if (typeof value === "string") {
-          result[key] = value;
-        }
-        return result;
-      }, {})
+      body: raw,
+      data: parsed
     };
   }
   if ((extension === ".yml" || extension === ".yaml") && raw.trim()) {
     const data = parseKeyValueBlock(raw);
     return {
-      path,
+      ...normalizedPath,
       extension,
       title: data.title,
       body: raw,
@@ -74,7 +90,7 @@ function parseContentFile(rootDir, filePath) {
       const body = raw.slice(end + 5).trim();
       const data = parseKeyValueBlock(frontmatter);
       return {
-        path,
+        ...normalizedPath,
         extension,
         title: data.title,
         body,
@@ -83,22 +99,92 @@ function parseContentFile(rootDir, filePath) {
     }
   }
   return {
-    path,
+    ...normalizedPath,
     extension,
     body: raw,
     data: {}
   };
 }
+export function readContentEntries(contentDir) {
+  if (!contentDir || !existsSync(contentDir)) {
+    return [];
+  }
+  return collectFiles(contentDir).map((filePath) => parseContentFile(contentDir, filePath));
+}
+function sortTree(nodes) {
+  nodes.sort((left, right) => {
+    if (left.kind !== right.kind) {
+      return left.kind === "directory" ? -1 : 1;
+    }
+    return left.name.localeCompare(right.name);
+  });
+  for (const node of nodes) {
+    if (node.kind === "directory") {
+      sortTree(node.children);
+    }
+  }
+  return nodes;
+}
+export function buildContentTree(entries) {
+  const roots = [];
+  const directories = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const segments = entry.stem.split("/").filter(Boolean);
+    const dirSegments = segments.slice(0, -1);
+    let siblings = roots;
+    for (let index = 0; index < dirSegments.length; index += 1) {
+      const stem = dirSegments.slice(0, index + 1).join("/");
+      let directory = directories.get(stem);
+      if (!directory) {
+        directory = {
+          kind: "directory",
+          name: dirSegments[index],
+          path: `/${stem}`,
+          stem,
+          children: []
+        };
+        directories.set(stem, directory);
+        siblings.push(directory);
+      }
+      siblings = directory.children;
+    }
+    siblings.push({
+      kind: "file",
+      ...entry
+    });
+  }
+  return sortTree(roots);
+}
+export function findContentTree(tree, path) {
+  const normalizedPath = normalizeQueryPath(path);
+  if (normalizedPath === "/") {
+    return tree;
+  }
+  const stack = [...tree];
+  while (stack.length) {
+    const node = stack.shift();
+    if (node.path === normalizedPath) {
+      return [node];
+    }
+    if (node.kind === "directory") {
+      stack.unshift(...node.children);
+    }
+  }
+  return [];
+}
 export default defineEventHandler((event) => {
   const runtimeConfig = useRuntimeConfig();
   const query = getQuery(event);
   const contentDir = runtimeConfig.flow?.content?.dir;
-  if (!contentDir || !existsSync(contentDir)) {
-    return [];
+  const requestUrl = getRequestURL(event);
+  const isTreeRequest = requestUrl.pathname.endsWith("/tree") || query.tree === true || query.tree === "true" || query.tree === "1";
+  const entries = readContentEntries(contentDir || "");
+  if (isTreeRequest) {
+    const tree = buildContentTree(entries);
+    return findContentTree(tree, query.path);
   }
-  const entries = collectFiles(contentDir).map((filePath) => parseContentFile(contentDir, filePath));
   if (query.path) {
-    return entries.filter((entry) => entry.path === query.path || entry.path.startsWith(`${query.path}/`));
+    return findContentEntries(entries, query.path);
   }
   return entries;
 });

package/modules/content/runtime/client.d.ts

@@ -0,0 +1,2 @@
+export { queryContent } from '../../../src/public/query-content.ts';
+export type { QueryContentBuilder } from '../../../src/public/query-content.ts';

package/modules/content/runtime/client.mjs

@@ -0,0 +1 @@
+export { queryContent } from "../../../src/public/query-content.mjs";

package/modules/images/ipx.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/modules/images/ipx.mjs

@@ -0,0 +1,55 @@
+import process from "node:process";
+import { createIPX, createIPXH3Handler, ipxFSStorage, ipxHttpStorage } from "ipx";
+import { defineHandler } from "nitro";
+import { getRequestURL } from "nitro/h3";
+import { useRuntimeConfig } from "nitro/runtime-config";
+let cachedDir = "";
+let cachedDomainsKey = "";
+let cachedHandler;
+function getEnvFlowImagesConfig() {
+  const raw = process.env.FLOW_IMAGES_RUNTIME_CONFIG;
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function resolveHandler() {
+  const envConfig = getEnvFlowImagesConfig();
+  const runtimeConfig = useRuntimeConfig();
+  const config = runtimeConfig.flow?.images || envConfig;
+  const publicDir = config?.publicDir;
+  const domains = Object.keys(config?.options?.domains || {});
+  const domainsKey = domains.join("|");
+  if (!publicDir) {
+    return void 0;
+  }
+  if (!cachedHandler || cachedDir !== publicDir || cachedDomainsKey !== domainsKey) {
+    cachedDir = publicDir;
+    cachedDomainsKey = domainsKey;
+    const ipx = createIPX({
+      storage: ipxFSStorage({ dir: publicDir }),
+      ...domains.length ? {
+        httpStorage: ipxHttpStorage({ domains })
+      } : {}
+    });
+    cachedHandler = createIPXH3Handler(ipx);
+  }
+  return cachedHandler;
+}
+export default defineHandler(async (event) => {
+  if (!getRequestURL(event)?.pathname.startsWith("/_ipx")) {
+    console.log("route", event.req.url.toString());
+    return;
+  }
+  const handler = resolveHandler();
+  const path = event.path.replace(/^\/_ipx/, "") || "/";
+  return await handler?.({
+    ...event,
+    path,
+    node: event.runtime?.node
+  });
+});

package/modules/images/module.d.ts

@@ -0,0 +1,4 @@
+import type { FlowImagesModuleOptions } from './runtime/types.ts';
+export type { FlowImagesModuleOptions as ImagesModuleOptions } from './runtime/types.ts';
+declare const _default: import("../../src/runtime/config.ts").FlowModuleDefinition<FlowImagesModuleOptions>;
+export default _default;

package/modules/images/module.mjs

@@ -0,0 +1,146 @@
+import { rmSync } from "node:fs";
+import { resolve } from "node:path";
+import process from "node:process";
+import { createIPX, createIPXNodeServer, ipxFSStorage, ipxHttpStorage } from "ipx";
+import { resolvePackageFile, resolvePackagePath } from "../../src/public/shared.mjs";
+import { defineFlowModule } from "../../src/runtime/config.mjs";
+import { materializeGeneratedImages } from "./runtime/build.mjs";
+import { screens } from "./runtime/helpers.mjs";
+import { resetFlowImageRuntimeState } from "./runtime/server.mjs";
+function withoutTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function resolveStrapiDomains(flowConfig, dirImages) {
+  const strapi = flowConfig.strapi;
+  if (!strapi || typeof strapi.url !== "string" || !strapi.url) {
+    return {};
+  }
+  try {
+    const url = new URL(strapi.url);
+    const target = dirImages;
+    const values = /* @__PURE__ */ new Set([
+      withoutTrailingSlash(url.origin),
+      withoutTrailingSlash(url.toString())
+    ]);
+    if (url.pathname && url.pathname !== "/") {
+      values.add(withoutTrailingSlash(`${url.origin}${url.pathname}`));
+    }
+    return [...values].reduce((result, value) => {
+      if (value) {
+        result[value] = target;
+      }
+      return result;
+    }, {});
+  } catch {
+    return {};
+  }
+}
+function createIpxDevServerPlugin(imagesRuntimeConfig) {
+  const domains = Object.keys(imagesRuntimeConfig.options.domains || {});
+  let middleware;
+  return {
+    name: "flow:images-ipx-dev",
+    apply: "serve",
+    configureServer(server) {
+      if (!middleware) {
+        const ipx = createIPX({
+          storage: ipxFSStorage({ dir: imagesRuntimeConfig.publicDir }),
+          ...domains.length ? { httpStorage: ipxHttpStorage({ domains }) } : {}
+        });
+        middleware = createIPXNodeServer(ipx);
+      }
+      server.middlewares.use("/_ipx", (req, res, next) => {
+        try {
+          const result = middleware?.(req, res);
+          if (result && typeof result.then === "function") {
+            void result.catch(next);
+          }
+        } catch (error) {
+          next(error);
+        }
+      });
+    }
+  };
+}
+export default defineFlowModule({
+  meta: {
+    name: "images",
+    configKey: "images"
+  },
+  defaults: {
+    dirRenames: "shared/seo_images",
+    dirFiles: ["images", "media"],
+    buildBatchSize: 8,
+    lazy: true,
+    screens,
+    baseURL: "/_ipx",
+    dirImages: "/images",
+    domains: {},
+    presets: {}
+  },
+  setup(options, context) {
+    const resolvedDomains = {
+      ...resolveStrapiDomains(context.flowConfig, options.dirImages),
+      ...options.domains || {}
+    };
+    const isSsg = context.flowConfig.build.preset === "ssg";
+    const shouldGenerateOutput = isSsg && process.env.NODE_ENV === "production";
+    const isNetlify = !!process.env.NETLIFY;
+    const publicDir = resolve(context.projectRoot, "public");
+    const renameDir = resolve(context.projectRoot, options.dirRenames);
+    const imagesCacheRoot = resolve(context.projectRoot, "node_modules/.cache-images");
+    const generatedManifestPath = resolve(imagesCacheRoot, "generated-images.jsonl");
+    const generatedCacheDir = isNetlify ? resolve(imagesCacheRoot, "netlify") : void 0;
+    const generatedCacheManifestPath = generatedCacheDir ? resolve(generatedCacheDir, "manifest.json") : void 0;
+    const ipxHandlerPath = context.projectRoot === resolvePackagePath() ? resolve(context.projectRoot, "modules/images/ipx.ts") : resolvePackageFile("modules/images/ipx.ts", "modules/images/ipx.mjs", "modules/images/ipx.js");
+    const imagesRuntimeConfig = {
+      dirRenames: renameDir,
+      dirFiles: options.dirFiles,
+      buildBatchSize: options.buildBatchSize,
+      publicDir,
+      outputDir: resolve(context.projectRoot, ".output/public"),
+      generatedManifestPath,
+      generatedCacheDir,
+      generatedCacheManifestPath,
+      generate: shouldGenerateOutput,
+      netlifyCache: isNetlify,
+      options: {
+        lazy: options.lazy,
+        screens: options.screens,
+        domains: resolvedDomains,
+        presets: options.presets,
+        baseURL: options.baseURL,
+        dirImages: options.dirImages
+      }
+    };
+    process.env.FLOW_IMAGES_RUNTIME_CONFIG = JSON.stringify(imagesRuntimeConfig);
+    if (shouldGenerateOutput) {
+      rmSync(generatedManifestPath, { force: true });
+      const existingPrerenderDone = context.nitro.hooks["prerender:done"];
+      context.nitro.hooks["prerender:done"] = async (...args) => {
+        if (typeof existingPrerenderDone === "function") {
+          await existingPrerenderDone(...args);
+        }
+        const result = await materializeGeneratedImages(imagesRuntimeConfig);
+        if (result.total > 0) {
+          console.log(
+            `[flow:images] materialized ${result.total} images (${result.generated} generated, ${result.cacheHits} cache hits${imagesRuntimeConfig.netlifyCache && process.env.NETLIFY ? ", netlify cache enabled" : ""})`
+          );
+        }
+        resetFlowImageRuntimeState();
+      };
+    }
+    context.nitro.handlers.push({
+      route: "/_ipx/**",
+      handler: ipxHandlerPath
+      // middleware: true,
+    });
+    context.vite.plugins.push(createIpxDevServerPlugin(imagesRuntimeConfig));
+    context.nitro.runtimeConfig.flow = {
+      ...typeof context.nitro.runtimeConfig.flow === "object" && context.nitro.runtimeConfig.flow ? context.nitro.runtimeConfig.flow : {},
+      images: {
+        ...imagesRuntimeConfig
+      }
+    };
+  }
+});

package/modules/images/runtime/build.d.ts

@@ -0,0 +1,6 @@
+import type { FlowImagesRuntimeConfig } from './types.ts';
+export declare function materializeGeneratedImages(config: FlowImagesRuntimeConfig): Promise<{
+    cacheHits: number;
+    generated: number;
+    total: number;
+}>;

package/modules/images/runtime/build.mjs

@@ -0,0 +1,174 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import process from "node:process";
+import { createIPX, ipxFSStorage, ipxHttpStorage } from "ipx";
+const DEFAULT_BUILD_BATCH_SIZE = 8;
+function getGeneratedImageKey(entry) {
+  return `${entry.url}:${entry.generate}`;
+}
+function sortRecord(value) {
+  return Object.keys(value).sort().reduce((result, key) => {
+    result[key] = value[key];
+    return result;
+  }, {});
+}
+function hashRecord(value) {
+  return createHash("sha1").update(JSON.stringify(sortRecord(value))).digest("hex");
+}
+function normalizeOutputPath(path) {
+  return path.startsWith("/") ? path.slice(1) : path;
+}
+function outputFilePath(baseDir, path) {
+  return resolve(baseDir, normalizeOutputPath(path));
+}
+function createBatches(items, batchSize) {
+  const batches = [];
+  for (let index = 0; index < items.length; index += batchSize) {
+    batches.push(items.slice(index, index + batchSize));
+  }
+  return batches;
+}
+function resolveBuildBatchSize() {
+  const configuredValue = Number(process.env.FLOW_IMAGES_BUILD_BATCH_SIZE);
+  if (!Number.isFinite(configuredValue) || configuredValue < 1) {
+    return DEFAULT_BUILD_BATCH_SIZE;
+  }
+  return Math.floor(configuredValue);
+}
+function resolveConfiguredBatchSize(configuredBatchSize) {
+  if (Number.isFinite(configuredBatchSize) && configuredBatchSize && configuredBatchSize > 0) {
+    return Math.floor(configuredBatchSize);
+  }
+  return resolveBuildBatchSize();
+}
+async function ensureParentDir(path) {
+  await mkdir(dirname(path), { recursive: true });
+}
+async function readJson(path, fallback) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+async function readGeneratedManifest(path) {
+  if (!path || !existsSync(path)) {
+    return [];
+  }
+  const raw = await readFile(path, "utf8");
+  const collection = /* @__PURE__ */ new Map();
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim()) {
+      continue;
+    }
+    const parsed = JSON.parse(line);
+    collection.set(getGeneratedImageKey(parsed), parsed);
+  }
+  return [...collection.values()];
+}
+async function createSignature(entry, publicDir) {
+  if (entry.src.startsWith("http://") || entry.src.startsWith("https://")) {
+    return hashRecord({
+      generate: entry.generate,
+      modifiers: entry.modifiers,
+      src: entry.src
+    });
+  }
+  const sourcePath = resolve(publicDir, entry.src.replace(/^\//, ""));
+  const sourceStat = await stat(sourcePath);
+  return hashRecord({
+    generate: entry.generate,
+    modifiers: entry.modifiers,
+    mtimeMs: sourceStat.mtimeMs,
+    size: sourceStat.size,
+    src: entry.src
+  });
+}
+async function walkFiles(rootDir, currentDir = rootDir, files = []) {
+  if (!existsSync(currentDir)) {
+    return files;
+  }
+  for (const entry of await readdir(currentDir, { withFileTypes: true })) {
+    const entryPath = join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      await walkFiles(rootDir, entryPath, files);
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+async function pruneCache(cacheDir, activeFiles) {
+  for (const filePath of await walkFiles(cacheDir)) {
+    const relativePath = normalizeOutputPath(filePath.replace(`${cacheDir}/`, "").replace(`${cacheDir}\\`, ""));
+    if (!activeFiles.has(relativePath)) {
+      await rm(filePath, { force: true });
+    }
+  }
+}
+export async function materializeGeneratedImages(config) {
+  if (!config.generate) {
+    return { cacheHits: 0, generated: 0, total: 0 };
+  }
+  const images = await readGeneratedManifest(config.generatedManifestPath);
+  if (!images.length) {
+    return { cacheHits: 0, generated: 0, total: 0 };
+  }
+  const domains = Object.keys(config.options.domains || {});
+  const ipx = createIPX({
+    storage: ipxFSStorage({ dir: config.publicDir }),
+    ...domains.length ? { httpStorage: ipxHttpStorage({ domains }) } : {}
+  });
+  const previousManifest = config.netlifyCache && config.generatedCacheManifestPath ? await readJson(config.generatedCacheManifestPath, {}) : {};
+  const nextManifest = {};
+  const activeCacheFiles = /* @__PURE__ */ new Set();
+  let cacheHits = 0;
+  let generated = 0;
+  const batchSize = resolveConfiguredBatchSize(config.buildBatchSize);
+  for (const batch of createBatches(images, batchSize)) {
+    const results = await Promise.all(batch.map(async (image) => {
+      const signature = await createSignature(image, config.publicDir);
+      const imageKey = getGeneratedImageKey(image);
+      nextManifest[imageKey] = {
+        ...image,
+        signature
+      };
+      const outputPath = outputFilePath(config.outputDir, image.generate);
+      const cacheRelativePath = normalizeOutputPath(image.generate);
+      const cachePath = config.generatedCacheDir ? outputFilePath(config.generatedCacheDir, cacheRelativePath) : void 0;
+      activeCacheFiles.add(cacheRelativePath);
+      await ensureParentDir(outputPath);
+      if (config.netlifyCache && cachePath && previousManifest[imageKey]?.signature === signature && existsSync(cachePath)) {
+        await copyFile(cachePath, outputPath);
+        return { cacheHit: 1, generated: 0 };
+      }
+      const processed = await ipx(image.src, image.modifiers).process();
+      const data = typeof processed.data === "string" ? Buffer.from(processed.data) : processed.data;
+      await writeFile(outputPath, data);
+      if (config.netlifyCache && cachePath) {
+        await ensureParentDir(cachePath);
+        await writeFile(cachePath, data);
+      }
+      return { cacheHit: 0, generated: 1 };
+    }));
+    for (const result of results) {
+      cacheHits += result.cacheHit;
+      generated += result.generated;
+    }
+  }
+  if (config.netlifyCache && config.generatedCacheDir && config.generatedCacheManifestPath) {
+    await mkdir(config.generatedCacheDir, { recursive: true });
+    await pruneCache(config.generatedCacheDir, activeCacheFiles);
+    await writeFile(config.generatedCacheManifestPath, `${JSON.stringify(nextManifest, null, 2)}
+`, "utf8");
+  }
+  return {
+    cacheHits,
+    generated,
+    total: images.length
+  };
+}

package/modules/images/runtime/helpers.d.ts

@@ -0,0 +1,16 @@
+import type { FlowImageOptions, ImageOptions } from './types.ts';
+export declare const screens: {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    xxl: number;
+};
+export declare function parseSize(input?: string | number | undefined): number | undefined;
+export declare function getNormalName(originalName: string): string;
+export declare function getFileExtension(url?: string): string;
+export declare function guessExt(input?: string): string;
+export declare function getPreset(ctx: {
+    options: FlowImageOptions;
+}, name?: string): ImageOptions;