@monkeyplus/flow 6.0.5 → 6.0.7

package/server/lib/render.mjs

@@ -5,7 +5,9 @@ import bases from "virtual:flow/bases";
 import layouts from "virtual:flow/layouts";
 import templates from "virtual:flow/templates";
 import { createSSRApp, defineComponent, h } from "vue";
+import { getFlowImageRuntimeUtils } from "../../modules/images/runtime/server.mjs";
 import { installFlowVuePlugins } from "../../src/runtime/vue";
+import { getUrl, getUrls } from "./pages.mjs";
 function escapeHtml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 }
@@ -95,18 +97,32 @@ async function renderBody(page) {
       head: head2
     };
   }
+  const context = {
+    page: page.definition,
+    context: page.context,
+    head: page.head,
+    seo: page.seo,
+    locale: page.locale,
+    params: page.params,
+    path: page.pathname
+  };
+  const imageUtils = getFlowImageRuntimeUtils();
+  const utils = {
+    getLocale() {
+      return page.locale;
+    },
+    async getUrl(namePage, localeCode, options) {
+      return await getUrl(namePage, localeCode || page.locale.code, options);
+    },
+    async getUrls(withLocale, omitNoPublish) {
+      return await getUrls(withLocale, omitNoPublish);
+    },
+    ...imageUtils || {}
+  };
   const TemplateRoot = defineComponent({
     render() {
-      const viewNode = h(TemplateComponent, {
-        page: page.definition,
-        context: page.context,
-        head: page.head,
-        seo: page.seo,
-        locale: page.locale,
-        params: page.params,
-        path: page.pathname
-      });
-      const content = LayoutComponent ? h(LayoutComponent, {}, {
+      const viewNode = h(TemplateComponent, context);
+      const content = LayoutComponent ? h(LayoutComponent, context, {
         default: () => viewNode
       }) : viewNode;
       return h(UApp, {}, {
@@ -115,6 +131,8 @@ async function renderBody(page) {
     }
   });
   const app = createSSRApp(TemplateRoot);
+  app.provide("context", context);
+  app.provide("utils", utils);
   const head = createHead();
   head.push(normalizeSeoToHead(page.head, fallbackTitle, fallbackDescription));
   app.use(head);

package/server/renderer.d.ts

@@ -1,3 +1,3 @@
 export default function renderPage(input: Request | {
     req?: Request;
-}): Promise<Response | undefined>;
+}): Promise<any>;

package/server/renderer.mjs

@@ -38,7 +38,8 @@ async function resolvePrerenderFetchHandler() {
 export default async function renderPage(input) {
   const viteEnvs = globalThis.__nitro_vite_envs__;
   const request = resolveRequest(input);
-  const viteFetchHandler = viteEnvs?.ssr?.fetch;
+  const viteEnv = viteEnvs?.ssr;
+  const viteFetchHandler = typeof viteEnv?.fetch === "function" ? viteEnv.fetch.bind(viteEnv) : void 0;
   if (!request) {
     return new Response("Not Found", { status: 404 });
   }

package/src/public/components.d.ts

@@ -1 +1,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';

package/src/public/components.mjs

@@ -1 +1,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";

package/src/public/index.d.ts

@@ -1,5 +1,7 @@
+export type { ContentDirectoryNode, ContentEntry, ContentFileNode, ContentTreeNode, } from '../../modules/content/query.ts';
+export type { FlowBootPayload } from '../runtime/boot.ts';
 export { defineFlowConfig, defineFlowModule, resolveFlowConfig } from '../runtime/config.ts';
+export type { FlowConfig, UserFlowConfig, } from '../runtime/config.ts';
 export { definePage } from '../runtime/pages.ts';
-export type { FlowConfig, FlowLocale, HeadDefinition, PageContextInput, UserFlowConfig, } from '../runtime/config.ts';
-export type { FlowBootPayload } from '../runtime/boot.ts';
-export type { FlowHydrationMode, PageDefinition, PageLocaleDefinition, PageViewDefinition, } from '../runtime/pages.ts';
+export type { FlowHydrationMode, FlowLocale, HeadDefinition, PageContextInput, PageDefinition, PageLocaleDefinition, PageViewDefinition, } from '../runtime/pages.ts';
+export { queryContent } from './query-content.ts';

package/src/public/index.mjs

@@ -1,2 +1,3 @@
 export { defineFlowConfig, defineFlowModule, resolveFlowConfig } from "../runtime/config.mjs";
 export { definePage } from "../runtime/pages.mjs";
+export { queryContent } from "./query-content.mjs";

package/src/public/modules/images.d.ts

@@ -0,0 +1,2 @@
+export { default } from '../../../modules/images/module.ts';
+export type { ImagesModuleOptions } from '../../../modules/images/module.ts';

package/src/public/modules/images.mjs

@@ -0,0 +1 @@
+export { default } from "../../../modules/images/module.mjs";

package/src/public/query-content.d.ts

@@ -0,0 +1,7 @@
+import type { ContentEntry, ContentTreeNode } from '../../modules/content/query.ts';
+export interface QueryContentBuilder {
+    find: () => Promise<ContentEntry[]>;
+    findOne: () => Promise<ContentEntry | null>;
+    tree: () => Promise<ContentTreeNode[]>;
+}
+export declare function queryContent(path?: string): QueryContentBuilder;

package/src/public/query-content.mjs

@@ -0,0 +1,127 @@
+const defaultContentConfig = {
+  apiBase: "/api/_content"
+};
+function getGlobalFetch() {
+  const candidate = globalThis.$fetch;
+  return typeof candidate === "function" ? candidate : void 0;
+}
+function withLeadingSlash(value) {
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function withoutTrailingSlash(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function normalizeQueryPath(path = "") {
+  if (!path) {
+    return "/";
+  }
+  const normalized = `/${path}`.replace(/\/+/g, "/");
+  return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function joinUrl(base, path = "") {
+  const normalizedBase = withoutTrailingSlash(base);
+  const normalizedPath = path ? withLeadingSlash(path) : "";
+  return `${normalizedBase}${normalizedPath}`;
+}
+function withQuery(url, params) {
+  if (!params || Object.keys(params).length === 0) {
+    return url;
+  }
+  const origin = typeof window !== "undefined" ? window.location.origin : "http://localhost:3000";
+  const target = new URL(url, origin);
+  Object.entries(params).forEach(([key, value]) => {
+    if (value == null || value === "") {
+      return;
+    }
+    target.searchParams.set(key, String(value));
+  });
+  return target.toString();
+}
+async function getRuntimeConfig() {
+  if (typeof window !== "undefined") {
+    return void 0;
+  }
+  try {
+    const loadRuntimeModule = new Function("specifier", "return import(specifier);");
+    const runtime = await loadRuntimeModule("nitro/runtime-config");
+    return typeof runtime.useRuntimeConfig === "function" ? runtime.useRuntimeConfig() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function getNitroFetch() {
+  if (typeof window !== "undefined") {
+    return void 0;
+  }
+  try {
+    const loadNitroModule = new Function("specifier", "return import(specifier);");
+    const runtime = await loadNitroModule("nitro/app");
+    return typeof runtime.fetch === "function" ? runtime.fetch : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveContentApiBase() {
+  const runtimeConfig = await getRuntimeConfig();
+  return runtimeConfig?.flow?.content?.apiBase || runtimeConfig?.public?.flow?.content?.apiBase || defaultContentConfig.apiBase;
+}
+async function resolveAbsoluteContentApiBase() {
+  const runtimeConfig = await getRuntimeConfig();
+  const apiBase = await resolveContentApiBase();
+  if (typeof window !== "undefined") {
+    return apiBase;
+  }
+  if (runtimeConfig?.flow?.siteUrl) {
+    return joinUrl(runtimeConfig.flow.siteUrl, apiBase);
+  }
+  return joinUrl("http://localhost:3000", apiBase);
+}
+async function fetchContent(route, path) {
+  const apiBase = await resolveContentApiBase();
+  const query = path && path !== "/" ? { path } : void 0;
+  const localFetch = getGlobalFetch();
+  const nitroFetch = await getNitroFetch();
+  if (typeof window === "undefined" && localFetch) {
+    return await localFetch(joinUrl(apiBase, route), {
+      headers: {
+        accept: "application/json"
+      },
+      query
+    });
+  }
+  if (typeof window === "undefined" && nitroFetch) {
+    return await nitroFetch(joinUrl(apiBase, route), {
+      headers: {
+        accept: "application/json"
+      },
+      query
+    });
+  }
+  const absoluteBase = await resolveAbsoluteContentApiBase();
+  const target = withQuery(joinUrl(absoluteBase, route), query);
+  const response = await fetch(target, {
+    headers: {
+      accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    const details = await response.text();
+    throw new Error(`Content request failed (${response.status} ${response.statusText}): ${details}`);
+  }
+  return await response.json();
+}
+export function queryContent(path = "") {
+  const normalizedPath = normalizeQueryPath(path);
+  return {
+    async find() {
+      return await fetchContent("query", normalizedPath);
+    },
+    async findOne() {
+      const entries = await this.find();
+      return entries[0] || null;
+    },
+    async tree() {
+      return await fetchContent("tree", normalizedPath);
+    }
+  };
+}

package/src/public/vite.mjs

@@ -210,6 +210,10 @@ export function createFlowViteConfig(options = {}) {
   const flowNitroHooks = flowNitroConfig.hooks || {};
   const flowPackagePattern = /^@monkeyplus\/flow(?:\/.*)?$/;
   const userPrerenderRoutesHook = typeof flowNitroHooks["prerender:routes"] === "function" ? flowNitroHooks["prerender:routes"] : void 0;
+  const configuredServer = flowConfig.server || {};
+  const moduleServer = flowModules.vite.server || { watch: { additionalPaths: [] } };
+  const configuredWatch = typeof configuredServer.watch === "object" && configuredServer.watch ? configuredServer.watch : {};
+  const moduleWatch = typeof moduleServer.watch === "object" && moduleServer.watch ? moduleServer.watch : {};
   return defineConfig({
     plugins: [
       createFlowVirtualServerModules(projectRoot, flowConfig),
@@ -224,10 +228,14 @@ export function createFlowViteConfig(options = {}) {
       ui({
         router: false,
         components: {
+          ...options.userFlowConfig?.components,
           resolvers: [
-            IconsResolver()
+            IconsResolver(),
+            ...options.userFlowConfig?.components?.resolvers || []
           ]
-        }
+          // dirs: [],
+        },
+        autoImport: options.userFlowConfig?.autoImport
       }),
       nitro({
         ...flowNitroConfig,
@@ -270,6 +278,14 @@ export function createFlowViteConfig(options = {}) {
         ...flowModules.vite.resolve.alias
       }
     },
+    server: {
+      ...configuredServer,
+      ...moduleServer,
+      watch: {
+        ...configuredWatch,
+        ...moduleWatch
+      }
+    },
     ssr: {
       noExternal: [flowPackagePattern]
     }

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

@@ -0,0 +1,188 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+    rename: StringConstructor;
+    eWidth: (StringConstructor | NumberConstructor)[];
+    eHeight: (StringConstructor | NumberConstructor)[];
+    sync: BooleanConstructor;
+    thumb: (StringConstructor | BooleanConstructor)[];
+    thumbnail: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+    format: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    quality: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    background: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    fit: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    modifiers: {
+        type: () => Record<string, any>;
+        default: undefined;
+    };
+    preset: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    provider: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    sizes: {
+        type: () => string | Record<string, any>;
+        default: undefined;
+    };
+    width: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    height: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    alt: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    referrerpolicy: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    usemap: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    longdesc: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    ismap: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    loading: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+    rename: StringConstructor;
+    eWidth: (StringConstructor | NumberConstructor)[];
+    eHeight: (StringConstructor | NumberConstructor)[];
+    sync: BooleanConstructor;
+    thumb: (StringConstructor | BooleanConstructor)[];
+    thumbnail: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+    format: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    quality: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    background: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    fit: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    modifiers: {
+        type: () => Record<string, any>;
+        default: undefined;
+    };
+    preset: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    provider: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    sizes: {
+        type: () => string | Record<string, any>;
+        default: undefined;
+    };
+    width: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    height: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    alt: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    referrerpolicy: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    usemap: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    longdesc: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    ismap: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    loading: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    width: string | number;
+    height: string | number;
+    fit: string;
+    format: string;
+    provider: string;
+    preset: string;
+    modifiers: Record<string, any>;
+    sizes: string | Record<string, any>;
+    alt: string;
+    referrerpolicy: string;
+    usemap: string;
+    longdesc: string;
+    ismap: boolean;
+    loading: string;
+    quality: string | number;
+    background: string;
+    title: string;
+    sync: boolean;
+    thumbnail: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/runtime/components/MkImage.mjs

@@ -0,0 +1,130 @@
+import { computed, defineComponent, h } from "vue";
+import { parseSize } from "../../../modules/images/runtime/helpers.mjs";
+import { useImage } from "./image-shared.mjs";
+function resolveImageSource(value, fallback) {
+  if (typeof value === "string" && value.length) {
+    return value;
+  }
+  if (value && typeof value === "object" && typeof value.url === "string") {
+    return value.url;
+  }
+  return fallback;
+}
+function getLocalSource(src) {
+  return src.startsWith("http") ? "" : src;
+}
+function isRuntimeLambda() {
+  const runtimeProcess = typeof globalThis === "object" ? Reflect.get(globalThis, "process") : void 0;
+  return !!(runtimeProcess?.env?.LAMBDA_TASK_ROOT || runtimeProcess?.env?.AWS_LAMBDA_FUNCTION_VERSION);
+}
+function resolveThumbnailValue(value, fallback) {
+  return value !== void 0 ? value : fallback;
+}
+export default defineComponent({
+  name: "MkImage",
+  inheritAttrs: false,
+  props: {
+    src: {
+      type: String,
+      required: true
+    },
+    rename: String,
+    eWidth: [String, Number],
+    eHeight: [String, Number],
+    sync: Boolean,
+    thumb: [Boolean, String],
+    thumbnail: { type: [Boolean, String], default: void 0 },
+    format: { type: String, default: void 0 },
+    quality: { type: [Number, String], default: void 0 },
+    background: { type: String, default: void 0 },
+    fit: { type: String, default: void 0 },
+    modifiers: {
+      type: Object,
+      default: void 0
+    },
+    preset: { type: String, default: void 0 },
+    provider: { type: String, default: void 0 },
+    sizes: {
+      type: [Object, String],
+      default: void 0
+    },
+    width: { type: [String, Number], default: void 0 },
+    height: { type: [String, Number], default: void 0 },
+    alt: { type: String, default: void 0 },
+    title: { type: String, default: void 0 },
+    referrerpolicy: { type: String, default: void 0 },
+    usemap: { type: String, default: void 0 },
+    longdesc: { type: String, default: void 0 },
+    ismap: { type: Boolean, default: void 0 },
+    loading: { type: String, default: void 0 }
+  },
+  setup(props, { attrs }) {
+    const { imageUtils, image, nImgAttrs, nModifiers, nOption } = useImage(props);
+    const options = computed(() => imageUtils.getImageOptions?.() || {
+      lazy: true,
+      screens: {},
+      domains: {},
+      presets: {},
+      baseURL: "/_ipx",
+      dirImages: "/images"
+    });
+    const nSizes = computed(() => {
+      if (!props.sizes || !imageUtils.getImage?.getSizes) {
+        return void 0;
+      }
+      return imageUtils.getImage.getSizes(props.src, {
+        ...nOption.value,
+        sizes: props.sizes,
+        modifiers: {
+          ...nModifiers.value,
+          width: parseSize(props.width),
+          height: parseSize(props.height)
+        }
+      });
+    });
+    const nAttrs = computed(() => {
+      const resolvedAttrs = {
+        ...nImgAttrs.value
+      };
+      if (nSizes.value) {
+        resolvedAttrs.sizes = nSizes.value.sizes;
+        resolvedAttrs.srcset = nSizes.value.srcset;
+      }
+      if (options.value.lazy && !props.sync && !resolvedAttrs.loading) {
+        resolvedAttrs.loading = "lazy";
+      }
+      return resolvedAttrs;
+    });
+    const nSrc = computed(() => {
+      const normal = nSizes.value?.src || resolveImageSource(
+        imageUtils.getImage?.(props.src, nModifiers.value, nOption.value),
+        props.src
+      );
+      const thumb = resolveThumbnailValue(props.thumbnail, props.thumb);
+      const thumbnail = typeof thumb === "string" ? thumb : thumb ? resolveImageSource(
+        imageUtils.getImage?.(props.src, { quality: 10, width: 60 }, nOption.value),
+        props.src
+      ) : void 0;
+      return {
+        normal,
+        thumbnail
+      };
+    });
+    return () => {
+      const compatibilityThumb = !isRuntimeLambda() && nSrc.value.thumbnail;
+      return h("img", {
+        ...attrs,
+        ...nAttrs.value,
+        "src": isRuntimeLambda() ? props.src : compatibilityThumb || nSrc.value.normal,
+        "data-src": compatibilityThumb ? nSrc.value.normal : void 0,
+        "data-thumb": compatibilityThumb,
+        "alt": props.alt || image.value.alt,
+        "title": props.title || image.value.title,
+        "class": compatibilityThumb ? [attrs.class, "lazyload"] : attrs.class,
+        "width": props.eWidth || nAttrs.value.width,
+        "height": props.eHeight || nAttrs.value.height,
+        "x-src": getLocalSource(props.src)
+      });
+    };
+  }
+});

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

@@ -0,0 +1,22 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    isSlot: BooleanConstructor;
+    to: {
+        type: StringConstructor;
+        required: true;
+    };
+    locale: StringConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    isSlot: BooleanConstructor;
+    to: {
+        type: StringConstructor;
+        required: true;
+    };
+    locale: StringConstructor;
+}>> & Readonly<{}>, {
+    isSlot: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;