@monkeyplus/flow 5.0.0-rc.99 → 6.0.0

package/dist/chunks/index.mjs

@@ -1,1140 +0,0 @@
-import { createHooks } from 'hookable';
-import { dirname, resolve, normalize, join, isAbsolute, relative, extname } from 'pathe';
-import { defineFlowModule, addPlugin, defineNuxtModule, logger, addTemplate, addPluginTemplate, addVitePlugin, useNuxt, resolveAlias, resolveFilesFlow, nuxtCtx, installModule, loadFlowConfig, templateUtils, normalizeTemplate, compileTemplate, normalizePlugin, isIgnoredFlow } from '@monkeyplus/flow-kit';
-import { fileURLToPath } from 'url';
-import { defineUnimportPreset, createUnimport, toImports, scanDirExports } from 'unimport';
-import { pathToFileURL } from 'node:url';
-import { createUnplugin } from 'unplugin';
-import { parseURL, parseQuery, joinURL } from 'ufo';
-import fs from 'fs';
-import escapeRE from 'escape-string-regexp';
-import { camelCase, pascalCase } from 'scule';
-import { genImport, genDynamicImport, genArrayFromRaw, genString } from 'knitwork';
-import fse from 'fs-extra';
-import logger$1 from 'consola';
-import * as vite from 'vite';
-import { createServer, build as build$1 } from 'vite';
-import { debounce } from 'perfect-debounce';
-import { existsSync, promises } from 'node:fs';
-import { createNitro, scanHandlers, writeTypes, build as build$2, prepare, copyPublicAssets, prerender, createDevServer } from 'nitropack';
-import defu from 'defu';
-import { dynamicEventHandler, toEventHandler } from 'h3';
-import { createRequire } from 'node:module';
-import chokidar from 'chokidar';
-import { generateTypes, resolveSchema } from 'untyped';
-import replace from '@rollup/plugin-replace';
-import { sanitizeFilePath } from 'mlly';
-import { resolveTSConfig } from 'pkg-types';
-
-const version = "5.0.0-rc.99";
-
-let _distDir = dirname(fileURLToPath(import.meta.url));
-if (_distDir.endsWith("chunks"))
-  _distDir = dirname(_distDir);
-const distDir = _distDir;
-const pkgDir = resolve(distDir, "..");
-resolve(distDir, "runtime");
-
-const metaModule = defineFlowModule({
-  meta: {
-    name: "meta"
-  },
-  defaults: {
-    charset: "utf-8",
-    viewport: "width=device-width, initial-scale=1"
-  },
-  setup(options, flow) {
-    const runtimeDir = flow.options.alias["#head"] || resolve(distDir, "head/runtime");
-    flow.options.alias["#head"] = runtimeDir;
-    addPlugin({ src: resolve(runtimeDir, "plugin") });
-  }
-});
-
-const TransformPlugin = createUnplugin(({ ctx, options, sourcemap }) => {
-  return {
-    name: "flow:auto-imports-transform",
-    enforce: "post",
-    transformInclude(id) {
-      const { pathname, search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
-      const { type, macro } = parseQuery(search);
-      const exclude = options.transform?.exclude || [/[\\/]node_modules[\\/]/];
-      const include = options.transform?.include || [];
-      if (exclude.some((pattern) => id.match(pattern)))
-        return false;
-      if (include.some((pattern) => id.match(pattern)))
-        return true;
-      if (pathname.endsWith(".vue") && (type === "template" || type === "script" || macro || !search))
-        return true;
-      if (pathname.match(/\.((c|m)?j|t)sx?$/g))
-        return true;
-    },
-    async transform(_code, id) {
-      const { code, s } = await ctx.injectImports(_code);
-      if (code === _code)
-        return;
-      return {
-        code,
-        map: sourcemap && s.generateMap({ source: id, includeContent: true })
-      };
-    }
-  };
-});
-
-const commonPresets = [
-  defineUnimportPreset({
-    from: "#head",
-    imports: [
-      "useHead"
-    ]
-  }),
-  defineUnimportPreset({
-    from: "#_pages",
-    imports: [
-      "definePage",
-      "defineDynamicPage",
-      "defineSharedContext"
-    ]
-  })
-];
-const appPreset = defineUnimportPreset({
-  from: "#app",
-  imports: [
-    "useRuntimeConfig",
-    "defineFlowPlugin",
-    "defineNuxtPlugin",
-    "useCookie",
-    "refreshNuxtData",
-    "useAsyncData",
-    "useRoute"
-  ]
-});
-const vuePreset = defineUnimportPreset({
-  from: "vue",
-  imports: [
-    "defineComponent",
-    "getCurrentInstance",
-    "useSlots",
-    "h",
-    "computed"
-  ]
-});
-const defaultPresets = [
-  ...commonPresets,
-  appPreset,
-  vuePreset
-];
-
-const autoImportsModule = defineNuxtModule({
-  meta: {
-    name: "auto-imports",
-    configKey: "autoImports"
-  },
-  defaults: {
-    presets: defaultPresets,
-    global: false,
-    imports: [],
-    dirs: [],
-    transform: {
-      exclude: void 0
-    }
-  },
-  async setup(options, flow) {
-    await flow.callHook("autoImports:sources", options.presets);
-    options.presets.forEach((i) => {
-      if (typeof i !== "string" && i.names && !i.imports) {
-        i.imports = i.names;
-        logger.warn("auto-imports: presets.names is deprecated, use presets.imports instead");
-      }
-    });
-    const ctx = createUnimport({
-      presets: options.presets,
-      imports: options.imports
-    });
-    let composablesDirs = [];
-    for (const layer of flow.options._layers) {
-      composablesDirs.push(resolve(layer.config.srcDir, "composables"));
-      for (const dir of layer.config.autoImports?.dirs ?? [])
-        composablesDirs.push(resolve(layer.config.srcDir, dir));
-    }
-    await flow.callHook("autoImports:dirs", composablesDirs);
-    composablesDirs = composablesDirs.map((dir) => normalize(dir));
-    addTemplate({
-      filename: "imports.mjs",
-      getContents: () => ctx.toExports()
-    });
-    flow.options.alias["#imports"] = join(flow.options.buildDir, "imports");
-    if (flow.options.dev && options.global) {
-      addPluginTemplate({
-        filename: "auto-imports.mjs",
-        getContents: () => {
-          const imports = ctx.getImports();
-          const importStatement = toImports(imports);
-          const globalThisSet = imports.map((i) => `globalThis.${i.as} = ${i.as};`).join("\n");
-          return `${importStatement}
-
-${globalThisSet}
-
-export default () => {};`;
-        }
-      });
-    } else {
-      addVitePlugin(TransformPlugin.vite({ ctx, options, sourcemap: flow.options.sourcemap }));
-    }
-    const regenerateAutoImports = async () => {
-      ctx.clearDynamicImports();
-      await ctx.modifyDynamicImports(async (imports) => {
-        imports.push(...await scanDirExports(composablesDirs));
-        await flow.callHook("autoImports:extend", imports);
-      });
-    };
-    await regenerateAutoImports();
-    addDeclarationTemplates(ctx);
-    flow.hook("prepare:types", ({ references }) => {
-      references.push({ path: resolve(flow.options.buildDir, "types/auto-imports.d.ts") });
-      references.push({ path: resolve(flow.options.buildDir, "imports.d.ts") });
-    });
-    flow.hook("builder:watch", async (_, path) => {
-      const _resolved = resolve(flow.options.srcDir, path);
-      if (composablesDirs.find((dir) => _resolved.startsWith(dir)))
-        await flow.callHook("builder:generateApp");
-    });
-    flow.hook("builder:generateApp", async () => {
-      await regenerateAutoImports();
-    });
-  }
-});
-function addDeclarationTemplates(ctx) {
-  const nuxt = useNuxt();
-  const stripExtension = (path) => path.replace(/\.[a-z]+$/, "");
-  const resolved = {};
-  const r = ({ from }) => {
-    if (resolved[from])
-      return resolved[from];
-    let path = resolveAlias(from);
-    if (isAbsolute(path))
-      path = relative(join(nuxt.options.buildDir, "types"), path);
-    path = stripExtension(path);
-    resolved[from] = path;
-    return path;
-  };
-  addTemplate({
-    filename: "imports.d.ts",
-    getContents: () => ctx.toExports()
-  });
-  addTemplate({
-    filename: "types/auto-imports.d.ts",
-    getContents: () => `// Generated by auto imports
-${ctx.generateTypeDeclarations({ resolvePath: r })}`
-  });
-}
-
-async function resolveFiles(dir) {
-  const nuxt = useNuxt();
-  const dirs = [resolve(nuxt.options.srcDir, dir)];
-  const allRoutes = (await Promise.all(
-    dirs.map(async (dir2) => {
-      const files = await resolveFilesFlow(dir2, `**/*{${nuxt.options.extensions.join(",")}}`);
-      files.sort();
-      return files.filter((file) => {
-        if (file.includes(" copy"))
-          return false;
-        if (!fs.readFileSync(file, "utf8").includes("export"))
-          return false;
-        return true;
-      }).map((file) => {
-        const segments = relative(dir2, file).replace(new RegExp(`${escapeRE(extname(file))}$`), "").split("/").join("_");
-        return {
-          file,
-          name: camelCase(segments)
-        };
-      });
-    })
-  )).flat();
-  return allRoutes;
-}
-function normalizeExports(files) {
-  const imports = files.map((page) => genImport(page.file, page.name)).join("\n");
-  const exports = files.reduce((acc, curr) => {
-    const name = curr.name;
-    return `${name}:typeof ${name}==='function'?${name}():${name},${acc}`;
-  }, "");
-  return {
-    imports,
-    exports
-  };
-}
-
-const pagesTypeTemplate = {
-  filename: "types/pages.d.ts",
-  getContents: ({ options }) => `// Generated by pages discovery
-export {}
-declare global {
-  type ArrElement<ArrType> = ArrType extends readonly (infer ElementType)[]
-  ? ElementType
-  : never;
-
-${options.pages.map((c) => {
-    const _type = `ArrElement<typeof ${genDynamicImport(isAbsolute(c.file) ? relative(join(options.buildDir, "types"), c.file) : c.file, { wrapper: false })}['default']>`;
-    return `export type ${pascalCase(c.name)}Context=Awaited<ReturnType<${_type}['locales']['es-ec']['context']>>`;
-  }).join("\n")}
-}
-export const pagesNames: string[]
-`.replaceAll(".ts", "")
-};
-
-const pagesModule = defineNuxtModule({
-  meta: {
-    name: "pages"
-  },
-  async setup(_options, flow) {
-    const runtimeDir = resolve(distDir, "pages/runtime");
-    flow.options.alias["#_pages"] = runtimeDir;
-    const pages = [];
-    const contexts = [];
-    const options = { pages, buildDir: flow.options.buildDir, contexts };
-    addTemplate({
-      ...pagesTypeTemplate,
-      options
-    });
-    const pagesDirs = [{ path: resolve(flow.options.srcDir, flow.options.dir.pages) }];
-    flow.options.alias["#pages"] = resolve(flow.options.buildDir, "pages.mjs");
-    flow.options.alias["#pagesContexts"] = resolve(flow.options.buildDir, "pages.contexts.mjs");
-    addTemplate({
-      filename: "pages.mjs",
-      async getContents({ options: options2 }) {
-        const { exports, imports } = normalizeExports(options2.pages);
-        const module = [imports, `export default {${exports}}`].join("\n");
-        return module;
-      },
-      options
-    });
-    addTemplate({
-      filename: "pages.contexts.mjs",
-      async getContents({ options: options2 }) {
-        const { exports, imports } = normalizeExports(options2.contexts);
-        const module = [imports, `export default {${exports}}`].join("\n");
-        return module;
-      },
-      options
-    });
-    flow.hook("app:templates", async () => {
-      options.pages = await resolveFiles(flow.options.dir?.pages || "pages");
-    });
-    flow.hook("app:templates", async () => {
-      options.contexts = await resolveFiles("shared/contexts");
-    });
-    flow.hook("prepare:types", ({ references }) => {
-      references.push({ path: resolve(flow.options.buildDir, "types/pages.d.ts") });
-    });
-    flow.hook("builder:watch", async (event, path) => {
-      if (!["add", "unlink", "change"].includes(event))
-        return;
-      if (path.includes(" copy"))
-        return;
-      const fPath = resolve(flow.options.rootDir, path);
-      if (pagesDirs.find((dir) => fPath.startsWith(dir.path)))
-        await flow.callHook("builder:generateApp");
-    });
-    addPlugin(resolve(runtimeDir, "pages"));
-  }
-});
-
-const createClient = async (flow) => {
-  let vite;
-  if (globalThis.viteClient) {
-    vite = globalThis.viteClient;
-  } else {
-    vite = await createServer({
-      root: resolve(flow.options.rootDir),
-      base: "/_vite/",
-      build: {
-        manifest: true
-      },
-      server: {
-        watch: {
-          ignored: ["**/.env/**", "**/.env*"]
-        },
-        middlewareMode: true
-      }
-    });
-    globalThis.viteClient = vite;
-  }
-  const _doReload = () => {
-    if (vite)
-      vite?.ws?.send({ type: "full-reload" });
-  };
-  const doReload = debounce(_doReload, 75);
-  flow.hook("bundler:change", () => {
-    doReload();
-  });
-  flow.hook("close", async () => {
-    vite.restart();
-  });
-  return vite;
-};
-
-const builClient = async (flow) => {
-  return await build$1({
-    base: flow.options.dev ? "/" : flow.options.app.baseURL,
-    root: flow.options.rootDir,
-    mode: "production",
-    build: {
-      outDir: "node_modules/.vite_flow",
-      manifest: true
-    }
-  });
-};
-const viteModule = defineFlowModule({
-  meta: {
-    name: "vite-client",
-    configKey: "bundle"
-  },
-  defaults: {
-    route: "/_vite/",
-    dir: "/client/pages"
-  },
-  async setup(_options, flow) {
-    const runtimeDir = resolve(distDir, "vite-client/runtime");
-    flow.options.alias["#viteManifest"] = resolve(flow.options.buildDir, "viteManifest.mjs");
-    let vite;
-    if (flow.options.dev) {
-      flow.hook("nitro:init", async (nitro) => {
-        vite = await createClient(flow);
-        nitro.options.devHandlers.push({
-          handler: vite.middlewares,
-          route: _options.route
-        });
-      });
-      addTemplate({
-        filename: "viteManifest.mjs",
-        async getContents() {
-          return [
-            "export default {",
-            `head:()=>'<script type="module" src="${joinURL("/", _options.route, "/@vite/client")}"><\/script>'`,
-            ",",
-            `body: (bundle)=>\`<script type="module" src="${joinURL("/", _options.route, _options.dir)}/\${bundle}.ts"><\/script>\``,
-            "}"
-          ].join("\n");
-        }
-      });
-    } else {
-      const file = resolve(flow.options.rootDir, "node_modules/.vite_flow/manifest.json");
-      addTemplate({
-        filename: "viteManifest.mjs",
-        async getContents() {
-          return [
-            "import fs from 'fs';",
-            `export default ()=>{
-            const manifest =JSON.parse(fs.readFileSync("${file}", 'utf8'));
-            return {manifest,base:'${_options.dir}'}
-          }`
-          ].join("\n");
-        }
-      });
-      flow.hook("build:before", async () => {
-        const start = Date.now();
-        logger$1.info("Building client...");
-        await builClient(flow);
-        logger$1.success(`Client build in ${Date.now() - start}ms`);
-      });
-      flow.hook("generate:before", async () => {
-        const files = resolve(flow.options.rootDir, "node_modules/.vite_flow/assets");
-        await fse.copy(files, resolve(flow.options.generate.dir, "assets"));
-      });
-    }
-    addPlugin({ src: resolve(runtimeDir, "plugin") });
-  }
-});
-
-const _require = createRequire(import.meta.url);
-const ImportProtectionPlugin = createUnplugin((options) => {
-  const cache = {};
-  return {
-    name: "flow:import-protection",
-    enforce: "pre",
-    resolveId(id, importer) {
-      const invalidImports = options.patterns.filter(([pattern]) => pattern instanceof RegExp ? pattern.test(id) : pattern === id);
-      let matched;
-      for (const match of invalidImports) {
-        cache[id] = cache[id] || /* @__PURE__ */ new Map();
-        const [pattern, warning] = match;
-        if (cache[id].has(pattern))
-          continue;
-        const relativeImporter = isAbsolute(importer) ? relative(options.rootDir, importer) : importer;
-        logger.error(warning || "Invalid import", `[importing \`${id}\` from \`${relativeImporter}\`]`);
-        cache[id].set(pattern, true);
-        matched = true;
-      }
-      if (matched)
-        return _require.resolve("unenv/runtime/mock/proxy");
-      return null;
-    }
-  };
-});
-
-async function initNitro(flow) {
-  const { handlers, devHandlers } = await resolveHandlers(flow);
-  const _nitroConfig = flow.options.nitro || {};
-  globalThis.generate = {};
-  const nitroConfig = defu(_nitroConfig, {
-    rootDir: flow.options.rootDir,
-    srcDir: join(flow.options.srcDir, "server"),
-    dev: flow.options.dev,
-    preset: flow.options.dev ? "nitro-dev" : void 0,
-    buildDir: flow.options.buildDir,
-    scanDirs: flow.options._layers.map((layer) => join(layer.config.srcDir, "server")),
-    renderer: resolve(distDir, "core/runtime/nitro/renderer"),
-    nodeModulesDirs: flow.options.modulesDir,
-    handlers,
-    devHandlers: [],
-    output: {
-      dir: resolve(flow.options.buildDir, "output")
-    },
-    baseURL: flow.options.app.baseURL,
-    runtimeConfig: {
-      ...flow.options.runtimeConfig,
-      app: {
-        ...flow.options.runtimeConfig.app,
-        baseURL: flow.options.dev ? "/" : flow.options.app.baseURL,
-        rootDir: flow.options.rootDir,
-        locale: flow.options.locale
-      },
-      nitro: {
-        envPrefix: "FLOW_",
-        ...flow.options.runtimeConfig.nitro
-      },
-      generate: flow.options._generate
-    },
-    typescript: {
-      generateTsConfig: false
-    },
-    publicAssets: [
-      {
-        baseURL: flow.options.app.buildAssetsDir,
-        dir: resolve(flow.options.buildDir, "dist/client")
-      },
-      ...flow.options._layers.map((layer) => join(layer.config.srcDir, layer.config.dir?.public || "public")).filter((dir) => existsSync(dir)).map((dir) => ({ dir }))
-    ],
-    prerender: {
-      crawlLinks: flow.options._generate ? flow.options.generate.crawler : false,
-      routes: [].concat(flow.options._generate ? ["/_urls", ...flow.options.generate.routes] : [])
-    },
-    sourcemap: flow.options.sourcemap,
-    externals: {
-      inline: [
-        ...flow.options.dev ? [] : ["eta", "@monkeyplus/", "@vue/", "@nuxt/", flow.options.buildDir],
-        "@monkeyplus/flow/dist",
-        "C:/Users/gnu/Documents/GitHub/flow/packages/flow/dist/app"
-      ]
-    },
-    alias: {
-      "estree-walker": "unenv/runtime/mock/proxy",
-      "@babel/parser": "unenv/runtime/mock/proxy",
-      "#paths": resolve(distDir, "core/runtime/nitro/paths"),
-      "#server": "#build/dist/server/server.mjs",
-      ...flow.options.alias
-    },
-    rollupConfig: {
-      plugins: [],
-      external: [""]
-    }
-  });
-  await flow.callHook("nitro:config", nitroConfig);
-  nitroConfig.handlers.unshift({
-    middleware: true,
-    handler: resolve(distDir, "core/runtime/nitro/flow")
-  });
-  const nitro = await createNitro(nitroConfig);
-  await flow.callHook("nitro:init", nitro);
-  nitro.vfs = flow.vfs = nitro.vfs || flow.vfs || {};
-  flow.hook("close", () => nitro.hooks.callHook("close"));
-  nitro.hooks.hook("rollup:before", (nitro2) => {
-    const plugin = ImportProtectionPlugin.rollup({
-      rootDir: flow.options.rootDir,
-      patterns: [
-        ...["#app", /^#build(\/|$)/].map((p) => [p, "Flow app aliases are not allowed in server routes."])
-      ]
-    });
-    nitro2.options.rollupConfig.plugins.push(plugin);
-  });
-  const devMidlewareHandler = dynamicEventHandler();
-  nitro.options.devHandlers.unshift({ handler: devMidlewareHandler });
-  nitro.options.devHandlers.push(...devHandlers);
-  nitro.options.handlers.unshift({
-    route: "/__flow_error",
-    lazy: true,
-    handler: resolve(distDir, "core/runtime/nitro/renderer")
-  });
-  flow.hook("prepare:types", async (opts) => {
-    if (flow.options._prepare) {
-      await scanHandlers(nitro);
-      await writeTypes(nitro);
-    }
-    opts.references.push({ path: resolve(flow.options.buildDir, "types/nitro.d.ts") });
-  });
-  flow.hook("build:done", async () => {
-    await flow.callHook("nitro:build:before", nitro);
-    if (flow.options.dev) {
-      await build$2(nitro);
-    } else {
-      await prepare(nitro);
-      await copyPublicAssets(nitro);
-      await prerender(nitro);
-      if (!flow.options._generate) {
-        await build$2(nitro);
-      } else {
-        const nitroDev = await createNitro({
-          ...nitro.options._config,
-          rootDir: nitro.options.rootDir,
-          logLevel: 0,
-          preset: "nitro-prerender"
-        });
-        flow.server = nitroDev;
-        const distDir2 = resolve(flow.options.rootDir, "dist");
-        if (!existsSync(distDir2))
-          await promises.symlink(nitro.options.output.publicDir, distDir2, "junction").catch(() => {
-          });
-      }
-    }
-  });
-  if (flow.options.dev) {
-    flow.hook("build:compile", ({ compiler }) => {
-      compiler.outputFileSystem = { ...fse, join };
-    });
-    flow.hook("server:devMiddleware", (m) => {
-      devMidlewareHandler.set(toEventHandler(m));
-    });
-    flow.server = createDevServer(nitro);
-    flow.hook("build:resources", () => {
-      flow.server.reload();
-    });
-    const waitUntilCompile = new Promise((resolve2) => nitro.hooks.hook("compiled", () => resolve2()));
-    flow.hook("build:done", () => waitUntilCompile);
-  }
-}
-async function resolveHandlers(flow) {
-  const handlers = [...flow.options.serverHandlers];
-  const devHandlers = [...flow.options.devServerHandlers];
-  return {
-    handlers,
-    devHandlers
-  };
-}
-
-const addModuleTranspiles = (opts = {}) => {
-  const flow = useNuxt();
-  const modules = [
-    ...opts.additionalModules || [],
-    ...flow.options.modules,
-    ...flow.options._modules
-  ].map((m) => typeof m === "string" ? m : Array.isArray(m) ? m[0] : m.src).filter((m) => typeof m === "string").map((m) => m.split("node_modules/").pop());
-  flow.options.build.transpile = flow.options.build.transpile.map((m) => typeof m === "string" ? m.split("node_modules/").pop() : m);
-  function isTranspilePresent(mod) {
-    return flow.options.build.transpile.some((t) => !(t instanceof Function) && (t instanceof RegExp ? t.test(mod) : new RegExp(t).test(mod)));
-  }
-  for (const module of modules) {
-    if (!isTranspilePresent(module))
-      flow.options.build.transpile.push(module);
-  }
-};
-
-function createFlow(options) {
-  const hooks = createHooks();
-  const flow = {
-    _version: "3.0.0-rc.3",
-    version,
-    options,
-    hooks,
-    callHook: hooks.callHook,
-    addHooks: hooks.addHooks,
-    hook: hooks.hook,
-    ready: () => initFlow(flow),
-    close: () => Promise.resolve(hooks.callHook("close", flow)),
-    vfs: {}
-  };
-  return flow;
-}
-async function initFlow(flow) {
-  nuxtCtx.set(flow);
-  flow.hook("close", () => nuxtCtx.unset());
-  await flow.callHook("modules:before", { nuxt: flow });
-  const modulesToInstall = [
-    ...flow.options.modules,
-    ...flow.options._modules
-  ];
-  for (const m of modulesToInstall) {
-    if (Array.isArray(m))
-      await installModule(m[0], m[1]);
-    else
-      await installModule(m, {});
-  }
-  await flow.callHook("modules:done", { nuxt: flow });
-  await addModuleTranspiles();
-  await initNitro(flow);
-  await flow.callHook("ready", flow);
-}
-async function loadFlow(opts) {
-  const start1 = Date.now();
-  const options = await loadFlowConfig(opts);
-  logger.info(`Config loading in ${Date.now() - start1}ms`);
-  options.appDir = resolve(distDir, "app");
-  options.alias["#app"] = resolve(distDir, "app/index");
-  options._majorVersion = 3;
-  options._modules.push(pagesModule, metaModule, autoImportsModule, viteModule);
-  options.modulesDir.push(resolve(pkgDir, "node_modules"));
-  const flow = createFlow(options);
-  if (opts.ready !== false)
-    await flow.ready();
-  return flow;
-}
-function defineFlowConfig(config) {
-  return config;
-}
-
-const serverPluginTemplate = {
-  filename: "plugins/server.mjs",
-  getContents(ctx) {
-    const serverPlugins = ctx.app.plugins;
-    return [
-      templateUtils.importSources(serverPlugins.map((p) => p.src)),
-      `export default ${genArrayFromRaw([
-        ...serverPlugins.map((p) => templateUtils.importName(p.src))
-      ])}`
-    ].join("\n");
-  }
-};
-const pluginsDeclaration = {
-  filename: "types/plugins.d.ts",
-  getContents: (ctx) => {
-    const EXTENSION_RE = new RegExp(`(?<=\\w)(${ctx.nuxt.options.extensions.map((e) => escapeRE(e)).join("|")})$`, "g");
-    const tsImports = ctx.app.plugins.map((p) => (isAbsolute(p.src) ? relative(join(ctx.nuxt.options.buildDir, "types"), p.src) : p.src).replace(EXTENSION_RE, ""));
-    return `// Generated by Flow'
-import type { Plugin } from '#app'
-
-type Decorate<T extends Record<string, any>> = { [K in keyof T as K extends string ? \`$\${K}\` : never]: T[K] }
-
-type InjectionType<A extends Plugin> = A extends Plugin<infer T> ? Decorate<T> : unknown
-
-type FlowAppInjections = 
-  ${tsImports.map((p) => `InjectionType<typeof ${genDynamicImport(p, { wrapper: false })}.default>`).join(" &\n  ")}
-
-declare module '#app' {
-  interface FlowApp extends FlowAppInjections { }
-}
-// TODO: Insert extend types
-
-
-export { }
-`;
-  }
-};
-const adHocModules = ["auto-imports", "meta", "pages", "vite-client"];
-const schemaTemplate = {
-  filename: "types/schema.d.ts",
-  getContents: ({ nuxt }) => {
-    const moduleInfo = nuxt.options._installedModules.map((m) => ({
-      ...m.meta || {},
-      importName: m.entryPath || m.meta?.name
-    })).filter((m) => m.configKey && m.name && !adHocModules.includes(m.name));
-    return [
-      "import { FlowModule } from '@monkeyplus/flow-schema'",
-      "declare module '@monkeyplus/flow-schema' {",
-      "  interface FlowConfig {",
-      ...moduleInfo.filter(Boolean).map(
-        (meta) => `    [${genString(meta.configKey)}]?: typeof ${genDynamicImport(meta.importName, { wrapper: false })}.default extends FlowModule<infer O> ? Partial<O> : Record<string, any>`
-      ),
-      "  }",
-      generateTypes(
-        resolveSchema(Object.fromEntries(Object.entries(nuxt.options.runtimeConfig).filter(([key]) => key !== "public"))),
-        {
-          interfaceName: "RuntimeConfig",
-          addExport: false,
-          addDefaults: false,
-          allowExtraKeys: false,
-          indentation: 2
-        }
-      ),
-      generateTypes(
-        resolveSchema(nuxt.options.runtimeConfig.public),
-        {
-          interfaceName: "PublicRuntimeConfig",
-          addExport: false,
-          addDefaults: false,
-          allowExtraKeys: false,
-          indentation: 2
-        }
-      ),
-      "}"
-    ].join("\n");
-  }
-};
-const publicPathTemplate = {
-  filename: "paths.mjs",
-  getContents({ nuxt }) {
-    return [
-      "import { joinURL } from 'ufo'",
-      !nuxt.options.dev && "import { useRuntimeConfig } from '#internal/nitro'",
-      nuxt.options.dev ? `const appConfig = ${JSON.stringify(nuxt.options.app)}` : "const appConfig = useRuntimeConfig().app",
-      "export const baseURL = () => appConfig.baseURL",
-      "export const buildAssetsDir = () => appConfig.buildAssetsDir",
-      "export const buildAssetsURL = (...path) => joinURL(publicAssetsURL(), buildAssetsDir(), ...path)",
-      "export const publicAssetsURL = (...path) => {",
-      "  const publicBase = appConfig.cdnURL || appConfig.baseURL",
-      "  return path.length ? joinURL(publicBase, ...path) : publicBase",
-      "}"
-    ].filter(Boolean).join("\n");
-  }
-};
-
-const defaultTemplates = {
-  __proto__: null,
-  serverPluginTemplate: serverPluginTemplate,
-  pluginsDeclaration: pluginsDeclaration,
-  schemaTemplate: schemaTemplate,
-  publicPathTemplate: publicPathTemplate
-};
-
-function createApp(flow, options = {}) {
-  return defu(options, {
-    dir: flow.options.srcDir,
-    extensions: flow.options.extensions,
-    plugins: [],
-    templates: []
-  });
-}
-async function generateApp(flow, app) {
-  await resolveApp(flow, app);
-  app.templates = Object.values(defaultTemplates).concat(
-    flow.options.build.templates
-  );
-  await flow.callHook("app:templates", app);
-  app.templates = app.templates.map((tmpl) => normalizeTemplate(tmpl));
-  const templateContext = { utils: templateUtils, nuxt: flow, app };
-  await Promise.all(
-    app.templates.map(async (template) => {
-      const contents = await compileTemplate(template, templateContext);
-      const fullPath = template.dst || resolve(flow.options.buildDir, template.filename);
-      flow.vfs[fullPath] = contents;
-      const aliasPath = `#build/${template.filename.replace(/\.\w+$/, "")}`;
-      flow.vfs[aliasPath] = contents;
-      if (process.platform === "win32")
-        flow.vfs[fullPath.replace(/\//g, "\\")] = contents;
-      if (template.write) {
-        await promises.mkdir(dirname(fullPath), { recursive: true });
-        await promises.writeFile(fullPath, contents, "utf8");
-      }
-    })
-  );
-  await flow.callHook("app:templatesGenerated", app);
-}
-async function resolveApp(flow, app) {
-  app.plugins = [...flow.options.plugins.map(normalizePlugin)];
-  for (const config of flow.options._layers.map((layer) => layer.config)) {
-    app.plugins.push(
-      ...[
-        ...config.plugins || [],
-        ...await resolveFilesFlow(config.srcDir, [
-          "plugins/*.{ts,js,mjs,cjs,mts,cts}",
-          "plugins/*/index.*{ts,js,mjs,cjs,mts,cts}"
-        ])
-      ].map((plugin) => normalizePlugin(plugin))
-    );
-  }
-  app.plugins = uniqueBy(app.plugins, "src");
-  await flow.callHook("app:resolve", app);
-}
-function uniqueBy(arr, key) {
-  const res = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const item of arr) {
-    if (seen.has(item[key]))
-      continue;
-    seen.add(item[key]);
-    res.push(item);
-  }
-  return res;
-}
-
-const PREFIX = "virtual:nuxt:";
-function virtual(vfs) {
-  const extensions = ["", ".ts", ".vue", ".mjs", ".cjs", ".js", ".json"];
-  const resolveWithExt = (id) => {
-    for (const ext of extensions) {
-      const rId = id + ext;
-      if (rId in vfs)
-        return rId;
-    }
-    return null;
-  };
-  return {
-    name: "virtual",
-    resolveId(id, importer) {
-      if (process.platform === "win32" && isAbsolute(id)) {
-        id = resolve(id);
-      }
-      const resolvedId = resolveWithExt(id);
-      if (resolvedId)
-        return PREFIX + resolvedId;
-      if (importer && !isAbsolute(id)) {
-        const importerNoPrefix = importer.startsWith(PREFIX) ? importer.slice(PREFIX.length) : importer;
-        const importedDir = dirname(importerNoPrefix);
-        const resolved = resolveWithExt(join(importedDir, id));
-        if (resolved)
-          return PREFIX + resolved;
-      }
-      return null;
-    },
-    load(id) {
-      if (!id.startsWith(PREFIX))
-        return null;
-      const idNoPrefix = id.slice(PREFIX.length);
-      if (idNoPrefix in vfs) {
-        return {
-          code: vfs[idNoPrefix],
-          map: null
-        };
-      }
-    }
-  };
-}
-
-async function warmupViteServer(server, entries) {
-  const warmedUrls = /* @__PURE__ */ new Set();
-  const warmup = async (url) => {
-    if (warmedUrls.has(url))
-      return;
-    warmedUrls.add(url);
-    try {
-      await server.transformRequest(url);
-    } catch (e) {
-      logger.debug("Warmup for %s failed with: %s", url, e);
-    }
-    const mod = await server.moduleGraph.getModuleByUrl(url);
-    const deps = Array.from(mod?.importedModules || []);
-    await Promise.all(deps.map((m) => warmup(m.url.replace("/@id/__x00__", "\0"))));
-  };
-  await Promise.all(entries.map((entry) => warmup(entry)));
-}
-
-const wpfs = {
-  ...fse,
-  join
-};
-
-function cacheDirPlugin(rootDir, name) {
-  const optimizeCacheDir = resolve(rootDir, "node_modules/.cache/vite", name);
-  return {
-    name: "flow:cache-dir",
-    configResolved(resolvedConfig) {
-      resolvedConfig.optimizeCacheDir = optimizeCacheDir;
-    }
-  };
-}
-
-async function buildServer(ctx) {
-  const serverConfig = vite.mergeConfig(ctx.config, {
-    base: ctx.nuxt.options.dev ? joinURL(ctx.nuxt.options.app.baseURL.replace(/^\.\//, "/") || "/", ctx.nuxt.options.app.buildAssetsDir) : void 0,
-    define: {
-      "process.server": true,
-      "process.client": false,
-      "typeof window": '"undefined"',
-      "typeof document": '"undefined"',
-      "typeof navigator": '"undefined"',
-      "typeof location": '"undefined"',
-      "typeof XMLHttpRequest": '"undefined"'
-    },
-    resolve: {
-      alias: {
-        "#build/plugins": resolve(ctx.nuxt.options.buildDir, "plugins/server")
-      }
-    },
-    ssr: {
-      external: ["#internal/nitro", "#internal/nitro/utils"],
-      noExternal: [
-        ...ctx.nuxt.options.build.transpile,
-        /\/esm\/.*\.js$/,
-        /\.(es|esm|esm-browser|esm-bundler).js$/,
-        "/__vue-jsx",
-        "#app",
-        /(nuxt|nuxt3)\/(dist|src|app)/,
-        /flow\/(dist|src|app)/,
-        /flow\/modules\/(content|icons|images|netlify|netlify-cms|seo|sitemap|vue)/,
-        /@monkeyplus\/flow\/(dist|src|app)/,
-        /@nuxt\/nitro\/(dist|src)/
-      ]
-    },
-    build: {
-      outDir: resolve(ctx.nuxt.options.buildDir, "dist/server"),
-      ssr: true,
-      rollupOptions: {
-        external: ["#internal/nitro"],
-        output: {
-          entryFileNames: "server.mjs",
-          preferConst: true,
-          inlineDynamicImports: !ctx.nuxt.options.experimental.viteServerDynamicImports,
-          format: "module"
-        },
-        onwarn(warning, rollupWarn) {
-          if (!["UNUSED_EXTERNAL_IMPORT"].includes(warning.code))
-            rollupWarn(warning);
-        }
-      }
-    },
-    server: {
-      preTransformRequests: false,
-      hmr: false
-    },
-    plugins: [
-      cacheDirPlugin(ctx.nuxt.options.rootDir, "server")
-    ]
-  });
-  if (ctx.nuxt.options.typescript.typeCheck === true || ctx.nuxt.options.typescript.typeCheck === "build" && !ctx.nuxt.options.dev) {
-    const checker = await import('vite-plugin-checker').then((r) => r.default);
-    serverConfig.plugins.push(checker({
-      vueTsc: {
-        tsconfigPath: await resolveTSConfig(ctx.nuxt.options.rootDir)
-      }
-    }));
-  }
-  await ctx.nuxt.callHook("vite:extendConfig", serverConfig, { isClient: false, isServer: true });
-  const onBuild = () => ctx.nuxt.callHook("build:resources", wpfs);
-  if (!ctx.nuxt.options.dev) {
-    const start = Date.now();
-    logger.info("Building server...");
-    await vite.build(serverConfig);
-    await onBuild();
-    logger.success(`Server built in ${Date.now() - start}ms`);
-    return;
-  }
-  const viteServer = await vite.createServer(serverConfig);
-  ctx.ssrServer = viteServer;
-  await ctx.nuxt.callHook("vite:serverCreated", viteServer, { isClient: false, isServer: true });
-  ctx.nuxt.hook("close", () => viteServer.close());
-  await viteServer.pluginContainer.buildStart({});
-  if (ctx.nuxt.options.experimental.viteNode) {
-    logger.info("Vite server using experimental `vite-node`...");
-    await import('./vite-node.mjs').then((r) => r.initViteNodeServer(ctx));
-  } else {
-    await import('./dev-bundler.mjs').then((r) => r.initViteDevBundler(ctx, onBuild));
-  }
-}
-
-async function bundle$1(nuxt) {
-  const entry = resolve(nuxt.options.appDir, nuxt.options.experimental.asyncEntry ? "entry.async" : "entry");
-  const ctx = {
-    nuxt,
-    entry,
-    config: vite.mergeConfig(
-      {
-        configFile: false,
-        resolve: {
-          alias: {
-            ...nuxt.options.alias,
-            "#app": nuxt.options.appDir,
-            "#build/plugins": "",
-            "#build": nuxt.options.buildDir,
-            "web-streams-polyfill/ponyfill/es2018": "unenv/runtime/mock/empty",
-            "abort-controller": "unenv/runtime/mock/empty"
-          }
-        },
-        optimizeDeps: {
-          entries: [entry],
-          include: []
-        },
-        build: {
-          rollupOptions: {
-            output: { sanitizeFileName: sanitizeFilePath },
-            input: resolve(nuxt.options.appDir, "entry")
-          },
-          watch: {
-            exclude: nuxt.options.ignore
-          }
-        },
-        plugins: [
-          replace({
-            ...Object.fromEntries([";", "(", "{", "}", " ", "	", "\n"].map((d) => [`${d}global.`, `${d}globalThis.`])),
-            preventAssignment: true
-          }),
-          virtual(nuxt.vfs)
-        ],
-        vue: {
-          reactivityTransform: nuxt.options.experimental.reactivityTransform
-        },
-        server: {
-          watch: { ignored: isIgnoredFlow },
-          fs: {
-            allow: [
-              nuxt.options.appDir
-            ]
-          },
-          hmr: false
-        }
-      },
-      nuxt.options.vite
-    )
-  };
-  if (!nuxt.options.dev) {
-    ctx.config.server.watch = void 0;
-    ctx.config.build.watch = void 0;
-  }
-  await nuxt.callHook("vite:extend", ctx);
-  nuxt.hook("vite:serverCreated", (server, env) => {
-    ctx.nuxt.hook("app:templatesGenerated", () => {
-      for (const [id, mod] of server.moduleGraph.idToModuleMap) {
-        if (id.includes("pages."))
-          server.moduleGraph.invalidateModule(mod);
-        if (id.startsWith("\virtual:"))
-          server.moduleGraph.invalidateModule(mod);
-      }
-    });
-    const start = Date.now();
-    warmupViteServer(server, [join("/@fs/", ctx.entry)]).then(() => logger.info(`Vite ${env.isClient ? "client" : "server"} warmed up in ${Date.now() - start}ms`)).catch(logger.error);
-  });
-  await buildServer(ctx);
-}
-
-async function build(flow) {
-  const app = createApp(flow);
-  const generateApp$1 = debounce(() => generateApp(flow, app), void 0, { leading: true });
-  await generateApp$1();
-  if (flow.options.dev) {
-    watch(flow);
-    flow.hook("builder:watch", async (event, path) => {
-      if (event !== "change" && /app|error|plugins/i.test(path))
-        await generateApp$1();
-    });
-    flow.hook("builder:generateApp", generateApp$1);
-  }
-  await flow.callHook("build:before", { flow }, flow.options.build);
-  if (!flow.options._prepare) {
-    await bundle(flow);
-    await flow.callHook("build:done", { flow });
-  }
-  if (!flow.options.dev)
-    await flow.callHook("close", flow);
-}
-function watch(flow) {
-  const watcher = chokidar.watch(flow.options.srcDir, {
-    ...flow.options.watchers.chokidar,
-    cwd: flow.options.srcDir,
-    ignoreInitial: true,
-    ignored: [
-      isIgnoredFlow,
-      ".flow",
-      "node_modules"
-    ]
-  });
-  watcher.on("all", (event, path) => flow.callHook("builder:watch", event, normalize(path)));
-  flow.hook("close", () => watcher.close());
-  return watcher;
-}
-async function bundle(nuxt) {
-  try {
-    return bundle$1(nuxt);
-  } catch (error) {
-    await nuxt.callHook("build:error", error);
-    throw error;
-  }
-}
-
-export { defineFlowConfig as a, build as b, createFlow as c, distDir as d, loadFlow as l };