@monkeyplus/flow 6.0.29 → 6.0.31

package/modules/images/cli-pregenerate.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/modules/images/cli-pregenerate.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import process from "node:process";
+import { consola } from "consola";
+import { createJiti } from "jiti";
+import { materializeGeneratedImages } from "./runtime/build.mjs";
+import { screens } from "./runtime/helpers.mjs";
+function withoutTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function resolveStrapiUrl(flowConfig) {
+  const strapi = flowConfig.strapi;
+  return typeof strapi?.url === "string" && strapi.url ? withoutTrailingSlash(strapi.url) : void 0;
+}
+function resolveStrapiDomains(flowConfig, dirImages) {
+  const strapiUrl = resolveStrapiUrl(flowConfig);
+  if (!strapiUrl) return {};
+  try {
+    const url = new URL(strapiUrl);
+    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 {};
+  }
+}
+async function run() {
+  const projectRoot = process.cwd();
+  const publicDir = resolve(projectRoot, "public");
+  const outputDir = publicDir;
+  const imagesCacheRoot = resolve(projectRoot, "node_modules/.cache-images");
+  const generatedManifestPath = resolve(imagesCacheRoot, "generated-images.jsonl");
+  let flowConfig = {};
+  try {
+    const jiti = createJiti(resolve(projectRoot, "flow.config.ts"), { fsCache: false, moduleCache: false });
+    const loaded = jiti(resolve(projectRoot, "flow.config.ts"));
+    flowConfig = (loaded?.default ?? loaded) || {};
+  } catch (error) {
+    consola.warn("No se pudo cargar flow.config.ts, usando valores por defecto.", error.message);
+  }
+  const userImagesConfig = flowConfig.images || {};
+  const dirImages = userImagesConfig.dirImages ?? "/assets/images";
+  const resolvedDomains = {
+    ...resolveStrapiDomains(flowConfig, dirImages),
+    ...userImagesConfig.domains || {}
+  };
+  const options = {
+    lazy: userImagesConfig.lazy ?? true,
+    screens: userImagesConfig.screens ?? screens,
+    domains: resolvedDomains,
+    presets: userImagesConfig.presets ?? {},
+    baseURL: userImagesConfig.baseURL ?? "/_ipx",
+    dirImages
+  };
+  const dirRenames = userImagesConfig.dirRenames ? resolve(projectRoot, userImagesConfig.dirRenames) : resolve(projectRoot, "shared/seo_images");
+  const config = {
+    dirRenames,
+    dirFiles: userImagesConfig.dirFiles || ["images", "media"],
+    buildBatchSize: userImagesConfig.buildBatchSize || 8,
+    publicDir,
+    outputDir,
+    generatedManifestPath,
+    generate: true,
+    netlifyCache: false,
+    options
+  };
+  consola.info("Iniciando generaci\xF3n local de im\xE1genes en la carpeta public...");
+  try {
+    const result = await materializeGeneratedImages(config);
+    consola.success(`[flow:images] Se han generado exitosamente ${result.total} im\xE1genes en public/ (${result.generated} nuevas generadas, ${result.cacheHits} omitidas por cach\xE9).`);
+  } catch (error) {
+    consola.error("Error al generar las im\xE1genes localmente:", error);
+    process.exit(1);
+  }
+}
+run().catch(console.error);

package/modules/images/runtime/build.mjs

@@ -148,6 +148,11 @@ export async function materializeGeneratedImages(config) {
       const cachePath = config.generatedCacheDir ? outputFilePath(config.generatedCacheDir, cacheRelativePath) : void 0;
       activeCacheFiles.add(cacheRelativePath);
       await ensureParentDir(outputPath);
+      const publicPreGeneratedPath = outputFilePath(config.publicDir, image.generate);
+      if (existsSync(publicPreGeneratedPath)) {
+        await copyFile(publicPreGeneratedPath, outputPath);
+        return { cacheHit: 1, generated: 0 };
+      }
       if (config.netlifyCache && cachePath && previousManifest[imageKey]?.signature === signature && existsSync(cachePath)) {
         await copyFile(cachePath, outputPath);
         return { cacheHit: 1, generated: 0 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "6.0.29",
+  "version": "6.0.31",
   "description": "@monkeyplus/flow package-first runtime with Vite, Nitro, Vue and a workspace playground.",
   "license": "MIT",
   "publishConfig": {

package/server/lib/render.mjs

@@ -133,6 +133,13 @@ async function renderBody(page) {
     }
   });
   const app = createSSRApp(TemplateRoot);
+  app.config.warnHandler = (msg, instance, trace) => {
+    const cleanTrace = trace.split("\n").map((line) => {
+      return line.length > 200 ? line.substring(0, 200) + " ... >" : line;
+    }).join("\n");
+    console.warn(`[Vue warn]: ${msg}
+${cleanTrace}`);
+  };
   app.provide("context", context);
   app.provide("utils", utils);
   const head = createHead();

package/src/public/components.d.ts

@@ -2,3 +2,4 @@ export { default as FlowIsland } from '../runtime/components/FlowIsland.ts';
 export { default as MkImage } from '../runtime/components/MkImage.ts';
 export { default as MkLink } from '../runtime/components/MkLink.ts';
 export { default as MkPicture } from '../runtime/components/MkPicture.ts';
+export { default as MkIcon } from '../runtime/components/MkIcon.ts';

package/src/public/components.mjs

@@ -2,3 +2,4 @@ export { default as FlowIsland } from "../runtime/components/FlowIsland.mjs";
 export { default as MkImage } from "../runtime/components/MkImage.mjs";
 export { default as MkLink } from "../runtime/components/MkLink.mjs";
 export { default as MkPicture } from "../runtime/components/MkPicture.mjs";
+export { default as MkIcon } from "../runtime/components/MkIcon.mjs";

package/src/runtime/components/MkIcon.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/runtime/components/MkIcon.mjs

@@ -0,0 +1,34 @@
+import { Icon } from "@iconify/vue";
+import { computed, defineComponent, h, Text } from "vue";
+export default defineComponent({
+  name: "MkIcon",
+  setup(props, { slots, attrs }) {
+    const iconName = computed(() => {
+      let name = "";
+      try {
+        const defaultSlot = slots.default?.();
+        if (defaultSlot) {
+          for (const vnode of defaultSlot) {
+            if (typeof vnode.children === "string") {
+              name += vnode.children;
+            } else if (vnode.type === Text && typeof vnode.children === "string") {
+              name += vnode.children;
+            }
+          }
+        }
+      } catch (e) {
+        name = "";
+      }
+      return name.trim();
+    });
+    return () => {
+      if (!iconName.value) {
+        return h("span", { ...attrs }, slots.default?.());
+      }
+      return h(Icon, {
+        icon: iconName.value,
+        ...attrs
+      });
+    };
+  }
+});