@monkeyplus/flow 6.0.6 → 6.0.7

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

@@ -0,0 +1,199 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+    rename: StringConstructor;
+    thumb: (StringConstructor | BooleanConstructor)[];
+    thumbnail: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+    classImg: StringConstructor;
+    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;
+    };
+    sync: BooleanConstructor;
+    eWidth: (StringConstructor | NumberConstructor)[];
+    eHeight: (StringConstructor | NumberConstructor)[];
+    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;
+    };
+    legacyFormat: {
+        type: StringConstructor;
+        default: null;
+    };
+}>, () => 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;
+    thumb: (StringConstructor | BooleanConstructor)[];
+    thumbnail: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+    classImg: StringConstructor;
+    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;
+    };
+    sync: BooleanConstructor;
+    eWidth: (StringConstructor | NumberConstructor)[];
+    eHeight: (StringConstructor | NumberConstructor)[];
+    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;
+    };
+    legacyFormat: {
+        type: StringConstructor;
+        default: null;
+    };
+}>> & 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;
+    legacyFormat: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/runtime/components/MkPicture.mjs

@@ -0,0 +1,171 @@
+import { computed, defineComponent, h } from "vue";
+import { getFileExtension, screens } from "../../../modules/images/runtime/helpers.mjs";
+import { useImage } from "./image-shared.mjs";
+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: "MkPicture",
+  inheritAttrs: false,
+  props: {
+    src: {
+      type: String,
+      required: true
+    },
+    rename: String,
+    thumb: [Boolean, String],
+    thumbnail: { type: [Boolean, String], default: void 0 },
+    classImg: String,
+    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
+    },
+    sync: Boolean,
+    eWidth: [String, Number],
+    eHeight: [String, Number],
+    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 },
+    legacyFormat: { type: String, default: null }
+  },
+  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 originalFormat = () => getFileExtension(props.src);
+    const isTransparent = () => ["png", "webp", "gif"].includes(originalFormat());
+    const nFormat = () => {
+      if (props.format) {
+        return props.format;
+      }
+      if (originalFormat() === "svg") {
+        return "svg";
+      }
+      return "webp";
+    };
+    const nLegacyFormat = () => {
+      if (props.legacyFormat) {
+        return props.legacyFormat;
+      }
+      const formats = {
+        webp: isTransparent() ? "png" : "jpeg",
+        svg: "png"
+      };
+      return formats[nFormat()] || originalFormat();
+    };
+    const nSources = computed(() => {
+      if (nFormat() === "svg" || !imageUtils.getImage?.getSizes) {
+        return [{ src: props.src, srcset: props.src }];
+      }
+      const formats = nLegacyFormat() !== nFormat() ? [nLegacyFormat(), nFormat()] : [nFormat()];
+      return formats.map((format) => {
+        const result = imageUtils.getImage.getSizes(props.src, {
+          ...nOption.value,
+          modifiers: {
+            ...nModifiers.value,
+            format
+          },
+          sizes: props.sizes || options.value.screens || screens
+        });
+        return {
+          src: result.src,
+          type: `image/${format}`,
+          sizes: result.sizes,
+          srcset: result.srcset
+        };
+      });
+    });
+    const nThumbnail = computed(() => {
+      const thumb = resolveThumbnailValue(props.thumbnail, props.thumb);
+      if (typeof thumb === "string") {
+        return thumb;
+      }
+      if (!thumb) {
+        return void 0;
+      }
+      const thumbnail = imageUtils.getImage?.(props.src, {
+        quality: 10,
+        width: 60
+      }, nOption.value);
+      return typeof thumbnail === "string" ? thumbnail : props.src;
+    });
+    return () => {
+      if (isRuntimeLambda()) {
+        return h("img", {
+          ...attrs,
+          ...nImgAttrs.value,
+          src: props.src,
+          alt: props.alt || image.value.alt,
+          title: props.title || image.value.title,
+          width: props.eWidth || nImgAttrs.value.width,
+          height: props.eHeight || nImgAttrs.value.height,
+          "x-src": getLocalSource(props.src)
+        });
+      }
+      const primarySource = nSources.value[0] || { src: props.src, srcset: props.src };
+      const fallbackSource = nSources.value[1];
+      const compatibilityThumb = nThumbnail.value;
+      const sourceSrcsetProp = compatibilityThumb ? "data-srcset" : "srcset";
+      const sourceSizesProp = compatibilityThumb ? "data-sizes" : "sizes";
+      const imgAttrs = {
+        ...attrs,
+        ...nImgAttrs.value,
+        src: compatibilityThumb || primarySource.src,
+        srcset: compatibilityThumb ? void 0 : primarySource.srcset,
+        sizes: compatibilityThumb ? void 0 : primarySource.sizes,
+        "data-src": compatibilityThumb ? primarySource.src : void 0,
+        "data-srcset": compatibilityThumb ? primarySource.srcset : void 0,
+        "data-sizes": compatibilityThumb ? primarySource.sizes : void 0,
+        "data-thumb": compatibilityThumb,
+        alt: props.alt || image.value.alt,
+        title: props.title || image.value.title,
+        width: props.eWidth || nImgAttrs.value.width,
+        height: props.eHeight || nImgAttrs.value.height,
+        class: compatibilityThumb ? [attrs.class, "lazyload", props.classImg] : [attrs.class, props.classImg],
+        "x-src": getLocalSource(props.src)
+      };
+      if (options.value.lazy && !props.sync && !imgAttrs.loading) {
+        imgAttrs.loading = "lazy";
+      }
+      const children = [];
+      if (fallbackSource) {
+        children.push(h("source", {
+          type: fallbackSource.type,
+          [sourceSrcsetProp]: fallbackSource.srcset,
+          [sourceSizesProp]: fallbackSource.sizes
+        }));
+      }
+      children.push(h("img", imgAttrs));
+      return h("picture", { key: primarySource.src }, children);
+    };
+  }
+});

package/src/runtime/components/image-shared.d.ts

@@ -0,0 +1,27 @@
+import type { FlowImageMeta, FlowImageOptions, GetImageFunction } from '../../../modules/images/runtime/types.ts';
+export interface InjectedImageUtils {
+    getImage?: GetImageFunction;
+    getImageMeta?: (src: string) => FlowImageMeta | undefined;
+    getImageOptions?: () => FlowImageOptions | undefined;
+}
+export declare function useInjectedImageUtils(): InjectedImageUtils;
+export declare function useImage(props: Record<string, any>): {
+    imageUtils: InjectedImageUtils;
+    image: import("vue").ComputedRef<FlowImageMeta>;
+    nImgAttrs: import("vue").ComputedRef<{
+        width: number | undefined;
+        height: number | undefined;
+        alt: any;
+        referrerpolicy: any;
+        usemap: any;
+        longdesc: any;
+        ismap: any;
+        loading: any;
+    }>;
+    nModifiers: import("vue").ComputedRef<any>;
+    nOption: import("vue").ComputedRef<{
+        provider: any;
+        preset: any;
+        rename: any;
+    }>;
+};

package/src/runtime/components/image-shared.mjs

@@ -0,0 +1,51 @@
+import { computed, inject } from "vue";
+import { getNormalName, parseSize } from "../../../modules/images/runtime/helpers.mjs";
+export function useInjectedImageUtils() {
+  return inject("utils", {});
+}
+export function useImage(props) {
+  const imageUtils = useInjectedImageUtils();
+  const nImgAttrs = computed(() => ({
+    width: parseSize(props.width),
+    height: parseSize(props.height),
+    alt: props.alt,
+    referrerpolicy: props.referrerpolicy,
+    usemap: props.usemap,
+    longdesc: props.longdesc,
+    ismap: props.ismap,
+    loading: props.loading
+  }));
+  const nModifiers = computed(() => ({
+    ...props.modifiers,
+    width: parseSize(props.width),
+    height: parseSize(props.height),
+    format: props.format,
+    quality: props.quality,
+    background: props.background,
+    fit: props.fit
+  }));
+  const nOption = computed(() => ({
+    provider: props.provider,
+    preset: props.preset,
+    rename: props.rename
+  }));
+  const image = computed(() => {
+    const meta = {
+      ...imageUtils.getImageMeta?.(props.src) || { name: props.src }
+    };
+    if (!meta.alt) {
+      meta.alt = getNormalName(meta.name);
+    }
+    if (!meta.title) {
+      meta.title = getNormalName(meta.name);
+    }
+    return meta;
+  });
+  return {
+    imageUtils,
+    image,
+    nImgAttrs,
+    nModifiers,
+    nOption
+  };
+}

package/src/runtime/config.d.ts

@@ -1,3 +1,5 @@
+import type { Options as AutoimportOptions } from 'unplugin-auto-import/types';
+import type { Options as ComponentOptions } from 'unplugin-vue-components/types';
 export interface FlowDirEntry {
     dir: string;
 }
@@ -23,6 +25,18 @@ export interface FlowLocaleConfig {
     locales: string[];
     location: string;
     language: string;
+    prefixStrategy?: 'auto' | 'manual';
+    prefixFormat?: 'compact' | 'nested';
+}
+export interface FlowServerConfig extends Record<string, unknown> {
+    host?: string | boolean;
+    port?: number;
+    strictPort?: boolean;
+    open?: boolean;
+    https?: Record<string, unknown>;
+    watch?: Record<string, unknown> & {
+        additionalPaths?: string[];
+    };
 }
 export interface FlowConfig {
     modules: FlowModuleInput[];
@@ -31,6 +45,7 @@ export interface FlowConfig {
     };
     build: FlowBuildConfig;
     locale: FlowLocaleConfig;
+    server?: FlowServerConfig;
     siteUrl?: string;
     nitro?: Record<string, unknown>;
     [key: string]: unknown;
@@ -41,7 +56,10 @@ export type UserFlowConfig = Partial<FlowConfig> & Record<string, unknown> & {
         pages?: FlowDirEntry[];
     };
     locale?: Partial<FlowLocaleConfig>;
+    server?: FlowServerConfig;
     siteUrl?: string;
+    components?: Partial<ComponentOptions>;
+    autoImport?: Partial<AutoimportOptions>;
 };
 export interface FlowModuleNitroConfig extends Record<string, unknown> {
     plugins: string[];

package/src/runtime/config.mjs

@@ -20,7 +20,10 @@ export function resolveFlowConfig(userFlowConfig = {}) {
     locale: {
       locales: userFlowConfig.locale?.locales?.length ? userFlowConfig.locale.locales : ["es-ec"],
       location: userFlowConfig.locale?.location || "ec",
-      language: userFlowConfig.locale?.language || "es"
-    }
+      language: userFlowConfig.locale?.language || "es",
+      prefixStrategy: userFlowConfig.locale?.prefixStrategy || "auto",
+      prefixFormat: userFlowConfig.locale?.prefixFormat || "compact"
+    },
+    server: userFlowConfig.server
   };
 }

package/src/runtime/locale-routing.d.ts

@@ -0,0 +1,12 @@
+import type { FlowConfig, FlowLocaleConfig } from './config';
+export type FlowLocalePrefixStrategy = 'auto' | 'manual';
+export type FlowLocalePrefixFormat = 'compact' | 'nested';
+interface FlowLocaleConfigInput {
+    locale?: Partial<FlowLocaleConfig>;
+}
+export declare function normalizePath(value: string): string;
+export declare function getDefaultLocaleCode(config?: FlowLocaleConfigInput): string;
+export declare function getLocalePrefix(config: FlowLocaleConfigInput | undefined, localeCode: string): string;
+export declare function localizeRoutePattern(config: FlowConfig | FlowLocaleConfigInput | undefined, localeCode: string, route: string): string;
+export declare function toPublicRoute(config: FlowConfig | FlowLocaleConfigInput | undefined, localeCode: string, route: string): string;
+export {};

package/src/runtime/locale-routing.mjs

@@ -0,0 +1,93 @@
+function ensureLeadingSlash(value) {
+  if (!value) {
+    return "/";
+  }
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function ensureTrailingSlash(value) {
+  if (value === "/" || value.endsWith("/")) {
+    return value;
+  }
+  return `${value}/`;
+}
+function preserveTrailingSlash(value, source) {
+  return source.endsWith("/") ? ensureTrailingSlash(value) : value;
+}
+function resolveLocaleConfig(config) {
+  return {
+    locales: config?.locale?.locales?.length ? config.locale.locales : ["es-ec"],
+    location: config?.locale?.location || "ec",
+    language: config?.locale?.language || "es",
+    prefixStrategy: config?.locale?.prefixStrategy || "auto",
+    prefixFormat: config?.locale?.prefixFormat || "compact"
+  };
+}
+function resolveLocaleParts(config, code) {
+  const localeConfig = resolveLocaleConfig(config);
+  const [lang = localeConfig.language, loc = localeConfig.location] = code.split("-");
+  return {
+    lang,
+    loc
+  };
+}
+function routeHasPrefix(route, prefix) {
+  return route === prefix || route === `${prefix}/` || route.startsWith(`${prefix}/`);
+}
+function getLocalePrefixVariants(config, localeCode) {
+  const localeConfig = resolveLocaleConfig(config);
+  const { lang, loc } = resolveLocaleParts(config, localeCode);
+  const prefixes = /* @__PURE__ */ new Set();
+  if (loc === localeConfig.location) {
+    prefixes.add(`/${lang}`);
+    return [...prefixes];
+  }
+  prefixes.add(`/${lang}-${loc}`);
+  prefixes.add(`/${lang}/${loc}`);
+  return [...prefixes];
+}
+export function normalizePath(value) {
+  if (!value || value === "/") {
+    return "/";
+  }
+  return value.length > 1 && value.endsWith("/") ? value.slice(0, -1) : value;
+}
+export function getDefaultLocaleCode(config) {
+  const localeConfig = resolveLocaleConfig(config);
+  return `${localeConfig.language}-${localeConfig.location}`;
+}
+export function getLocalePrefix(config, localeCode) {
+  const localeConfig = resolveLocaleConfig(config);
+  if (localeConfig.prefixStrategy === "manual") {
+    return "";
+  }
+  if (localeCode === getDefaultLocaleCode(config)) {
+    return "";
+  }
+  const { lang, loc } = resolveLocaleParts(config, localeCode);
+  if (loc === localeConfig.location) {
+    return `/${lang}`;
+  }
+  if (localeConfig.prefixFormat === "nested") {
+    return `/${lang}/${loc}`;
+  }
+  return `/${lang}-${loc}`;
+}
+export function localizeRoutePattern(config, localeCode, route) {
+  const normalizedRoute = ensureLeadingSlash(route || "/");
+  const prefix = getLocalePrefix(config, localeCode);
+  if (!prefix) {
+    return normalizedRoute;
+  }
+  if (getLocalePrefixVariants(config, localeCode).some((candidate) => routeHasPrefix(normalizedRoute, candidate))) {
+    return normalizedRoute;
+  }
+  if (normalizedRoute === "/") {
+    return ensureTrailingSlash(prefix);
+  }
+  return preserveTrailingSlash(`${normalizePath(prefix)}${normalizedRoute}`, normalizedRoute);
+}
+export function toPublicRoute(config, localeCode, route) {
+  const localizedRoute = localizeRoutePattern(config, localeCode, route);
+  const publicRoute = localizedRoute.replaceAll("*", "");
+  return preserveTrailingSlash(normalizePath(publicRoute), localizedRoute);
+}

package/src/runtime/page-discovery.mjs

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync } from "node:fs";
 import { resolve } from "node:path";
 import { createJiti } from "jiti";
+import { localizeRoutePattern, normalizePath, toPublicRoute } from "./locale-routing.mjs";
 const jiti = createJiti(import.meta.url, {
   fsCache: false,
   moduleCache: false
@@ -25,12 +26,6 @@ function collectFiles(rootDir, currentDir = rootDir) {
   }
   return files.sort((left, right) => left.localeCompare(right));
 }
-function normalizePath(value) {
-  if (!value || value === "/") {
-    return "/";
-  }
-  return value.length > 1 && value.endsWith("/") ? value.slice(0, -1) : value;
-}
 function createLocale(flowConfig, code) {
   const [lang = flowConfig.locale.language || "es", loc = flowConfig.locale.location || "ec"] = code.split("-");
   return {
@@ -55,9 +50,6 @@ function replacePath(pattern, url) {
   }
   return normalizePath(resolved.replaceAll("**", ""));
 }
-function toPublicRoutePattern(url) {
-  return normalizePath(url.replaceAll("*", ""));
-}
 function combineName(name, dynamicName) {
   return `${name.replace(/\/*$/, "")}/${dynamicName.replace(/^\/*/, "")}`;
 }
@@ -124,14 +116,15 @@ export async function getUrlFromDefinitions(definitions, flowConfig, namePage, l
     return void 0;
   }
   const localePage = definition.locales[localeCode];
+  const localizedRoute = localizeRoutePattern(flowConfig, localeCode, localePage?.url || "/");
   if (!localePage) {
     return void 0;
   }
   if (options.url) {
-    return replacePath(localePage.url, options.url);
+    return replacePath(localizedRoute, options.url);
   }
   if (options.params) {
-    return replacePath(localePage.url, options.params);
+    return replacePath(localizedRoute, options.params);
   }
   if (localePage.dynamic && options.dynamicName) {
     const entries = await getDynamicEntries(definitions, flowConfig, definition, localeCode, localePage);
@@ -139,9 +132,9 @@ export async function getUrlFromDefinitions(definitions, flowConfig, namePage, l
     if (!entry) {
       return void 0;
     }
-    return replacePath(localePage.url, entry.url);
+    return replacePath(localizedRoute, entry.url);
   }
-  return toPublicRoutePattern(localePage.url);
+  return toPublicRoute(flowConfig, localeCode, localePage.url);
 }
 export async function getUrlsFromDefinitions(definitions, flowConfig, withLocale = false, omitNoPublish = false) {
   const urls = [];
@@ -157,12 +150,12 @@ export async function getUrlsFromDefinitions(definitions, flowConfig, withLocale
       if (localePage.dynamic) {
         const entries = await getDynamicEntries(definitions, flowConfig, definition, localeCode, localePage);
         for (const entry of entries) {
-          const url2 = replacePath(localePage.url, entry.url);
+          const url2 = replacePath(localizeRoutePattern(flowConfig, localeCode, localePage.url), entry.url);
           urls.push(withLocale ? { url: url2, locale: localeCode, name: combineName(definition.name, entry.name) } : url2);
         }
         continue;
       }
-      const url = toPublicRoutePattern(localePage.url);
+      const url = toPublicRoute(flowConfig, localeCode, localePage.url);
       urls.push(withLocale ? { url, locale: localeCode, name: definition.name } : url);
     }
   }