@monkeyplus/flow 6.0.6 → 6.0.8

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/nitro.mjs

@@ -16,7 +16,10 @@ export function createFlowNitroConfig(options = {}) {
   const flowConfig = resolveFlowConfig(options.userFlowConfig || {});
   const flowModules = loadFlowModules(projectRoot, flowConfig);
   const flowNitroConfig = { ...flowConfig.nitro || {} };
-  const flowNitroHooks = flowNitroConfig.hooks || {};
+  const flowNitroHooks = {
+    ...flowNitroConfig.hooks || {},
+    ...flowModules.nitro.hooks
+  };
   const configuredNoExternals = Array.isArray(flowNitroConfig.noExternals) ? flowNitroConfig.noExternals : [];
   const flowPackagePattern = /^@monkeyplus\/flow(?:\/.*)?$/;
   const flowRuntimeConfig = typeof flowModules.nitro.runtimeConfig.flow === "object" && flowModules.nitro.runtimeConfig.flow ? flowModules.nitro.runtimeConfig.flow : {};

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,130 @@
+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) {
+    console.debug(`[Flow Content] Fetching content from ${joinUrl(apiBase, route)} using global fetch`);
+    return await localFetch(joinUrl(apiBase, route), {
+      headers: {
+        accept: "application/json"
+      },
+      query
+    });
+  }
+  if (typeof window === "undefined" && nitroFetch) {
+    console.debug(`[Flow Content] Fetching content from ${joinUrl(apiBase, route)} using Nitro fetch`);
+    return await nitroFetch(joinUrl(apiBase, route), {
+      headers: {
+        accept: "application/json"
+      },
+      query
+    });
+  }
+  const absoluteBase = await resolveAbsoluteContentApiBase();
+  const target = withQuery(joinUrl(absoluteBase, route), query);
+  console.debug(`[Flow Content] Fetching content from ${target}`);
+  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,131 @@
+import { computed, defineComponent, h } from "vue";
+import { parseSize } from "../../../modules/images/runtime/helpers.mjs";
+import { useImage, useLazySizes } 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
+      };
+    });
+    useLazySizes(() => !isRuntimeLambda() && !!nSrc.value.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;

package/src/runtime/components/MkLink.mjs

@@ -0,0 +1,72 @@
+import { defineComponent, h, inject, onServerPrefetch, ref, watch } from "vue";
+const flowUtilsKey = "utils";
+function isExternalTarget(value) {
+  return /^(?:[a-z][a-z\d+.-]*:|#|\/\/)/i.test(value);
+}
+function normalizeNamedTarget(value, localeCode, lang, loc) {
+  if (!value.startsWith("/")) {
+    return value;
+  }
+  const variants = [
+    localeCode ? `/${localeCode}/` : void 0,
+    lang && loc ? `/${lang}-${loc}/` : void 0,
+    lang && loc ? `/${lang}/${loc}/` : void 0,
+    lang ? `/${lang}/` : void 0
+  ].filter((candidate) => Boolean(candidate));
+  for (const prefix of variants) {
+    if (value.startsWith(prefix)) {
+      return value.slice(prefix.length);
+    }
+  }
+  return value;
+}
+export default defineComponent({
+  name: "MkLink",
+  props: {
+    isSlot: Boolean,
+    to: {
+      type: String,
+      required: true
+    },
+    locale: String
+  },
+  setup(props, { slots }) {
+    const utils = inject(flowUtilsKey, void 0);
+    const href = ref(props.to);
+    const isClient = typeof window !== "undefined";
+    const updateHref = async () => {
+      if (!utils) {
+        href.value = props.to;
+        return;
+      }
+      if (isExternalTarget(props.to)) {
+        href.value = props.to;
+        return;
+      }
+      const currentLocale = utils.getLocale();
+      const namedTarget = normalizeNamedTarget(
+        props.to,
+        currentLocale.code,
+        currentLocale.lang,
+        currentLocale.loc
+      );
+      if (namedTarget.startsWith("/")) {
+        href.value = namedTarget;
+        return;
+      }
+      href.value = await utils.getUrl(namedTarget, props.locale) || props.to;
+    };
+    onServerPrefetch(updateHref);
+    if (isClient) {
+      watch(() => [props.to, props.locale], () => {
+        void updateHref();
+      }, { immediate: true });
+    }
+    return () => {
+      if (props.isSlot) {
+        return slots.default?.({ href: href.value }) || null;
+      }
+      return h("a", { href: href.value }, slots.default ? slots.default() : href.value);
+    };
+  }
+});