@monkeyplus/flow 5.0.0-rc.99 → 6.0.1

package/src/runtime/modules.mjs

@@ -0,0 +1,115 @@
+import { dirname, resolve } from "node:path";
+import { createJiti } from "jiti";
+function createNitroConfig() {
+  return {
+    plugins: [],
+    handlers: [],
+    routeRules: {},
+    runtimeConfig: {},
+    virtual: {}
+  };
+}
+function createViteConfig() {
+  return {
+    plugins: [],
+    resolve: {
+      alias: {}
+    },
+    server: {
+      watch: {
+        additionalPaths: []
+      }
+    }
+  };
+}
+function normalizeModuleInput(entry) {
+  if (Array.isArray(entry)) {
+    return {
+      module: entry[0],
+      options: entry[1] || {}
+    };
+  }
+  if (typeof entry === "string") {
+    return {
+      module: entry,
+      options: {}
+    };
+  }
+  if ("module" in entry) {
+    return {
+      module: entry.module,
+      options: entry.options || {}
+    };
+  }
+  return {
+    module: entry,
+    options: {}
+  };
+}
+function resolveModuleSpecifier(specifier, projectRoot) {
+  if (specifier.startsWith("~/")) {
+    return resolve(projectRoot, specifier.slice(2));
+  }
+  if (specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/")) {
+    return resolve(projectRoot, specifier);
+  }
+  return specifier;
+}
+function loadModuleDefinition(source, projectRoot, jiti = createJiti(resolve(projectRoot, "flow.config.ts"), { fsCache: false })) {
+  if (typeof source !== "string") {
+    return {
+      definition: source,
+      moduleRoot: projectRoot
+    };
+  }
+  const resolvedSource = resolveModuleSpecifier(source, projectRoot);
+  const loaded = jiti(resolvedSource);
+  const definition = loaded?.default ?? loaded;
+  const modulePath = typeof resolvedSource === "string" ? jiti.resolve(resolvedSource) : resolvedSource;
+  return {
+    definition,
+    moduleRoot: dirname(modulePath)
+  };
+}
+function resolveModuleOptions(definition, flowConfig, inlineOptions) {
+  const configKey = definition.meta?.configKey;
+  const keyedOptions = configKey && typeof flowConfig[configKey] === "object" ? flowConfig[configKey] : {};
+  return {
+    ...definition.defaults || {},
+    ...keyedOptions,
+    ...inlineOptions
+  };
+}
+export function loadFlowModules(projectRoot, flowConfig) {
+  const nitro = createNitroConfig();
+  const vite = createViteConfig();
+  const prerenderRoutes = /* @__PURE__ */ new Set();
+  const loadedModules = [];
+  const jiti = createJiti(resolve(projectRoot, "flow.config.ts"), { fsCache: false, moduleCache: false });
+  for (const entry of flowConfig.modules) {
+    const normalized = normalizeModuleInput(entry);
+    const { definition } = loadModuleDefinition(normalized.module, projectRoot, jiti);
+    if (!definition || typeof definition !== "object") {
+      continue;
+    }
+    const options = resolveModuleOptions(definition, flowConfig, normalized.options);
+    const context = {
+      projectRoot,
+      flowConfig,
+      nitro,
+      vite,
+      prerenderRoutes
+    };
+    definition.setup?.(options, context);
+    loadedModules.push({
+      name: definition.meta?.name || "anonymous",
+      options
+    });
+  }
+  return {
+    modules: loadedModules,
+    nitro,
+    vite,
+    prerenderRoutes: [...prerenderRoutes]
+  };
+}

package/src/runtime/page-discovery.d.ts

@@ -0,0 +1,6 @@
+import type { FlowConfig } from './config';
+import type { GetUrlOptions, PageDefinition, PageUrlInfo } from './pages';
+export declare function loadPageDefinitions(projectRoot: string, flowConfig: FlowConfig): Promise<PageDefinition[]>;
+export declare function getUrlFromDefinitions(definitions: PageDefinition[], flowConfig: FlowConfig, namePage: string, localeCode?: string, options?: GetUrlOptions): Promise<string | undefined>;
+export declare function getUrlsFromDefinitions(definitions: PageDefinition[], flowConfig: FlowConfig, withLocale?: boolean, omitNoPublish?: boolean): Promise<(string | PageUrlInfo)[]>;
+export declare function getPrerenderRoutes(projectRoot: string, flowConfig: FlowConfig): Promise<string[]>;

package/src/runtime/page-discovery.mjs

@@ -0,0 +1,175 @@
+import { existsSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { createJiti } from "jiti";
+const jiti = createJiti(import.meta.url, {
+  fsCache: false,
+  moduleCache: false
+});
+const dynamicRouteCache = /* @__PURE__ */ new Map();
+function collectFiles(rootDir, currentDir = rootDir) {
+  const entries = readdirSync(currentDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = resolve(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(rootDir, fullPath));
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (!entry.name.endsWith(".ts") || entry.name.endsWith(".d.ts")) {
+      continue;
+    }
+    files.push(fullPath);
+  }
+  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 {
+    code,
+    lang,
+    loc
+  };
+}
+function replacePath(pattern, url) {
+  let resolved = pattern;
+  if (typeof url === "string") {
+    return normalizePath(resolved.replace("/**", `/${url}`));
+  }
+  for (const [key, value] of Object.entries(url)) {
+    if (key === "_") {
+      continue;
+    }
+    resolved = resolved.replace(`:${key}`, value);
+  }
+  if (url._ && resolved.endsWith("/**")) {
+    resolved = resolved.replace("/**", `/${url._}`);
+  }
+  return normalizePath(resolved.replaceAll("**", ""));
+}
+function toPublicRoutePattern(url) {
+  return normalizePath(url.replaceAll("*", ""));
+}
+function combineName(name, dynamicName) {
+  return `${name.replace(/\/*$/, "")}/${dynamicName.replace(/^\/*/, "")}`;
+}
+function createContext(definitions, flowConfig, definition, locale, localePage, pathname, params, dynamic) {
+  return {
+    dynamic,
+    locale,
+    path: pathname,
+    name: definition.name,
+    page: localePage,
+    params,
+    view: definition.view,
+    utils: {
+      getLocale() {
+        return locale;
+      },
+      async getUrl(namePage, localeCode, options) {
+        return await getUrlFromDefinitions(definitions, flowConfig, namePage, localeCode, options);
+      },
+      async getUrls(withLocale, omitNoPublish) {
+        return await getUrlsFromDefinitions(definitions, flowConfig, withLocale, omitNoPublish);
+      }
+    }
+  };
+}
+async function getDynamicEntries(definitions, flowConfig, definition, localeCode, localePage) {
+  if (!localePage.dynamic) {
+    return [];
+  }
+  const cacheKey = `${definition.name}:${localeCode}:${localePage.url}`;
+  if (localePage.dynamic.options?.once) {
+    const cached = dynamicRouteCache.get(cacheKey);
+    if (cached) {
+      return await cached;
+    }
+    const locale2 = createLocale(flowConfig, localeCode);
+    const ctx2 = createContext(definitions, flowConfig, definition, locale2, localePage, localePage.url, {});
+    const pending = Promise.resolve(localePage.dynamic.method(ctx2));
+    dynamicRouteCache.set(cacheKey, pending);
+    return await pending;
+  }
+  const locale = createLocale(flowConfig, localeCode);
+  const ctx = createContext(definitions, flowConfig, definition, locale, localePage, localePage.url, {});
+  return await localePage.dynamic.method(ctx);
+}
+export async function loadPageDefinitions(projectRoot, flowConfig) {
+  const pageDirs = flowConfig.dir.pages.map((entry) => resolve(projectRoot, entry.dir)).filter((dirPath) => existsSync(dirPath));
+  const files = pageDirs.flatMap((pagesDir) => collectFiles(pagesDir));
+  const pages = [];
+  for (const filePath of files) {
+    const loaded = await jiti.import(filePath, { default: true });
+    const definitions = Array.isArray(loaded) ? loaded : [loaded];
+    for (const definition of definitions) {
+      if (definition) {
+        pages.push(definition);
+      }
+    }
+  }
+  return pages;
+}
+export async function getUrlFromDefinitions(definitions, flowConfig, namePage, localeCode = flowConfig.locale.locales[0], options = {}) {
+  const definition = definitions.find((candidate) => candidate.name === namePage);
+  if (!definition) {
+    return void 0;
+  }
+  const localePage = definition.locales[localeCode];
+  if (!localePage) {
+    return void 0;
+  }
+  if (options.url) {
+    return replacePath(localePage.url, options.url);
+  }
+  if (options.params) {
+    return replacePath(localePage.url, options.params);
+  }
+  if (localePage.dynamic && options.dynamicName) {
+    const entries = await getDynamicEntries(definitions, flowConfig, definition, localeCode, localePage);
+    const entry = entries.find((candidate) => candidate.name === options.dynamicName);
+    if (!entry) {
+      return void 0;
+    }
+    return replacePath(localePage.url, entry.url);
+  }
+  return toPublicRoutePattern(localePage.url);
+}
+export async function getUrlsFromDefinitions(definitions, flowConfig, withLocale = false, omitNoPublish = false) {
+  const urls = [];
+  for (const definition of definitions) {
+    if (omitNoPublish && definition.noPublish) {
+      continue;
+    }
+    for (const localeCode of flowConfig.locale.locales) {
+      const localePage = definition.locales[localeCode];
+      if (!localePage) {
+        continue;
+      }
+      if (localePage.dynamic) {
+        const entries = await getDynamicEntries(definitions, flowConfig, definition, localeCode, localePage);
+        for (const entry of entries) {
+          const url2 = replacePath(localePage.url, entry.url);
+          urls.push(withLocale ? { url: url2, locale: localeCode, name: combineName(definition.name, entry.name) } : url2);
+        }
+        continue;
+      }
+      const url = toPublicRoutePattern(localePage.url);
+      urls.push(withLocale ? { url, locale: localeCode, name: definition.name } : url);
+    }
+  }
+  return urls;
+}
+export async function getPrerenderRoutes(projectRoot, flowConfig) {
+  const definitions = await loadPageDefinitions(projectRoot, flowConfig);
+  const routes = await getUrlsFromDefinitions(definitions, flowConfig, false, true);
+  return routes.filter((route) => typeof route === "string").filter((route) => !route.includes(":") && !route.includes("*"));
+}

package/src/runtime/pages.d.ts

@@ -0,0 +1,107 @@
+import type { UseHeadInput } from '@unhead/vue';
+export type MaybePromise<T> = T | Promise<T>;
+export interface FlowLocale {
+    code: string;
+    lang: string;
+    loc: string;
+}
+export interface LegacySeoDefinition {
+    title?: string;
+    /**
+   * @deprecated
+   */
+    description?: string;
+    /**
+   * @deprecated
+   */
+    keywords?: string;
+    /**
+   * @deprecated
+   */
+    imageSocial?: string;
+    /**
+   * @deprecated
+   */
+    twitterSite?: string;
+    /**
+   * @deprecated
+   */
+    google?: boolean;
+    /**
+   * @deprecated
+   */
+    twitter?: boolean;
+    /**
+     * @deprecated
+     */
+    facebook?: boolean;
+}
+export type HeadDefinition = UseHeadInput & LegacySeoDefinition;
+/**
+ * @deprecated Use HeadDefinition.
+ */
+export type SeoDefinition = HeadDefinition;
+export type FlowHydrationMode = 'islands' | 'app';
+export type DynamicRouteUrl = string | Record<string, string>;
+export interface DynamicRouteEntry<TContext = Record<string, unknown>> {
+    url: DynamicRouteUrl;
+    name: string;
+    context?: TContext;
+    slug?: string;
+}
+export interface DynamicRouteOptions {
+    assign?: string;
+    method: (ctx: Omit<PageContextInput, 'dynamic'>) => MaybePromise<DynamicRouteEntry[]>;
+    options?: {
+        once?: boolean;
+    };
+}
+export interface GetUrlOptions {
+    params?: Record<string, string>;
+    dynamicName?: string;
+    url?: DynamicRouteUrl;
+}
+export interface PageUrlInfo {
+    url: string;
+    locale: string;
+    name: string;
+}
+export interface PageViewDefinition {
+    bundle?: string;
+    template: string;
+    layout?: string;
+    base?: string;
+    mode?: FlowHydrationMode;
+}
+export interface PageContextUtils {
+    getLocale: () => FlowLocale;
+    getUrl: (namePage: string, localeCode?: string, options?: GetUrlOptions) => Promise<string | undefined>;
+    getUrls: (withLocale?: boolean, omitNoPublish?: boolean) => Promise<Array<string | PageUrlInfo>>;
+}
+export interface PageContextInput {
+    locale: FlowLocale;
+    path: string;
+    name: string;
+    view: PageViewDefinition;
+    page: PageLocaleDefinition;
+    params: Record<string, string>;
+    dynamic?: DynamicRouteEntry;
+    utils: PageContextUtils;
+}
+export interface PageLocaleDefinition {
+    url: string;
+    head?: (ctx: PageContextInput) => MaybePromise<HeadDefinition>;
+    /**
+     * @deprecated Use head.
+     */
+    seo?: (ctx: PageContextInput) => MaybePromise<HeadDefinition>;
+    context?: (ctx: PageContextInput) => MaybePromise<Record<string, unknown>>;
+    dynamic?: DynamicRouteOptions;
+}
+export interface PageDefinition {
+    name: string;
+    view: PageViewDefinition;
+    locales: Record<string, PageLocaleDefinition>;
+    noPublish?: boolean;
+}
+export declare function definePage(...pages: PageDefinition[]): PageDefinition[];

package/src/runtime/pages.mjs

@@ -0,0 +1,3 @@
+export function definePage(...pages) {
+  return pages;
+}

package/src/runtime/ssg.d.ts

@@ -0,0 +1,9 @@
+import type { FlowConfig } from './config.ts';
+interface FlowBuildHooksOptions {
+    projectRoot: string;
+    flowConfig: FlowConfig;
+    modulePrerenderRoutes: string[];
+    existingHooks?: Record<string, unknown>;
+}
+export declare function createFlowBuildHooks(options: FlowBuildHooksOptions): Record<string, unknown>;
+export {};

package/src/runtime/ssg.mjs

@@ -0,0 +1,37 @@
+import { extname } from "node:path";
+import { getPrerenderRoutes } from "./page-discovery.mjs";
+function isHtmlRoute(route) {
+  return extname(route) === "";
+}
+async function resolveFlowPrerenderRoutes(options) {
+  const discoveredRoutes = await getPrerenderRoutes(options.projectRoot, options.flowConfig);
+  return [.../* @__PURE__ */ new Set([
+    ...discoveredRoutes,
+    ...options.modulePrerenderRoutes
+  ])];
+}
+export function createFlowBuildHooks(options) {
+  const hooks = {
+    ...options.existingHooks || {}
+  };
+  if (options.flowConfig.build.preset !== "ssg") {
+    return hooks;
+  }
+  const userPrerenderRoutes = typeof hooks["prerender:routes"] === "function" ? hooks["prerender:routes"] : void 0;
+  const userPrerenderGenerate = typeof hooks["prerender:generate"] === "function" ? hooks["prerender:generate"] : void 0;
+  let prerenderRoutesPromise;
+  hooks["prerender:routes"] = async (routes) => {
+    prerenderRoutesPromise ||= resolveFlowPrerenderRoutes(options);
+    for (const route of await prerenderRoutesPromise) {
+      routes.add(route);
+    }
+    await userPrerenderRoutes?.(routes);
+  };
+  hooks["prerender:generate"] = async (route) => {
+    await userPrerenderGenerate?.(route);
+    if (route.route && isHtmlRoute(route.route)) {
+      route.contentType = "text/html; charset=utf-8";
+    }
+  };
+  return hooks;
+}

package/src/runtime/virtual-pages.d.ts

@@ -0,0 +1,8 @@
+import type { FlowConfig } from './config';
+export declare function createVirtualPagesModule(projectRoot: string, flowConfig: FlowConfig): string;
+export declare function createVirtualTemplatesModule(projectRoot: string): string;
+export declare function createVirtualLayoutsModule(projectRoot: string): string;
+export declare function createVirtualBaseTemplatesModule(projectRoot: string): string;
+export declare function createVirtualIslandsModule(projectRoot: string): string;
+export declare function createVirtualClientPagesModule(projectRoot: string): string;
+export declare function createVirtualClientPageAssetsModule(projectRoot: string): string;

package/src/runtime/virtual-pages.mjs

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { basename, extname, resolve } from "node:path";
+function collectFiles(rootDir, extensions, currentDir = rootDir) {
+  const entries = readdirSync(currentDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = resolve(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(rootDir, extensions, fullPath));
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (!extensions.some((extension) => entry.name.endsWith(extension))) {
+      continue;
+    }
+    if (entry.name.endsWith(".d.ts")) {
+      continue;
+    }
+    files.push(fullPath);
+  }
+  return files.sort((left, right) => left.localeCompare(right));
+}
+function toAbsoluteImport(filePath) {
+  return filePath.split("\\").join("/");
+}
+function createVirtualClientPageModuleSource(projectRoot, mapper) {
+  const clientPagesDir = resolve(projectRoot, "client/pages");
+  const files = existsSync(clientPagesDir) ? collectFiles(clientPagesDir, [".ts"]) : [];
+  const entries = files.map((filePath) => {
+    const key = basename(filePath, extname(filePath));
+    return `${JSON.stringify(key)}: ${mapper(filePath)}`;
+  });
+  return [
+    "const bundles = {",
+    ...entries.map((entry) => `  ${entry},`),
+    "};",
+    "",
+    "export default bundles;",
+    ""
+  ].join("\n");
+}
+export function createVirtualPagesModule(projectRoot, flowConfig) {
+  const pageDirs = flowConfig.dir.pages.map((entry) => resolve(projectRoot, entry.dir)).filter((dirPath) => existsSync(dirPath));
+  const files = pageDirs.flatMap((pagesDir) => collectFiles(pagesDir, [".ts"]));
+  const imports = files.map((filePath, index) => {
+    return `import page_${index} from ${JSON.stringify(toAbsoluteImport(filePath))};`;
+  });
+  const values = files.map((_, index) => {
+    return `...(Array.isArray(page_${index}) ? page_${index} : [page_${index}])`;
+  });
+  const source = [
+    ...imports,
+    "",
+    `const pages = [${values.join(", ")}];`,
+    "",
+    "export default pages;",
+    ""
+  ].join("\n");
+  return source;
+}
+function createVirtualVueModuleSource(files, variableName) {
+  const imports = files.map((filePath, index) => {
+    return `import item_${index} from ${JSON.stringify(toAbsoluteImport(filePath))};`;
+  });
+  const entries = files.map((filePath, index) => {
+    const key = basename(filePath, extname(filePath)).toLowerCase();
+    return `${JSON.stringify(key)}: item_${index}`;
+  });
+  return [
+    ...imports,
+    "",
+    `const ${variableName} = {`,
+    ...entries.map((entry) => `  ${entry},`),
+    "};",
+    "",
+    `export default ${variableName};`,
+    ""
+  ].join("\n");
+}
+export function createVirtualTemplatesModule(projectRoot) {
+  const templatesDir = resolve(projectRoot, "views/templates");
+  const files = existsSync(templatesDir) ? collectFiles(templatesDir, [".vue"]) : [];
+  return createVirtualVueModuleSource(files, "templates");
+}
+export function createVirtualLayoutsModule(projectRoot) {
+  const layoutsDir = resolve(projectRoot, "views/layouts");
+  const files = existsSync(layoutsDir) ? collectFiles(layoutsDir, [".vue"]) : [];
+  return createVirtualVueModuleSource(files, "layouts");
+}
+export function createVirtualBaseTemplatesModule(projectRoot) {
+  const baseDir = resolve(projectRoot, "views/base");
+  const files = existsSync(baseDir) ? collectFiles(baseDir, [".html"]) : [];
+  const entries = files.map((filePath) => {
+    const key = basename(filePath, extname(filePath)).toLowerCase();
+    const value = readFileSync(filePath, "utf8");
+    return `${JSON.stringify(key)}: ${JSON.stringify(value)}`;
+  });
+  return [
+    "const bases = {",
+    ...entries.map((entry) => `  ${entry},`),
+    "};",
+    "",
+    "export default bases;",
+    ""
+  ].join("\n");
+}
+export function createVirtualIslandsModule(projectRoot) {
+  const islandsDir = resolve(projectRoot, "client/islands");
+  const files = existsSync(islandsDir) ? collectFiles(islandsDir, [".ts", ".vue"]) : [];
+  const entries = files.map((filePath) => {
+    const key = basename(filePath, extname(filePath)).toLowerCase();
+    return `${JSON.stringify(key)}: () => import(${JSON.stringify(toAbsoluteImport(filePath))})`;
+  });
+  return [
+    "const islands = {",
+    ...entries.map((entry) => `  ${entry},`),
+    "};",
+    "",
+    "export default islands;",
+    ""
+  ].join("\n");
+}
+export function createVirtualClientPagesModule(projectRoot) {
+  return createVirtualClientPageModuleSource(
+    projectRoot,
+    (filePath) => `() => import(${JSON.stringify(toAbsoluteImport(filePath))})`
+  );
+}
+export function createVirtualClientPageAssetsModule(projectRoot) {
+  const clientPagesDir = resolve(projectRoot, "client/pages");
+  const files = existsSync(clientPagesDir) ? collectFiles(clientPagesDir, [".ts"]) : [];
+  const imports = files.map((filePath, index) => {
+    return `import bundle_${index} from ${JSON.stringify(`${toAbsoluteImport(filePath)}?assets=client`)};`;
+  });
+  const entries = files.map((filePath, index) => {
+    const key = basename(filePath, extname(filePath));
+    return `${JSON.stringify(key)}: bundle_${index}`;
+  });
+  return [
+    ...imports,
+    "",
+    "const bundles = {",
+    ...entries.map((entry) => `  ${entry},`),
+    "};",
+    "",
+    "export default bundles;",
+    ""
+  ].join("\n");
+}