@monkeyplus/flow 6.0.17 → 6.0.19

package/modules/cms/server/lib/widgets.mjs

@@ -0,0 +1,200 @@
+import { join } from "node:path";
+import { mapObjIndexed } from "./helpers.mjs";
+function returnWidget(widget, options = {}) {
+  return (name, _ctx) => ({
+    name,
+    ...widget,
+    label: name,
+    ...options
+  });
+}
+export function boolean(options) {
+  return returnWidget(
+    { widget: "boolean" },
+    options
+  );
+}
+export function editor(options) {
+  return returnWidget(
+    { widget: "editor" },
+    options
+  );
+}
+export function color(options) {
+  return returnWidget(
+    { widget: "color" },
+    options
+  );
+}
+export function dateTime(options) {
+  return returnWidget(
+    { widget: "date" },
+    options
+  );
+}
+export function list(options) {
+  return (id, ctx) => {
+    return object(
+      { ...options, widget: "list", fields: options.fields }
+    )(id, ctx);
+  };
+}
+export function number(options) {
+  return returnWidget(
+    { widget: "number" },
+    options
+  );
+}
+export function object(options) {
+  return (id, ctx) => {
+    const _fields = mapObjIndexed((buildField, id2) => {
+      return buildField(id2, ctx);
+    }, options.fields);
+    return {
+      name: id,
+      widget: "object",
+      ...options,
+      fields: Object.values(_fields)
+    };
+  };
+}
+export function select(options) {
+  return returnWidget(
+    { widget: "select" },
+    options
+  );
+}
+export function text(options) {
+  return returnWidget({ widget: "text" }, options);
+}
+export function string(options) {
+  return returnWidget(
+    { widget: "string" },
+    options
+  );
+}
+export function file(options) {
+  return returnWidget({ widget: "file" }, options);
+}
+export function image(options) {
+  return (name, ctx) => {
+    if (options?.mediaFolder)
+      options.mediaFolder = join("", options.mediaFolder);
+    return returnWidget(
+      { widget: "image" },
+      options
+    )(name, ctx);
+  };
+}
+export function imageObject(options) {
+  return (name, ctx) => {
+    if (options?.mediaFolder)
+      options.mediaFolder = join("", options.mediaFolder);
+    return {
+      name,
+      widget: "object",
+      label: options?.label,
+      collapsed: false,
+      fields: [
+        returnWidget(
+          { widget: "image" },
+          options
+        )("src", ctx),
+        returnWidget(
+          { widget: "string" },
+          {
+            required: false
+          }
+        )("alt", {
+          ...ctx
+        }),
+        returnWidget(
+          { widget: "string" },
+          {
+            required: false
+          }
+        )("title", ctx),
+        returnWidget(
+          { widget: "string" },
+          {
+            required: false
+          }
+        )("rename", ctx)
+      ]
+    };
+  };
+}
+export function link(options) {
+  return (name, ctx) => {
+    return {
+      name,
+      widget: "object",
+      label: options?.label,
+      ...options,
+      fields: [
+        // Label
+        returnWidget(
+          { widget: "string" },
+          { label: "Texto" }
+        )("label", ctx),
+        // Link
+        returnWidget(
+          { widget: "select" },
+          {
+            required: false,
+            items: ["Interna", "Externa"]
+          }
+        )("type", {
+          ...ctx
+        }),
+        // Link
+        returnWidget(
+          { widget: "string" },
+          {
+            required: false,
+            label: "Link",
+            options: {
+              show: {
+                type: "Externa"
+              }
+            }
+          }
+        )("link", {
+          ...ctx
+        }),
+        // Link 2
+        returnWidget(
+          { widget: "select" },
+          {
+            label: "P\xE1gina",
+            required: false,
+            items: ["uno", "dos"],
+            options: {
+              alias: "link",
+              list: "pages",
+              show: {
+                type: "Interna"
+              }
+            }
+          }
+        )("link2", ctx)
+      ]
+    };
+  };
+}
+export const widgets = {
+  string,
+  color,
+  number,
+  file,
+  dateTime,
+  image,
+  editor,
+  object,
+  boolean,
+  list,
+  text,
+  select,
+  imageObject,
+  link
+};

package/modules/cms/server/trial.d.ts

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

package/modules/cms/server/trial.mjs

@@ -0,0 +1,8 @@
+import { defineEventHandler, getRouterParams } from "nitro/h3";
+export default defineEventHandler(async (event) => {
+  const params = getRouterParams(event);
+  return {
+    message: "hello",
+    params
+  };
+});

package/modules/content/query.mjs

@@ -1,4 +1,5 @@
 import { extname } from "node:path";
+import { consola } from "consola";
 import { defineEventHandler, getQuery, getRequestURL } from "nitro/h3";
 import { useStorage } from "nitro/storage";
 function normalizeQueryPath(path) {
@@ -85,6 +86,31 @@ function parseContentFile(keyPath, raw) {
   };
 }
 export async function readContentEntries() {
+  const applyCmsPreview = (entries2) => {
+    try {
+      const previewData = globalThis.__cmsPreviewData;
+      if (previewData) {
+        for (const [rawKey, payload] of Object.entries(previewData)) {
+          if (!payload || typeof payload !== "object")
+            continue;
+          let targetPath = rawKey;
+          if (targetPath.startsWith("/content/")) {
+            targetPath = targetPath.slice(8);
+          }
+          targetPath = targetPath.replace(/\.(json|md|yaml|yml|txt)$/i, "");
+          const entry = entries2.find((e) => e.path === targetPath);
+          if (entry) {
+            entry.data = { ...entry.data, ...payload };
+            if ("title" in payload) {
+              entry.title = payload.title;
+            }
+          }
+        }
+      }
+    } catch (e) {
+    }
+    return entries2;
+  };
   const storage = useStorage("content");
   const keys = await storage.getKeys();
   const entries = [];
@@ -116,9 +142,10 @@ export async function readContentEntries() {
         await walkDir(contentDir, contentDir);
       } catch (e) {
       }
-      return entries.sort((left, right) => left.path.localeCompare(right.path));
+      const sorted = entries.sort((left, right) => left.path.localeCompare(right.path));
+      return applyCmsPreview(sorted);
     } catch (e) {
-      console.error("[Flow Content] fs fallback failed:", e);
+      consola.error("[Flow Content] fs fallback failed:", e);
     }
   }
   for (const key of keys) {
@@ -133,7 +160,8 @@ export async function readContentEntries() {
       entries.push(entry);
     }
   }
-  return entries.sort((left, right) => left.path.localeCompare(right.path));
+  const sortedEntries = entries.sort((left, right) => left.path.localeCompare(right.path));
+  return applyCmsPreview(sortedEntries);
 }
 function sortTree(nodes) {
   nodes.sort((left, right) => {

package/modules/images/ipx.mjs

@@ -1,8 +1,10 @@
 import process from "node:process";
+import { consola } from "consola";
 import { createIPX, createIPXH3Handler, ipxFSStorage, ipxHttpStorage } from "ipx";
 import { defineHandler } from "nitro";
 import { getRequestURL } from "nitro/h3";
 import { useRuntimeConfig } from "nitro/runtime-config";
+import { withWatermark } from "./watermark.mjs";
 let cachedDir = "";
 let cachedDomainsKey = "";
 let cachedHandler;
@@ -36,13 +38,13 @@ function resolveHandler() {
         httpStorage: ipxHttpStorage({ domains })
       } : {}
     });
-    cachedHandler = createIPXH3Handler(ipx);
+    cachedHandler = createIPXH3Handler(withWatermark(ipx));
   }
   return cachedHandler;
 }
 export default defineHandler(async (event) => {
   if (!getRequestURL(event)?.pathname.startsWith("/_ipx")) {
-    console.log("route", event.req.url.toString());
+    consola.log("route", event.req.url.toString());
     return;
   }
   const handler = resolveHandler();

package/modules/images/module.d.ts

@@ -1,4 +1,3 @@
 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

@@ -1,12 +1,14 @@
 import { rmSync } from "node:fs";
 import { resolve } from "node:path";
 import process from "node:process";
+import { consola } from "consola";
 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";
+import { withWatermark } from "./watermark.mjs";
 function withoutTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
@@ -51,7 +53,7 @@ function createIpxDevServerPlugin(imagesRuntimeConfig) {
           storage: ipxFSStorage({ dir: imagesRuntimeConfig.publicDir }),
           ...domains.length ? { httpStorage: ipxHttpStorage({ domains }) } : {}
         });
-        middleware = createIPXNodeServer(ipx);
+        middleware = createIPXNodeServer(withWatermark(ipx));
       }
       server.middlewares.use("/_ipx", (req, res, next) => {
         try {
@@ -78,7 +80,7 @@ export default defineFlowModule({
     lazy: true,
     screens,
     baseURL: "/_ipx",
-    dirImages: "/images",
+    dirImages: "/assets/images",
     domains: {},
     presets: {}
   },
@@ -129,7 +131,7 @@ export default defineFlowModule({
         }
         const result = await materializeGeneratedImages(imagesRuntimeConfig);
         if (result.total > 0) {
-          console.log(
+          consola.log(
             `[flow:images] materialized ${result.total} images (${result.generated} generated, ${result.cacheHits} cache hits${imagesRuntimeConfig.netlifyCache && process.env.NETLIFY ? ", netlify cache enabled" : ""})`
           );
         }

package/modules/images/runtime/build.mjs

@@ -129,6 +129,12 @@ export async function materializeGeneratedImages(config) {
   let cacheHits = 0;
   let generated = 0;
   const batchSize = resolveConfiguredBatchSize(config.buildBatchSize);
+  const originalSourcesToDelete = /* @__PURE__ */ new Set();
+  for (const image of images) {
+    if (image.isRenamed) {
+      originalSourcesToDelete.add(image.src);
+    }
+  }
   for (const batch of createBatches(images, batchSize)) {
     const results = await Promise.all(batch.map(async (image) => {
       const signature = await createSignature(image, config.publicDir);
@@ -166,6 +172,12 @@ export async function materializeGeneratedImages(config) {
     await writeFile(config.generatedCacheManifestPath, `${JSON.stringify(nextManifest, null, 2)}
 `, "utf8");
   }
+  for (const src of originalSourcesToDelete) {
+    const originalPath = outputFilePath(config.outputDir, src);
+    if (existsSync(originalPath)) {
+      await rm(originalPath, { force: true });
+    }
+  }
   return {
     cacheHits,
     generated,

package/modules/images/runtime/image.mjs

@@ -158,7 +158,7 @@ export function createImageResolver(imagesOptions, stateImages, runtime = {}) {
     image.ext = image.format && `.${image.format}` || guessExt(logicalInput);
     let baseDir = isStrapi ? normalizeDirImages(imagesOptions.dirImages) : getBaseDir(sourceInput, imagesOptions.dirImages);
     const originalExt = guessExt(logicalInput);
-    let renamedImage = stateImages.all[logicalInput]?.rename;
+    let renamedImage = stateImages.all[sourceInput]?.rename || stateImages.all[logicalInput]?.rename;
     if (!renamedImage && imagesOptions.domains) {
       renamedImage = resolveRemoteRename(sourceInput, imagesOptions.domains);
     }
@@ -181,12 +181,13 @@ export function createImageResolver(imagesOptions, stateImages, runtime = {}) {
         ...image,
         src: image.src,
         generate: image.generate,
-        modifiers: image.modifiers
+        modifiers: image.modifiers,
+        isRenamed: !!resolvedOptions.rename || !!renamedImage
       });
     }
     const src = runtime.generateOutput && image.generate ? image.generate : image.url;
     if (resolvedOptions._meta) {
-      const meta = { ...stateImages.all[logicalInput] || { name: logicalInput, alt: void 0, title: void 0 } };
+      const meta = { ...stateImages.all[sourceInput] || stateImages.all[logicalInput] || { name: logicalInput, alt: void 0, title: void 0 } };
       if (!meta.alt) {
         meta.alt = getNormalName(meta.name);
       }

package/modules/images/runtime/renames.mjs

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
 import { joinURL } from "ufo";
+import { consola } from "consola";
 const RENAME_FILE = "_rename";
 function normalizePublicPath(path) {
   return `/${path}`.replace(/\\/g, "/").replace(/\/+/g, "/");
@@ -28,27 +29,57 @@ function toPublicImagePath(rootDir, manifestDir, fileName) {
   const relativeDir = relative(rootDir, manifestDir).split(sep).join("/");
   return normalizePublicPath(joinURL(relativeDir, fileName));
 }
+function formatKebabCase(str) {
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "").trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9\-]/g, "").replace(/-+/g, "-");
+}
+function findOriginalExtension(manifestDir, baseName) {
+  try {
+    for (const entry of readdirSync(manifestDir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name !== RENAME_FILE) {
+        const ext = extname(entry.name);
+        const nameWithoutExt = basename(entry.name, ext);
+        if (nameWithoutExt === baseName) {
+          return ext;
+        }
+      }
+    }
+  } catch {
+  }
+  return "";
+}
 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)) {
+  const parts = trimmed.split("|").map((s) => s.trim());
+  let original = parts[0];
+  const rawRenamed = parts[1];
+  const title = parts[2];
+  const alt = parts[3];
+  if (!original || !rawRenamed || isHeaderLine(original, rawRenamed)) {
     return void 0;
   }
-  const sourceExt = extname(original);
-  const renamedWithExt = extname(renamed) ? renamed : `${renamed}${sourceExt}`;
   const manifestDir = dirname(filePath);
+  let sourceExt = extname(original);
+  if (!sourceExt) {
+    sourceExt = findOriginalExtension(manifestDir, original);
+    if (sourceExt) {
+      original = `${original}${sourceExt}`;
+    }
+  }
+  const rawRenamedExt = extname(rawRenamed);
+  const renamedBase = formatKebabCase(rawRenamedExt ? basename(rawRenamed, rawRenamedExt) : rawRenamed);
+  const renamedWithExt = rawRenamedExt ? `${renamedBase}${rawRenamedExt}` : `${renamedBase}${sourceExt}`;
   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
+      name: renamedBase,
+      title: title || void 0,
+      alt: alt || void 0
     }
   };
 }
@@ -67,7 +98,7 @@ function readRenameDirectory(rootDir) {
   return entries;
 }
 export function loadImageRenames(sources) {
-  return sources.reduce((collection, source) => {
+  const allEntries = sources.reduce((collection, source) => {
     if (!source || !existsSync(source)) {
       return collection;
     }
@@ -76,4 +107,24 @@ export function loadImageRenames(sources) {
       ...readRenameDirectory(source)
     };
   }, {});
+  const renamedToOriginal = {};
+  for (const [originalPath, meta] of Object.entries(allEntries)) {
+    const renamedPath = meta.rename;
+    if (!renamedToOriginal[renamedPath]) {
+      renamedToOriginal[renamedPath] = [];
+    }
+    renamedToOriginal[renamedPath].push(originalPath);
+  }
+  for (const [renamedPath, originalPaths] of Object.entries(renamedToOriginal)) {
+    if (originalPaths.length > 1) {
+      consola.warn(
+        `
+[Flow Images] \u26A0\uFE0F ALERTA: M\xFAltiples im\xE1genes intentan renombrarse al mismo destino "${renamedPath}".
+Im\xE1genes originales:
+${originalPaths.map((p) => `  - ${p}`).join("\n")}
+`
+      );
+    }
+  }
+  return allEntries;
 }

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

@@ -16,11 +16,33 @@ export interface FlowImageMeta {
     alt?: string;
     title?: string;
 }
+export interface WatermarkOptions {
+    text?: string;
+    image?: string;
+    opacity?: number;
+    position?: string;
+    x?: number;
+    y?: number;
+    color?: string;
+    background?: string;
+    fontSize?: number;
+    fontWeight?: string;
+    ratio?: number;
+}
 export interface ImageModifiers {
-    width?: number;
-    height?: number;
-    fit?: string;
-    format?: string;
+    width?: number | string;
+    height?: number | string;
+    fit?: 'contain' | 'cover' | 'fill' | 'inside' | 'outside' | string;
+    format?: 'auto' | 'webp' | 'jpeg' | 'png' | 'avif' | 'gif' | string;
+    quality?: number | string;
+    background?: string;
+    blur?: number | string;
+    trim?: number | string;
+    position?: 'top' | 'right top' | 'right' | 'right bottom' | 'bottom' | 'left bottom' | 'left' | 'left top' | 'center' | string;
+    grayscale?: boolean | string;
+    rotate?: number | string;
+    size?: string;
+    watermark?: boolean | string | WatermarkOptions;
     [key: string]: any;
 }
 export interface ImageOptions {
@@ -51,6 +73,7 @@ export interface GeneratedImageEntry extends ResolvedImage {
     src: string;
     generate: string;
     modifiers: Record<string, string>;
+    isRenamed?: boolean;
 }
 export type GetImageFunction = ((input: string, modifiers?: Record<string, any>, options?: ImageOptions) => string | Record<string, unknown>) & {
     getSizes: (input: string, options: ImageSizesOptions) => ImageSizes;

package/modules/images/watermark.d.ts

@@ -0,0 +1 @@
+export declare function withWatermark(ipxInstance: any): (id: string, modifiers?: Record<string, string>, opts?: any) => any;

package/modules/images/watermark.mjs

@@ -0,0 +1,113 @@
+import { Buffer } from "node:buffer";
+import { resolve } from "node:path";
+import process from "node:process";
+import { consola } from "consola";
+const positionsMap = {
+  "top": "north",
+  "bottom": "south",
+  "center": "center",
+  "centre": "centre",
+  "left": "west",
+  "right": "east",
+  "top-left": "northwest",
+  "top-right": "northeast",
+  "bottom-left": "southwest",
+  "bottom-right": "southeast",
+  "southeast": "southeast",
+  "southwest": "southwest",
+  "northeast": "northeast",
+  "northwest": "northwest",
+  "north": "north",
+  "south": "south",
+  "east": "east",
+  "west": "west"
+};
+function getAlpha(opacity) {
+  if (opacity === void 0)
+    return "e6";
+  return Math.round(opacity * 255).toString(16).padStart(2, "0");
+}
+export function withWatermark(ipxInstance) {
+  return (id, modifiers = {}, opts = {}) => {
+    const hasWatermark = modifiers.watermark !== void 0;
+    const watermarkRaw = typeof modifiers.watermark === "string" && modifiers.watermark !== "true" && modifiers.watermark !== "" ? modifiers.watermark : "WATERMARK";
+    if (hasWatermark) {
+      delete modifiers.watermark;
+    }
+    const instance = ipxInstance(id, modifiers, opts);
+    const origProcess = instance.process;
+    instance.process = async () => {
+      const res = await origProcess();
+      if (hasWatermark && res.data && typeof res.data !== "string" && res.format !== "gif" && res.format !== "svg") {
+        try {
+          const sharp = (await import("sharp")).default;
+          let watermarkOptions = {
+            text: "WATERMARK",
+            opacity: 0.9,
+            position: "southeast",
+            color: "#ffffff",
+            background: "#00000080",
+            fontWeight: "bold"
+          };
+          if (modifiers.watermark !== "true") {
+            const decodedText = decodeURIComponent(watermarkRaw).replace(/_/g, " ");
+            if (decodedText.startsWith("b64")) {
+              try {
+                const jsonStr = Buffer.from(decodedText.slice(3), "base64").toString("utf-8");
+                const parsed = JSON.parse(jsonStr);
+                watermarkOptions = { ...watermarkOptions, ...parsed };
+              } catch (e) {
+                consola.error("[flow:images] Error parsing watermark b64:", e);
+                watermarkOptions.text = decodedText;
+              }
+            } else {
+              watermarkOptions.text = decodedText;
+            }
+          }
+          consola.log("[flow:images] Aplicando marca de agua din\xE1mica:", watermarkOptions);
+          const gravity = positionsMap[watermarkOptions.position || "southeast"] || "southeast";
+          if (watermarkOptions.image) {
+            const watermarkPath = resolve(process.cwd(), watermarkOptions.image);
+            let watermarkBuffer = await sharp(watermarkPath).toBuffer();
+            if (watermarkOptions.ratio) {
+              const mainMeta = await sharp(res.data).metadata();
+              const waterMarkWidth = Math.round((mainMeta.width || 1e3) * watermarkOptions.ratio);
+              watermarkBuffer = await sharp(watermarkBuffer).resize(waterMarkWidth).toBuffer();
+            }
+            res.data = await sharp(res.data).composite([{
+              input: watermarkBuffer,
+              gravity,
+              top: watermarkOptions.y,
+              left: watermarkOptions.x,
+              blend: "over"
+            }]).toBuffer();
+          } else {
+            const text = watermarkOptions.text || "WATERMARK";
+            const color = watermarkOptions.color || "#ffffff";
+            const weight = watermarkOptions.fontWeight || "bold";
+            const pangoMarkup = `<span foreground="${color}"  font_weight="${weight}"> ${text} </span>`;
+            res.data = await sharp(res.data).composite([{
+              input: {
+                text: {
+                  text: pangoMarkup,
+                  rgba: true,
+                  dpi: watermarkOptions.fontSize ? watermarkOptions.fontSize * 5 : 150,
+                  // rough dpi estimation based on size
+                  align: "center"
+                }
+              },
+              gravity,
+              top: watermarkOptions.y,
+              left: watermarkOptions.x,
+              blend: "over"
+            }]).toBuffer();
+          }
+        } catch (err) {
+          consola.error("[flow:images] Error applying watermark:", err);
+        }
+      }
+      return res;
+    };
+    return instance;
+  };
+}

package/modules/netlify-cms/handler.mjs

@@ -1,5 +1,6 @@
+import { consola } from "consola";
 import { defineEventHandler } from "nitro/h3";
-console.log("Loading handler.ts");
+consola.log("Loading handler.ts");
 export default defineEventHandler(async (event) => {
   return "hola";
 });