@monkeyplus/flow 6.0.6 → 6.0.7

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,5 @@
+export default function ipxHandler(event: any): Promise<string | void | Buffer<ArrayBufferLike> | {
+    error: {
+        message: string;
+    };
+}> | Response;

package/modules/images/ipx.mjs

@@ -0,0 +1,31 @@
+import { createIPX, createIPXH3Handler, ipxFSStorage, ipxHttpStorage } from "ipx";
+import { useRuntimeConfig } from "nitro/runtime-config";
+let cachedDir = "";
+let cachedDomainsKey = "";
+let cachedHandler;
+function resolveHandler() {
+  const config = useRuntimeConfig();
+  const publicDir = config.flow?.images?.publicDir;
+  const domains = Object.keys(config.flow?.images?.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 function ipxHandler(event) {
+  const handler = resolveHandler();
+  if (!handler) {
+    return new Response("Not Found", { status: 404 });
+  }
+  return handler(event);
+}

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,96 @@
+import { rmSync } from "node:fs";
+import { resolve } from "node:path";
+import { joinURL } from "ufo";
+import { resolvePackageFile, resolvePackagePath } from "../../src/public/shared.mjs";
+import { defineFlowModule } from "../../src/runtime/config.mjs";
+import { screens } from "./runtime/helpers.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 = joinURL(dirImages, "strapi");
+    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 {};
+  }
+}
+export default defineFlowModule({
+  meta: {
+    name: "images",
+    configKey: "images"
+  },
+  defaults: {
+    dirRenames: "shared/seo_images",
+    dirFiles: ["images", "media"],
+    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 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 buildPluginPath = context.projectRoot === resolvePackagePath() ? resolve(context.projectRoot, "modules/images/plugin.ts") : resolvePackageFile("modules/images/plugin.ts", "modules/images/plugin.mjs", "modules/images/plugin.js");
+    if (isSsg) {
+      rmSync(generatedManifestPath, { force: true });
+      context.nitro.plugins.push(buildPluginPath);
+    }
+    context.nitro.handlers.push({
+      route: "/_ipx/**",
+      handler: ipxHandlerPath
+    });
+    context.nitro.runtimeConfig.flow = {
+      ...typeof context.nitro.runtimeConfig.flow === "object" && context.nitro.runtimeConfig.flow ? context.nitro.runtimeConfig.flow : {},
+      images: {
+        dirRenames: renameDir,
+        dirFiles: options.dirFiles,
+        publicDir,
+        outputDir: resolve(context.projectRoot, ".output/public"),
+        generatedManifestPath,
+        generatedCacheDir,
+        generatedCacheManifestPath,
+        generate: isSsg,
+        netlifyCache: isNetlify,
+        options: {
+          lazy: options.lazy,
+          screens: options.screens,
+          domains: resolvedDomains,
+          presets: options.presets,
+          baseURL: options.baseURL,
+          dirImages: options.dirImages
+        }
+      }
+    };
+  }
+});

package/modules/images/plugin.d.ts

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

package/modules/images/plugin.mjs

@@ -0,0 +1,19 @@
+import process from "node:process";
+import { defineNitroPlugin } from "nitro/runtime";
+import { materializeGeneratedImages } from "./runtime/build.mjs";
+import { resetFlowImageRuntimeState } from "./runtime/server.mjs";
+export default defineNitroPlugin((nitro) => {
+  nitro.hooks.hook("prerender:done", async () => {
+    const imagesConfig = nitro.options.runtimeConfig.flow?.images;
+    if (!imagesConfig?.generate) {
+      return;
+    }
+    const result = await materializeGeneratedImages(imagesConfig);
+    if (result.total > 0) {
+      console.log(
+        `[flow:images] materialized ${result.total} images (${result.generated} generated, ${result.cacheHits} cache hits${imagesConfig.netlifyCache && process.env.NETLIFY ? ", netlify cache enabled" : ""})`
+      );
+    }
+    resetFlowImageRuntimeState();
+  });
+});

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,142 @@
+import { createHash } from "node:crypto";
+import { copyFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { createIPX, ipxFSStorage, ipxHttpStorage } from "ipx";
+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));
+}
+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(parsed.url, 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;
+  for (const image of images) {
+    const signature = await createSignature(image, config.publicDir);
+    nextManifest[image.url] = {
+      ...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[image.url]?.signature === signature && existsSync(cachePath)) {
+      await copyFile(cachePath, outputPath);
+      cacheHits += 1;
+      continue;
+    }
+    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);
+    }
+    generated += 1;
+  }
+  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;

package/modules/images/runtime/helpers.mjs

@@ -0,0 +1,45 @@
+function extname(value) {
+  const fileName = value.split("/").pop() || value;
+  const index = fileName.lastIndexOf(".");
+  return index > 0 ? fileName.slice(index) : "";
+}
+function basename(value) {
+  return value.split("/").pop() || value;
+}
+export const screens = {
+  xs: 320,
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280,
+  xxl: 1536
+};
+export function parseSize(input = "") {
+  if (typeof input === "number") {
+    return input;
+  }
+  if (typeof input === "string" && input.replace("px", "").match(/^\d+$/g)) {
+    return parseInt(input, 10);
+  }
+  return void 0;
+}
+export function getNormalName(originalName) {
+  const name = basename(originalName).replace(extname(originalName), "");
+  return name.replace(/-/g, " ");
+}
+export function getFileExtension(url = "") {
+  return url.split(/[?#]/).shift().split("/").pop().split(".").pop();
+}
+export function guessExt(input = "") {
+  const ext = input.split(".").pop()?.split("?")[0];
+  if (ext && /^[\w0-9]+$/.test(ext)) {
+    return `.${ext}`;
+  }
+  return "";
+}
+export function getPreset(ctx, name) {
+  if (!name) {
+    return {};
+  }
+  return ctx.options?.presets?.[name] || {};
+}

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

@@ -0,0 +1,7 @@
+import type { FlowImagesState, FlowImageOptions, GeneratedImageEntry, GetImageFunction } from './types.ts';
+export declare function createImageResolver(imagesOptions: FlowImageOptions, stateImages: FlowImagesState, runtime?: {
+    generateOutput?: boolean;
+    onGenerate?: (image: GeneratedImageEntry) => void;
+}): {
+    getImage: GetImageFunction;
+};