@monkeyplus/flow 5.0.0-rc.98 → 6.0.0

package/src/public/nitro.mjs

@@ -0,0 +1,78 @@
+import { resolve } from "node:path";
+import { defineNitroConfig } from "nitro/config";
+import { resolveFlowConfig } from "../runtime/config.ts";
+import { loadFlowModules } from "../runtime/modules.ts";
+import { createFlowBuildHooks } from "../runtime/ssg.ts";
+import {
+  createVirtualBaseTemplatesModule,
+  createVirtualIslandsModule,
+  createVirtualLayoutsModule,
+  createVirtualPagesModule,
+  createVirtualTemplatesModule
+} from "../runtime/virtual-pages.ts";
+import { resolvePackageFile } from "./shared.ts";
+export function createFlowNitroConfig(options = {}) {
+  const projectRoot = resolve(options.projectRoot || process.cwd());
+  const flowConfig = resolveFlowConfig(options.userFlowConfig || {});
+  const flowModules = loadFlowModules(projectRoot, flowConfig);
+  const flowNitroConfig = { ...flowConfig.nitro || {} };
+  const flowNitroHooks = flowNitroConfig.hooks || {};
+  const flowRuntimeConfig = typeof flowModules.nitro.runtimeConfig.flow === "object" && flowModules.nitro.runtimeConfig.flow ? flowModules.nitro.runtimeConfig.flow : {};
+  const moduleRuntimeConfig = { ...flowModules.nitro.runtimeConfig };
+  delete moduleRuntimeConfig.flow;
+  return defineNitroConfig({
+    compatibilityDate: "2026-04-02",
+    builder: "vite",
+    renderer: {
+      handler: resolvePackageFile("server/renderer.ts", "server/renderer.mjs", "server/renderer.js")
+    },
+    framework: {
+      name: "@monkeyplus/flow",
+      version: "6.0.0"
+    },
+    serverDir: "./server",
+    devServer: {
+      watch: [
+        resolve(projectRoot, "flow.config.ts"),
+        resolve(projectRoot, "pages"),
+        resolve(projectRoot, "client"),
+        resolve(projectRoot, "views")
+      ]
+    },
+    serverEntry: resolvePackageFile("server.ts", "server.mjs", "server.js"),
+    virtual: {
+      "virtual:flow/pages": createVirtualPagesModule(projectRoot, flowConfig),
+      "virtual:flow/islands": createVirtualIslandsModule(projectRoot),
+      "virtual:flow/templates": createVirtualTemplatesModule(projectRoot),
+      "virtual:flow/layouts": createVirtualLayoutsModule(projectRoot),
+      "virtual:flow/bases": createVirtualBaseTemplatesModule(projectRoot),
+      ...flowModules.nitro.virtual
+    },
+    hooks: createFlowBuildHooks({
+      projectRoot,
+      flowConfig,
+      modulePrerenderRoutes: flowModules.prerenderRoutes,
+      existingHooks: flowNitroHooks
+    }),
+    plugins: flowModules.nitro.plugins,
+    handlers: flowModules.nitro.handlers,
+    routeRules: {
+      "/api/**": { cors: true },
+      ...flowModules.nitro.routeRules
+    },
+    runtimeConfig: {
+      app: {
+        name: "@monkeyplus/flow",
+        version: "6.0.0"
+      },
+      flow: {
+        build: flowConfig.build,
+        dir: flowConfig.dir,
+        locale: flowConfig.locale,
+        siteUrl: flowConfig.siteUrl,
+        ...flowRuntimeConfig
+      },
+      ...moduleRuntimeConfig
+    }
+  });
+}

package/src/public/shared.d.ts

@@ -0,0 +1,2 @@
+export declare function resolvePackagePath(...segments: string[]): string;
+export declare function resolvePackageFile(...candidates: string[]): string;

package/src/public/shared.mjs

@@ -0,0 +1,18 @@
+import { accessSync, constants } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const publicDir = dirname(fileURLToPath(import.meta.url));
+export function resolvePackagePath(...segments) {
+  return resolve(publicDir, "..", "..", ...segments);
+}
+export function resolvePackageFile(...candidates) {
+  for (const candidate of candidates) {
+    const absolutePath = resolvePackagePath(candidate);
+    try {
+      accessSync(absolutePath, constants.F_OK);
+      return absolutePath;
+    } catch {
+    }
+  }
+  return resolvePackagePath(candidates[0] || "");
+}

package/src/public/vite.d.ts

@@ -0,0 +1,6 @@
+import type { UserFlowConfig } from '../runtime/config.ts';
+export interface CreateFlowViteConfigOptions {
+    projectRoot?: string;
+    userFlowConfig?: UserFlowConfig;
+}
+export declare function createFlowViteConfig(options?: CreateFlowViteConfigOptions): any;

package/src/public/vite.mjs

@@ -0,0 +1,273 @@
+import { existsSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import Vue from "@vitejs/plugin-vue";
+import { nitro } from "nitro/vite";
+import { defineConfig, normalizePath } from "vite";
+import IconsResolver from "unplugin-icons/resolver";
+import Icons from "unplugin-icons/vite";
+import ui from "@nuxt/ui/vite";
+import { resolveFlowConfig } from "../runtime/config.ts";
+import { loadFlowModules } from "../runtime/modules.ts";
+import { getPrerenderRoutes } from "../runtime/page-discovery.ts";
+import {
+  createVirtualBaseTemplatesModule,
+  createVirtualClientPageAssetsModule,
+  createVirtualClientPagesModule,
+  createVirtualIslandsModule,
+  createVirtualLayoutsModule,
+  createVirtualPagesModule,
+  createVirtualTemplatesModule
+} from "../runtime/virtual-pages.ts";
+const flowRestartPatterns = [
+  /^flow\.config\.ts$/,
+  /^nitro\.config\.ts$/,
+  /^vite\.config\.ts$/,
+  /^pages\/.+\.ts$/,
+  /^views\/templates\/.+\.vue$/,
+  /^views\/layouts\/.+\.vue$/,
+  /^views\/base\/.+\.html$/,
+  /^server\/.+\.(ts|js|mjs|mts)$/,
+  /^server\.ts$/,
+  /^entry-server\.ts$/
+];
+const flowFullReloadPatterns = [
+  /^client\/pages\/.+\.ts$/,
+  /^client\/islands\/.+\.ts$/
+];
+const flowStructureReloadPatterns = [
+  /^pages\/.+\.ts$/,
+  /^views\/templates\/.+\.vue$/,
+  /^views\/layouts\/.+\.vue$/,
+  /^views\/base\/.+\.html$/,
+  /^client\/pages\/.+\.ts$/,
+  /^client\/islands\/.+\.(ts|vue)$/
+];
+function matchesAny(patterns, value) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+function getVirtualModuleIdsForPath(projectPath) {
+  const ids = /* @__PURE__ */ new Set();
+  if (projectPath === "flow.config.ts" || projectPath.startsWith("pages/")) {
+    ids.add("virtual:flow/pages");
+  }
+  if (projectPath.startsWith("views/templates/")) {
+    ids.add("virtual:flow/templates");
+  }
+  if (projectPath.startsWith("views/layouts/")) {
+    ids.add("virtual:flow/layouts");
+  }
+  if (projectPath.startsWith("views/base/")) {
+    ids.add("virtual:flow/bases");
+  }
+  if (projectPath.startsWith("client/pages/")) {
+    ids.add("virtual:flow/client-pages");
+    ids.add("virtual:flow/client-page-assets");
+  }
+  if (projectPath.startsWith("client/islands/")) {
+    ids.add("virtual:flow/islands");
+  }
+  return [...ids];
+}
+function invalidateVirtualModules(server, projectPath) {
+  const ids = getVirtualModuleIdsForPath(projectPath);
+  for (const id of ids) {
+    for (const candidate of [id, `\0${id}`]) {
+      const mod = server.moduleGraph.getModuleById(candidate);
+      if (mod) {
+        server.moduleGraph.invalidateModule(mod);
+      }
+    }
+  }
+}
+function invalidateFileModules(server, filePath, event) {
+  const normalizedFile = normalizePath(filePath);
+  if (event === "unlink") {
+    server.moduleGraph.onFileDelete(normalizedFile);
+    for (const environment of Object.values(server.environments)) {
+      environment.moduleGraph.onFileDelete(normalizedFile);
+    }
+    return;
+  }
+  server.moduleGraph.onFileChange(normalizedFile);
+  for (const environment of Object.values(server.environments)) {
+    environment.moduleGraph.onFileChange(normalizedFile);
+  }
+  const mixedModules = server.moduleGraph.getModulesByFile(normalizedFile) || [];
+  for (const mod of mixedModules) {
+    server.moduleGraph.invalidateModule(mod);
+  }
+  for (const environment of Object.values(server.environments)) {
+    const modules = environment.moduleGraph.getModulesByFile(normalizedFile) || [];
+    for (const mod of modules) {
+      environment.moduleGraph.invalidateModule(mod);
+    }
+  }
+}
+function createFlowHotReload(projectRoot) {
+  let restartPending = false;
+  function toProjectPath(filePath) {
+    return normalizePath(relative(projectRoot, filePath));
+  }
+  function scheduleRestart(server) {
+    if (restartPending) {
+      return;
+    }
+    restartPending = true;
+    server.ws.send({ type: "full-reload", path: "*" });
+    setTimeout(() => {
+      void server.restart().finally(() => {
+        restartPending = false;
+      });
+    }, 0);
+  }
+  async function handleServerChange(server, filePath, event) {
+    const projectPath = toProjectPath(filePath);
+    invalidateFileModules(server, filePath, event);
+    invalidateVirtualModules(server, projectPath);
+    if (matchesAny(flowRestartPatterns, projectPath)) {
+      scheduleRestart(server);
+      return true;
+    }
+    const shouldReload = event === "change" ? matchesAny(flowFullReloadPatterns, projectPath) : matchesAny(flowStructureReloadPatterns, projectPath);
+    if (!shouldReload) {
+      return false;
+    }
+    server.ws.send({ type: "full-reload", path: "*" });
+    return true;
+  }
+  return {
+    name: "flow:hot-reload",
+    configureServer(server) {
+      server.watcher.on("add", (filePath) => {
+        void handleServerChange(server, filePath, "add");
+      });
+      server.watcher.on("unlink", (filePath) => {
+        void handleServerChange(server, filePath, "unlink");
+      });
+    },
+    async handleHotUpdate(ctx) {
+      if (await handleServerChange(ctx.server, ctx.file, "change")) {
+        return [];
+      }
+    }
+  };
+}
+function createFlowVirtualServerModules(projectRoot, flowConfig) {
+  const modules = /* @__PURE__ */ new Map([
+    ["virtual:flow/pages", () => createVirtualPagesModule(projectRoot, flowConfig)],
+    ["virtual:flow/client-page-assets", () => createVirtualClientPageAssetsModule(projectRoot)],
+    ["virtual:flow/islands", () => createVirtualIslandsModule(projectRoot)],
+    ["virtual:flow/templates", () => createVirtualTemplatesModule(projectRoot)],
+    ["virtual:flow/layouts", () => createVirtualLayoutsModule(projectRoot)],
+    ["virtual:flow/bases", () => createVirtualBaseTemplatesModule(projectRoot)]
+  ]);
+  return {
+    name: "flow:server-virtuals",
+    enforce: "pre",
+    resolveId(id) {
+      if (modules.has(id)) {
+        return `\0${id}`;
+      }
+    },
+    load(id) {
+      const normalizedId = id.startsWith("\0") ? id.slice(1) : id;
+      const factory = modules.get(normalizedId);
+      if (!factory) {
+        return null;
+      }
+      return factory();
+    }
+  };
+}
+function createFlowVirtualClientPages(projectRoot) {
+  const virtualId = "virtual:flow/client-pages";
+  const resolvedVirtualId = `\0${virtualId}`;
+  return {
+    name: "flow:client-pages",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === virtualId) {
+        return resolvedVirtualId;
+      }
+    },
+    load(id) {
+      if (id !== resolvedVirtualId) {
+        return null;
+      }
+      const clientPagesDir = resolve(projectRoot, "client/pages");
+      if (!existsSync(clientPagesDir)) {
+        return "const bundles = {};\n\nexport default bundles;\n";
+      }
+      return createVirtualClientPagesModule(projectRoot);
+    }
+  };
+}
+export function createFlowViteConfig(options = {}) {
+  const projectRoot = resolve(options.projectRoot || process.cwd());
+  const flowConfig = resolveFlowConfig(options.userFlowConfig || {});
+  const flowModules = loadFlowModules(projectRoot, flowConfig);
+  const flowNitroConfig = { ...flowConfig.nitro || {} };
+  const flowNitroHooks = flowNitroConfig.hooks || {};
+  const userPrerenderRoutesHook = typeof flowNitroHooks["prerender:routes"] === "function" ? flowNitroHooks["prerender:routes"] : void 0;
+  return defineConfig({
+    plugins: [
+      createFlowVirtualServerModules(projectRoot, flowConfig),
+      createFlowVirtualClientPages(projectRoot),
+      createFlowHotReload(projectRoot),
+      ...flowModules.vite.plugins,
+      Icons({
+        autoInstall: true,
+        compiler: "vue3"
+      }),
+      Vue(),
+      ui({
+        router: false,
+        components: {
+          resolvers: [
+            IconsResolver()
+          ]
+        }
+      }),
+      nitro({
+        ...flowNitroConfig,
+        hooks: {
+          ...flowNitroHooks,
+          async "prerender:routes"(routes) {
+            const discoveredRoutes = await getPrerenderRoutes(projectRoot, flowConfig);
+            for (const route of discoveredRoutes) {
+              routes.add(route);
+            }
+            for (const route of flowModules.prerenderRoutes) {
+              routes.add(route);
+            }
+            if (userPrerenderRoutesHook) {
+              await userPrerenderRoutesHook(routes);
+            }
+          }
+        }
+      })
+    ],
+    environments: {
+      client: {
+        build: {
+          rollupOptions: {
+            input: resolve(projectRoot, "src/main.ts")
+          }
+        }
+      },
+      ssr: {
+        build: {
+          rollupOptions: {
+            input: resolve(projectRoot, "entry-server.ts")
+          }
+        }
+      }
+    },
+    resolve: {
+      alias: {
+        "@": resolve(projectRoot, "src"),
+        ...flowModules.vite.resolve.alias
+      }
+    }
+  });
+}

package/src/public/vue.d.ts

@@ -0,0 +1 @@
+export { installFlowVuePlugins } from '../runtime/vue.ts';

package/src/public/vue.mjs

@@ -0,0 +1 @@
+export { installFlowVuePlugins } from "../runtime/vue.ts";

package/src/runtime/boot.d.ts

@@ -0,0 +1,9 @@
+import type { FlowHydrationMode, FlowLocale } from './pages';
+export interface FlowBootPayload {
+    path: string;
+    bundle: string;
+    template: string;
+    title: string;
+    locale: FlowLocale;
+    mode: FlowHydrationMode;
+}

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

@@ -0,0 +1,42 @@
+import { type Component, type PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    component: {
+        type: PropType<Component>;
+        required: true;
+    };
+    props: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => 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<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    component: {
+        type: PropType<Component>;
+        required: true;
+    };
+    props: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    props: Record<string, unknown>;
+    tag: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/runtime/components/FlowIsland.mjs

@@ -0,0 +1,35 @@
+import { defineComponent, h, mergeProps, useAttrs } from "vue";
+function serializeIslandProps(props) {
+  return JSON.stringify(props).replaceAll("<", "\\u003c");
+}
+export default defineComponent({
+  name: "FlowIsland",
+  inheritAttrs: false,
+  props: {
+    name: {
+      type: String,
+      required: true
+    },
+    component: {
+      type: [Object, Function],
+      required: true
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    tag: {
+      type: String,
+      default: "div"
+    }
+  },
+  setup(props) {
+    const attrs = useAttrs();
+    return () => h(props.tag, mergeProps(attrs, {
+      "data-flow-island": props.name.toLowerCase(),
+      "data-flow-props": serializeIslandProps(props.props)
+    }), [
+      h(props.component, props.props)
+    ]);
+  }
+});

package/src/runtime/config.d.ts

@@ -0,0 +1,73 @@
+export interface FlowDirEntry {
+    dir: string;
+}
+export type FlowBuildPreset = 'server' | 'ssg';
+export interface FlowBuildConfig {
+    preset: FlowBuildPreset;
+}
+export interface FlowModuleMeta {
+    name: string;
+    configKey?: string;
+}
+export interface FlowModuleDefinition<TOptions = Record<string, unknown>> {
+    meta?: FlowModuleMeta;
+    defaults?: Partial<TOptions>;
+    setup?: (options: TOptions, context: FlowModuleSetupContext) => void;
+}
+export interface FlowModuleInstall<TOptions = Record<string, unknown>> {
+    module: string | FlowModuleDefinition<TOptions>;
+    options?: Partial<TOptions>;
+}
+export type FlowModuleInput = string | FlowModuleDefinition<any> | FlowModuleInstall<any> | [string | FlowModuleDefinition<any>, Record<string, unknown>?];
+export interface FlowLocaleConfig {
+    locales: string[];
+    location: string;
+    language: string;
+}
+export interface FlowConfig {
+    modules: FlowModuleInput[];
+    dir: {
+        pages: FlowDirEntry[];
+    };
+    build: FlowBuildConfig;
+    locale: FlowLocaleConfig;
+    siteUrl?: string;
+    nitro?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export type UserFlowConfig = Partial<FlowConfig> & Record<string, unknown> & {
+    build?: Partial<FlowBuildConfig>;
+    dir?: {
+        pages?: FlowDirEntry[];
+    };
+    locale?: Partial<FlowLocaleConfig>;
+    siteUrl?: string;
+};
+export interface FlowModuleNitroConfig extends Record<string, unknown> {
+    plugins: string[];
+    handlers: Array<Record<string, unknown>>;
+    routeRules: Record<string, Record<string, unknown>>;
+    runtimeConfig: Record<string, unknown>;
+    virtual: Record<string, string | (() => string | Promise<string>)>;
+}
+export interface FlowModuleViteConfig extends Record<string, unknown> {
+    plugins: unknown[];
+    resolve: {
+        alias: Record<string, string>;
+    };
+    server: {
+        watch: {
+            additionalPaths: string[];
+        };
+    };
+}
+export interface FlowModuleSetupContext {
+    projectRoot: string;
+    flowConfig: FlowConfig;
+    nitro: FlowModuleNitroConfig;
+    vite: FlowModuleViteConfig;
+    prerenderRoutes: Set<string>;
+}
+export declare function defineFlowConfig(config: UserFlowConfig): UserFlowConfig;
+export declare function defineFlowModule<TOptions = Record<string, unknown>>(module: FlowModuleDefinition<TOptions>): FlowModuleDefinition<TOptions>;
+export declare function resolveFlowConfig(userFlowConfig?: UserFlowConfig): FlowConfig;

package/src/runtime/config.mjs

@@ -0,0 +1,26 @@
+export function defineFlowConfig(config) {
+  return config;
+}
+export function defineFlowModule(module) {
+  return module;
+}
+export function resolveFlowConfig(userFlowConfig = {}) {
+  const preset = process.env.FLOW_BUILD_PRESET === "ssg" ? "ssg" : process.env.FLOW_BUILD_PRESET === "server" ? "server" : userFlowConfig.build?.preset || "server";
+  return {
+    ...userFlowConfig,
+    modules: userFlowConfig.modules || [],
+    build: {
+      preset
+    },
+    siteUrl: userFlowConfig.siteUrl,
+    nitro: userFlowConfig.nitro,
+    dir: {
+      pages: userFlowConfig.dir?.pages?.length ? userFlowConfig.dir.pages : [{ dir: "pages" }]
+    },
+    locale: {
+      locales: userFlowConfig.locale?.locales?.length ? userFlowConfig.locale.locales : ["es-ec"],
+      location: userFlowConfig.locale?.location || "ec",
+      language: userFlowConfig.locale?.language || "es"
+    }
+  };
+}

package/src/runtime/head.d.ts

@@ -0,0 +1,3 @@
+import { useHead, useSeoMeta } from '@unhead/vue';
+export declare function getClientHead(): import("@unhead/vue").VueHeadClient<import("@unhead/vue").UseHeadInput<_Deprecated>, boolean>;
+export { useHead, useSeoMeta };

package/src/runtime/head.mjs

@@ -0,0 +1,7 @@
+import { createHead } from "@unhead/vue/client";
+import { useHead, useSeoMeta } from "@unhead/vue";
+const clientHead = createHead();
+export function getClientHead() {
+  return clientHead;
+}
+export { useHead, useSeoMeta };

package/src/runtime/islands.d.ts

@@ -0,0 +1,2 @@
+import type { FlowBootPayload } from './boot';
+export declare function hydrateIslands(boot?: FlowBootPayload): Promise<void>;

package/src/runtime/islands.mjs

@@ -0,0 +1,52 @@
+import { createSSRApp } from "vue";
+import { getClientHead } from "./head.mjs";
+import { installFlowVuePlugins } from "./vue.mjs";
+import islands from "virtual:flow/islands";
+function parseIslandProps(value) {
+  if (!value) {
+    return {};
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+}
+async function hydrateIsland(element, boot) {
+  if (element.dataset.flowIslandHydrated === "true") {
+    return;
+  }
+  const islandName = element.dataset.flowIsland?.toLowerCase();
+  if (!islandName) {
+    return;
+  }
+  const importer = islands[islandName];
+  if (!importer) {
+    return;
+  }
+  const props = parseIslandProps(element.dataset.flowProps);
+  const mod = await importer();
+  if (mod.hydrate) {
+    await mod.hydrate({
+      element,
+      props,
+      boot
+    });
+    element.dataset.flowIslandHydrated = "true";
+    return;
+  }
+  if (!mod.default) {
+    return;
+  }
+  const app = createSSRApp(mod.default, props);
+  app.use(getClientHead());
+  installFlowVuePlugins(app);
+  app.mount(element);
+  element.dataset.flowIslandHydrated = "true";
+}
+export async function hydrateIslands(boot) {
+  const elements = Array.from(document.querySelectorAll("[data-flow-island]"));
+  for (const element of elements) {
+    await hydrateIsland(element, boot);
+  }
+}

package/src/runtime/modules.d.ts

@@ -0,0 +1,12 @@
+import type { FlowConfig, FlowModuleNitroConfig, FlowModuleViteConfig } from './config.ts';
+export interface LoadedFlowModule {
+    name: string;
+    options: Record<string, unknown>;
+}
+export interface FlowModuleResolution {
+    modules: LoadedFlowModule[];
+    nitro: FlowModuleNitroConfig;
+    vite: FlowModuleViteConfig;
+    prerenderRoutes: string[];
+}
+export declare function loadFlowModules(projectRoot: string, flowConfig: FlowConfig): FlowModuleResolution;