@monkeyplus/flow 6.0.6 → 6.0.8

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 { FlowImageOptions, FlowImagesState, GeneratedImageEntry, GetImageFunction } from './types.ts';
+export declare function createImageResolver(imagesOptions: FlowImageOptions, stateImages: FlowImagesState, runtime?: {
+    generateOutput?: boolean;
+    onGenerate?: (image: GeneratedImageEntry) => void;
+}): {
+    getImage: GetImageFunction;
+};

package/modules/images/runtime/image.mjs

@@ -0,0 +1,252 @@
+import { encodeParam, encodePath, joinURL } from "ufo";
+import { getNormalName, getPreset, guessExt, parseSize } from "./helpers.mjs";
+const modifierKeyMap = {
+  background: "b",
+  fit: "fit",
+  format: "f",
+  height: "h",
+  position: "pos",
+  quality: "q",
+  resize: "s",
+  width: "w"
+};
+function resolveIpxUrl(src, modifiers = {}, baseURL = "/_ipx") {
+  const normalizedModifiers = { ...modifiers };
+  if (normalizedModifiers.width && normalizedModifiers.height) {
+    normalizedModifiers.resize = `${normalizedModifiers.width}x${normalizedModifiers.height}`;
+    delete normalizedModifiers.width;
+    delete normalizedModifiers.height;
+  }
+  const params = Object.entries(normalizedModifiers).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => `${encodeParam(modifierKeyMap[key] || key)}_${encodeParam(String(value))}`).join(",") || "_";
+  const serializedModifiers = Object.entries(normalizedModifiers).filter(([, value]) => value !== void 0 && value !== null && value !== "").reduce((result, [key, value]) => {
+    result[key] = String(value);
+    return result;
+  }, {});
+  return {
+    modifiers: serializedModifiers,
+    url: joinURL(baseURL, params, encodePath(src))
+  };
+}
+function isRemoteUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+function normalizeDirImages(dirImages) {
+  return dirImages.replace(/^\/+/, "").split("/")[0] || "images";
+}
+function getPathname(value) {
+  if (isRemoteUrl(value)) {
+    return new URL(value).pathname;
+  }
+  return value;
+}
+function getBaseDir(value, dirImages) {
+  return getPathname(value).replace(/^\/+/, "").split("/")[0] || normalizeDirImages(dirImages);
+}
+function getDirectory(value) {
+  const pathname = getPathname(value).split(/[?#]/, 1)[0] || "";
+  const lastSlash = pathname.lastIndexOf("/");
+  return lastSlash >= 0 ? pathname.slice(0, lastSlash) : "";
+}
+function getRelativePath(value, baseDir) {
+  const pathname = getPathname(value).split(/[?#]/, 1)[0] || "";
+  const normalizedBaseDir = baseDir.replace(/^\/+/, "").replace(/\/+$/, "");
+  const normalizedPath = pathname.replace(/^\/+/, "");
+  if (!normalizedBaseDir) {
+    return normalizedPath;
+  }
+  if (normalizedPath === normalizedBaseDir) {
+    return "";
+  }
+  if (normalizedPath.startsWith(`${normalizedBaseDir}/`)) {
+    return normalizedPath.slice(normalizedBaseDir.length + 1);
+  }
+  return normalizedPath;
+}
+function getModifierSegment(modifiers = {}) {
+  return Object.entries(modifiers).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => `${encodeParam(modifierKeyMap[key] || key)}_${encodeParam(String(value))}`).join(",") || "_";
+}
+function resolveRemoteRename(input, domains = {}) {
+  if (!isRemoteUrl(input)) {
+    return void 0;
+  }
+  const inputUrl = new URL(input);
+  for (const [base, target] of Object.entries(domains)) {
+    const normalizedBase = decodeURIComponent(base);
+    if (!normalizedBase) {
+      continue;
+    }
+    if (normalizedBase.startsWith("http://") || normalizedBase.startsWith("https://")) {
+      if (input.startsWith(normalizedBase)) {
+        return input.replace(normalizedBase, target);
+      }
+      const baseUrl = new URL(normalizedBase);
+      if (inputUrl.origin === baseUrl.origin && inputUrl.pathname.startsWith(baseUrl.pathname)) {
+        const suffix = inputUrl.pathname.slice(baseUrl.pathname.length).replace(/^\/+/, "");
+        return joinURL(target, suffix);
+      }
+      continue;
+    }
+    if (inputUrl.host === normalizedBase || inputUrl.hostname === normalizedBase) {
+      return joinURL(target, inputUrl.pathname);
+    }
+  }
+  return void 0;
+}
+function resolveRenamePath(path, rename) {
+  const normalizedRename = rename?.trim();
+  if (!normalizedRename) {
+    return path;
+  }
+  const directory = getDirectory(path);
+  let resolvedPath = normalizedRename.startsWith("/") ? normalizedRename : joinURL(directory || "/", normalizedRename);
+  const extension = guessExt(getPathname(path));
+  if (!guessExt(resolvedPath) && extension) {
+    resolvedPath += extension;
+  }
+  return resolvedPath;
+}
+export function createImageResolver(imagesOptions, stateImages, runtime = {}) {
+  const getImage = ((input, modifiers = {}, options = {}) => {
+    if (typeof input !== "string" || !input.length) {
+      throw new TypeError(`input must be a non-empty string (received ${typeof input})`);
+    }
+    const preset = getPreset({ options: imagesOptions }, options?.preset);
+    const resolvedOptions = {
+      ...options,
+      modifiers: {
+        ...preset?.modifiers,
+        ...modifiers
+      }
+    };
+    if (input.startsWith("data:")) {
+      return {
+        url: input
+      };
+    }
+    if (!input.startsWith("/") && !input.startsWith("https://") && !input.startsWith("http://")) {
+      input = joinURL(imagesOptions.dirImages, input);
+    }
+    const expectedFormat = resolvedOptions.modifiers?.format;
+    if (resolvedOptions.modifiers?.width) {
+      resolvedOptions.modifiers.width = parseSize(resolvedOptions.modifiers.width);
+    }
+    if (resolvedOptions.modifiers?.height) {
+      resolvedOptions.modifiers.height = parseSize(resolvedOptions.modifiers.height);
+    }
+    const image = resolveIpxUrl(input, resolvedOptions.modifiers || {}, imagesOptions.baseURL || "/_ipx");
+    image.format = image.format || expectedFormat || "";
+    image.src = input;
+    image.ext = image.format && `.${image.format}` || guessExt(input);
+    let baseDir = getBaseDir(input, imagesOptions.dirImages);
+    const originalExt = guessExt(input);
+    let renamedImage = stateImages.all[input]?.rename;
+    if (!renamedImage && imagesOptions.domains) {
+      renamedImage = resolveRemoteRename(input, imagesOptions.domains);
+    }
+    const replacedPath = decodeURIComponent(resolveRenamePath(renamedImage || input, resolvedOptions.rename));
+    if (isRemoteUrl(input) && replacedPath.startsWith("/")) {
+      baseDir = getBaseDir(replacedPath, imagesOptions.dirImages);
+    }
+    const modifierSegment = getModifierSegment(image.modifiers);
+    const relativePath = getRelativePath(replacedPath, baseDir);
+    image.generate = joinURL(`/${baseDir}`, modifierSegment === "_" ? "" : modifierSegment, relativePath);
+    if (originalExt) {
+      image.generate = image.generate.replace(originalExt, image.ext);
+    } else if (!image.generate.includes(".") && image.ext) {
+      image.generate += image.ext;
+    }
+    stateImages.generate[image.url] = image;
+    if (image.src && image.generate && image.modifiers) {
+      runtime.onGenerate?.({
+        ...image,
+        src: image.src,
+        generate: image.generate,
+        modifiers: image.modifiers
+      });
+    }
+    const src = runtime.generateOutput && image.generate ? image.generate : image.url;
+    if (resolvedOptions._meta) {
+      const meta = { ...stateImages.all[input] || { name: input, alt: void 0, title: void 0 } };
+      if (!meta.alt) {
+        meta.alt = getNormalName(meta.name);
+      }
+      if (!meta.title) {
+        meta.title = getNormalName(meta.name);
+      }
+      delete meta.name;
+      return { src, ...meta };
+    }
+    return src;
+  });
+  getImage.getSizes = (input, opts) => {
+    const width = parseSize(opts.modifiers?.width);
+    const height = parseSize(opts.modifiers?.height);
+    const hwRatio = width && height ? height / width : 0;
+    const variants = [];
+    const sizes = {};
+    if (typeof opts.sizes === "string") {
+      for (const entry of opts.sizes.split(/[\s,]+/).filter(Boolean)) {
+        const sizeEntry = entry.split(":");
+        if (sizeEntry.length !== 2) {
+          continue;
+        }
+        sizes[sizeEntry[0].trim()] = sizeEntry[1].trim();
+      }
+    } else {
+      Object.assign(sizes, opts.sizes);
+    }
+    for (const key in sizes) {
+      const screenMaxWidth = imagesOptions.screens?.[key] || Number.parseInt(key, 10);
+      let size = String(sizes[key]);
+      const isFluid = size.endsWith("vw");
+      if (!isFluid && /^\d+$/.test(size)) {
+        size = `${size}px`;
+      }
+      if (!isFluid && !size.endsWith("px")) {
+        continue;
+      }
+      let calculatedWidth = Number.parseInt(size, 10);
+      if (!screenMaxWidth || !calculatedWidth) {
+        continue;
+      }
+      if (isFluid) {
+        calculatedWidth = Math.round(calculatedWidth / 100 * screenMaxWidth);
+      }
+      const calculatedHeight = hwRatio ? Math.round(calculatedWidth * hwRatio) : height;
+      const resizeConfig = opts.modifiers?.resize;
+      const resize = resizeConfig?.[screenMaxWidth] || resizeConfig?.["*"];
+      const positionConfig = opts.modifiers?.position;
+      const position = positionConfig?.[screenMaxWidth] || positionConfig?.["*"] || positionConfig;
+      const currentModifiers = {
+        ...opts.modifiers,
+        width: calculatedWidth,
+        height: calculatedHeight,
+        resize,
+        position
+      };
+      if (resize) {
+        delete currentModifiers.width;
+      }
+      variants.push({
+        width: calculatedWidth,
+        size,
+        screenMaxWidth,
+        media: `(max-width: ${screenMaxWidth}px)`,
+        src: getImage(input, currentModifiers, opts)
+      });
+    }
+    variants.sort((left, right) => left.screenMaxWidth - right.screenMaxWidth);
+    const defaultVariant = variants[variants.length - 1];
+    if (defaultVariant) {
+      defaultVariant.media = "";
+    }
+    return {
+      sizes: variants.map((variant) => `${variant.media ? `${variant.media} ` : ""}${variant.size}`).join(", "),
+      srcset: variants.map((variant) => `${variant.src} ${variant.width}w`).join(", "),
+      src: defaultVariant?.src
+    };
+  };
+  return {
+    getImage
+  };
+}

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

@@ -0,0 +1,2 @@
+import type { FlowImageMeta } from './types.ts';
+export declare function loadImageRenames(sources: string[]): Record<string, FlowImageMeta>;

package/modules/images/runtime/renames.mjs

@@ -0,0 +1,79 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { joinURL } from "ufo";
+const RENAME_FILE = "_rename";
+function normalizePublicPath(path) {
+  return `/${path}`.replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+function isHeaderLine(original, renamed) {
+  return original.toLowerCase().includes("nombre") && renamed.toLowerCase().includes("nuevo");
+}
+function walkRenameFiles(rootDir, currentDir = rootDir, files = []) {
+  if (!existsSync(currentDir)) {
+    return files;
+  }
+  for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
+    const entryPath = join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      walkRenameFiles(rootDir, entryPath, files);
+      continue;
+    }
+    if (entry.isFile() && entry.name === RENAME_FILE) {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+function toPublicImagePath(rootDir, manifestDir, fileName) {
+  const relativeDir = relative(rootDir, manifestDir).split(sep).join("/");
+  return normalizePublicPath(joinURL(relativeDir, fileName));
+}
+function parseRenameLine(rootDir, filePath, line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("//")) {
+    return void 0;
+  }
+  const [original, renamed, title, ...altParts] = trimmed.split(/\s+/);
+  if (!original || !renamed || isHeaderLine(original, renamed)) {
+    return void 0;
+  }
+  const sourceExt = extname(original);
+  const renamedWithExt = extname(renamed) ? renamed : `${renamed}${sourceExt}`;
+  const manifestDir = dirname(filePath);
+  const sourcePath = toPublicImagePath(rootDir, manifestDir, original);
+  const renamedPath = toPublicImagePath(rootDir, manifestDir, renamedWithExt);
+  return {
+    key: sourcePath,
+    value: {
+      rename: renamedPath,
+      name: basename(renamedWithExt, extname(renamedWithExt)),
+      title,
+      alt: altParts.length ? altParts.join(" ") : void 0
+    }
+  };
+}
+function readRenameDirectory(rootDir) {
+  const entries = {};
+  for (const filePath of walkRenameFiles(resolve(rootDir))) {
+    const raw = readFileSync(filePath, "utf8");
+    for (const line of raw.split(/\r?\n/)) {
+      const parsed = parseRenameLine(rootDir, filePath, line);
+      if (!parsed) {
+        continue;
+      }
+      entries[parsed.key] = parsed.value;
+    }
+  }
+  return entries;
+}
+export function loadImageRenames(sources) {
+  return sources.reduce((collection, source) => {
+    if (!source || !existsSync(source)) {
+      return collection;
+    }
+    return {
+      ...collection,
+      ...readRenameDirectory(source)
+    };
+  }, {});
+}

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

@@ -0,0 +1,3 @@
+import type { FlowImageRuntimeUtils, FlowImagesRuntimeConfig } from './types.ts';
+export declare function getFlowImageRuntimeUtils(config?: FlowImagesRuntimeConfig | undefined): FlowImageRuntimeUtils | undefined;
+export declare function resetFlowImageRuntimeState(): void;

package/modules/images/runtime/server.mjs

@@ -0,0 +1,80 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname } from "node:path";
+import process from "node:process";
+import { createImageResolver } from "./image.mjs";
+import { loadImageRenames } from "./renames.mjs";
+let runtimeConfigRequire;
+let cachedKey;
+let cachedUtils;
+let generatedEntryKeys = /* @__PURE__ */ new Set();
+function getEnvFlowImagesRuntimeConfig() {
+  const raw = process.env.FLOW_IMAGES_RUNTIME_CONFIG;
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function getFlowImagesRuntimeConfig() {
+  try {
+    runtimeConfigRequire ??= createRequire(import.meta.url);
+    const runtime = runtimeConfigRequire("nitro/runtime-config");
+    return runtime.useRuntimeConfig?.().flow?.images || getEnvFlowImagesRuntimeConfig();
+  } catch {
+    return getEnvFlowImagesRuntimeConfig();
+  }
+}
+export function getFlowImageRuntimeUtils(config = getFlowImagesRuntimeConfig()) {
+  if (!config) {
+    return void 0;
+  }
+  const cacheKey = JSON.stringify(config);
+  const useCache = process.env.NODE_ENV === "production";
+  if (useCache && cachedKey === cacheKey && cachedUtils) {
+    return cachedUtils;
+  }
+  const renameSources = [config.dirRenames, config.publicDir].filter(Boolean);
+  const images = {
+    all: loadImageRenames(renameSources),
+    generate: {}
+  };
+  const resolver = createImageResolver(config.options, images, {
+    generateOutput: config.generate,
+    onGenerate(image) {
+      if (!config.generatedManifestPath) {
+        return;
+      }
+      const dedupeKey = `${image.url}:${image.generate}`;
+      if (generatedEntryKeys.has(dedupeKey)) {
+        return;
+      }
+      generatedEntryKeys.add(dedupeKey);
+      mkdirSync(dirname(config.generatedManifestPath), { recursive: true });
+      appendFileSync(config.generatedManifestPath, `${JSON.stringify(image)}
+`, "utf8");
+    }
+  });
+  const utils = {
+    getImage: resolver.getImage,
+    getImageMeta(src) {
+      return images.all[src];
+    },
+    getImageOptions() {
+      return { ...config.options };
+    }
+  };
+  if (useCache) {
+    cachedKey = cacheKey;
+    cachedUtils = utils;
+  }
+  return utils;
+}
+export function resetFlowImageRuntimeState() {
+  generatedEntryKeys = /* @__PURE__ */ new Set();
+  cachedKey = void 0;
+  cachedUtils = void 0;
+}

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

@@ -0,0 +1,79 @@
+export interface FlowImagesModuleOptions {
+    dirRenames: string;
+    dirFiles: string[];
+    buildBatchSize: number;
+    lazy: boolean;
+    screens: Record<string, number>;
+    domains?: Record<string, string>;
+    presets: Record<string, Record<string, unknown>>;
+    baseURL: string;
+    dirImages: string;
+}
+export type FlowImageOptions = Omit<FlowImagesModuleOptions, 'dirRenames' | 'dirFiles' | 'buildBatchSize'>;
+export interface FlowImageMeta {
+    rename?: string;
+    name: string;
+    alt?: string;
+    title?: string;
+}
+export interface ImageModifiers {
+    width?: number;
+    height?: number;
+    fit?: string;
+    format?: string;
+    [key: string]: any;
+}
+export interface ImageOptions {
+    provider?: string;
+    preset?: string;
+    rename?: string;
+    modifiers?: Partial<ImageModifiers>;
+    _meta?: boolean;
+    [key: string]: any;
+}
+export interface ImageSizesOptions extends ImageOptions {
+    sizes: Record<string, string | number> | string;
+}
+export interface ImageSizes {
+    srcset: string;
+    sizes: string;
+    src?: string;
+}
+export interface ResolvedImage {
+    url: string;
+    format?: string;
+    src?: string;
+    ext?: string;
+    generate?: string;
+    modifiers?: Record<string, string>;
+}
+export interface GeneratedImageEntry extends ResolvedImage {
+    src: string;
+    generate: string;
+    modifiers: Record<string, string>;
+}
+export type GetImageFunction = ((input: string, modifiers?: Record<string, any>, options?: ImageOptions) => string | Record<string, unknown>) & {
+    getSizes: (input: string, options: ImageSizesOptions) => ImageSizes;
+};
+export interface FlowImagesState {
+    all: Record<string, FlowImageMeta>;
+    generate: Record<string, unknown>;
+}
+export interface FlowImagesRuntimeConfig {
+    dirRenames: string;
+    dirFiles: string[];
+    buildBatchSize?: number;
+    publicDir: string;
+    outputDir: string;
+    generatedManifestPath: string;
+    generatedCacheDir?: string;
+    generatedCacheManifestPath?: string;
+    generate: boolean;
+    netlifyCache: boolean;
+    options: FlowImageOptions;
+}
+export interface FlowImageRuntimeUtils {
+    getImage: GetImageFunction;
+    getImageMeta: (src: string) => FlowImageMeta | undefined;
+    getImageOptions: () => FlowImageOptions;
+}

package/modules/sitemap/handler.mjs

@@ -1,17 +1,16 @@
 import { defineEventHandler, getRequestURL, setHeader } from "nitro/h3";
 import { useRuntimeConfig } from "nitro/runtime-config";
 import { getUrls } from "../../server/lib/pages.mjs";
-function escapeXml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
+import { buildSitemapXml } from "./xml.mjs";
 export default defineEventHandler(async (event) => {
   const urls = await getUrls(true, true);
   const runtimeConfig = useRuntimeConfig();
   const origin = runtimeConfig.flow?.siteUrl || getRequestURL(event).origin;
-  const xml = `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${urls.map((entry) => typeof entry === "string" ? `  <url><loc>${escapeXml(new URL(entry, origin).toString())}</loc></url>` : `  <url><loc>${escapeXml(new URL(entry.url, origin).toString())}</loc><xhtml:link rel="alternate" hreflang="${escapeXml(entry.locale)}" href="${escapeXml(new URL(entry.url, origin).toString())}" xmlns:xhtml="http://www.w3.org/1999/xhtml" /></url>`).join("\n")}
-</urlset>`;
+  const xml = buildSitemapXml(urls, origin, {
+    locales: runtimeConfig.flow?.locale?.locales || ["es-ec"],
+    language: runtimeConfig.flow?.locale?.language || "es",
+    location: runtimeConfig.flow?.locale?.location || "ec"
+  });
   setHeader(event, "content-type", "application/xml; charset=utf-8");
   return xml;
 });