@monkeyplus/flow 5.0.0-rc.105 → 5.0.0-rc.107

package/dist/index.mjs

@@ -1,26 +1,1106 @@
-export { b as build, c as createFlow, a as defineFlowConfig, l as loadFlow } from './chunks/index.mjs';
-import 'hookable';
-import 'pathe';
-import '@monkeyplus/flow-kit';
-import 'url';
-import 'unimport';
-import 'node:url';
-import 'unplugin';
-import 'ufo';
-import 'fs';
-import 'escape-string-regexp';
-import 'scule';
-import 'knitwork';
-import 'node:fs';
-import 'nitropack';
-import 'fs-extra';
-import 'defu';
-import 'h3';
-import 'node:module';
-import 'chokidar';
-import 'perfect-debounce';
-import 'untyped';
-import 'vite';
-import '@rollup/plugin-replace';
-import 'mlly';
-import 'pkg-types';
+import { createHooks } from 'hookable';
+import { dirname, resolve, normalize, join, isAbsolute, relative, extname } from 'pathe';
+import { defineFlowModule, addPlugin, defineNuxtModule, logger, addTemplate, addPluginTemplate, addVitePlugin, addWebpackPlugin, updateTemplates, useNuxt, resolveAlias, resolveFilesFlow, nuxtCtx, installModule, loadFlowConfig, normalizeTemplate, compileTemplate, normalizePlugin, findPath, templateUtils, isIgnoredFlow } from '@monkeyplus/flow-kit';
+import escapeRE from 'escape-string-regexp';
+import { fileURLToPath } from 'url';
+import { defineUnimportPreset, createUnimport, toImports, scanDirExports } from 'unimport';
+import defu from 'defu';
+import { pathToFileURL } from 'node:url';
+import { createUnplugin } from 'unplugin';
+import { parseURL, parseQuery, joinURL } from 'ufo';
+import fs from 'fs';
+import { camelCase, pascalCase } from 'scule';
+import { genImport, genDynamicImport, genSafeVariableName, genArrayFromRaw, genString } from 'knitwork';
+import { existsSync, promises } from 'node:fs';
+import { createNitro, scanHandlers, writeTypes, build as build$1, prepare, copyPublicAssets, prerender, createDevServer } from 'nitropack';
+import { dynamicEventHandler } from 'h3';
+import { createRequire } from 'node:module';
+import chokidar from 'chokidar';
+import { debounce } from 'perfect-debounce';
+import { generateTypes, resolveSchema } from 'untyped';
+import { hash } from 'ohash';
+import { resolvePath, sanitizeFilePath } from 'mlly';
+import * as vite from 'vite';
+import replace from '@rollup/plugin-replace';
+import { resolveTSConfig } from 'pkg-types';
+import fse from 'fs-extra';
+
+const version = "5.0.0-rc.107";
+
+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: "nuxt:imports-transform",
+    enforce: "post",
+    transformInclude(id) {
+      const { pathname, search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+      const query = parseQuery(search);
+      if (options.transform?.include?.some((pattern) => id.match(pattern)))
+        return true;
+      if (options.transform?.exclude?.some((pattern) => id.match(pattern)))
+        return false;
+      if (id.endsWith(".vue") || "macro" in query || "vue" in query && (query.type === "template" || query.type === "script" || "setup" in query))
+        return true;
+      if (pathname.match(/\.((c|m)?j|t)sx?$/g))
+        return true;
+    },
+    async transform(code, id) {
+      id = normalize(id);
+      const isNodeModule = id.match(/[\\/]node_modules[\\/]/) && !options.transform?.include?.some((pattern) => id.match(pattern));
+      if (isNodeModule && !code.match(/(['"])#imports\1/))
+        return;
+      const { s } = await ctx.injectImports(code, id, { autoImport: options.autoImport && !isNodeModule });
+      if (s.hasChanged()) {
+        return {
+          code: s.toString(),
+          map: sourcemap ? s.generateMap({ source: id, includeContent: true }) : void 0
+        };
+      }
+    }
+  };
+});
+
+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 importsModule = defineNuxtModule({
+  meta: {
+    name: "imports",
+    configKey: "imports"
+  },
+  defaults: {
+    autoImport: true,
+    presets: defaultPresets,
+    global: false,
+    imports: [],
+    dirs: [],
+    transform: {
+      include: [],
+      exclude: void 0
+    }
+  },
+  async setup(options, nuxt) {
+    if (nuxt.options.autoImports) {
+      logger.warn("`autoImports` config is deprecated, use `imports` instead.");
+      options = defu(nuxt.options.autoImports, options);
+    }
+    await nuxt.callHook("imports:sources", options.presets);
+    options.presets?.forEach((_i) => {
+      const i = _i;
+      if (typeof i !== "string" && i.names && !i.imports) {
+        i.imports = i.names;
+        logger.warn("imports: presets.names is deprecated, use presets.imports instead");
+      }
+    });
+    const ctx = createUnimport({
+      presets: options.presets,
+      imports: options.imports,
+      virtualImports: ["#imports"],
+      addons: {
+        vueTemplate: options.autoImport
+      }
+    });
+    let composablesDirs = [];
+    for (const layer of nuxt.options._layers) {
+      composablesDirs.push(resolve(layer.config.srcDir, "composables"));
+      for (const dir of layer.config.imports?.dirs ?? []) {
+        if (!dir)
+          continue;
+        composablesDirs.push(resolve(layer.config.srcDir, dir));
+      }
+    }
+    await nuxt.callHook("imports:dirs", composablesDirs);
+    composablesDirs = composablesDirs.map((dir) => normalize(dir));
+    addTemplate({
+      filename: "imports.mjs",
+      getContents: async () => `${await ctx.toExports()}
+if (process.dev) { console.warn("[nuxt] \`#imports\` should be transformed with real imports. There seems to be something wrong with the imports plugin.") }`
+    });
+    nuxt.options.alias["#imports"] = join(nuxt.options.buildDir, "imports");
+    if (nuxt.options.dev && options.global) {
+      addPluginTemplate({
+        filename: "imports.mjs",
+        getContents: async () => {
+          const imports = await 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: nuxt.options.sourcemap.server || nuxt.options.sourcemap.client }));
+      addWebpackPlugin(TransformPlugin.webpack({ ctx, options, sourcemap: nuxt.options.sourcemap.server || nuxt.options.sourcemap.client }));
+    }
+    const regenerateImports = async () => {
+      ctx.clearDynamicImports();
+      await ctx.modifyDynamicImports(async (imports) => {
+        imports.push(...await scanDirExports(composablesDirs));
+        await nuxt.callHook("imports:extend", imports);
+      });
+    };
+    await regenerateImports();
+    addDeclarationTemplates(ctx, options);
+    nuxt.hook("prepare:types", ({ references }) => {
+      references.push({ path: resolve(nuxt.options.buildDir, "types/imports.d.ts") });
+      references.push({ path: resolve(nuxt.options.buildDir, "imports.d.ts") });
+    });
+    const templates = [
+      "types/imports.d.ts",
+      "imports.d.ts",
+      "imports.mjs"
+    ];
+    nuxt.hook("builder:watch", async (_, path) => {
+      const _resolved = resolve(nuxt.options.srcDir, path);
+      if (composablesDirs.find((dir) => _resolved.startsWith(dir))) {
+        await updateTemplates({
+          filter: (template) => templates.includes(template.filename)
+        });
+      }
+    });
+    nuxt.hook("builder:generateApp", async () => {
+      await regenerateImports();
+    });
+  }
+});
+function addDeclarationTemplates(ctx, options) {
+  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(nuxt.options.buildDir)
+  });
+  addTemplate({
+    filename: "types/imports.d.ts",
+    getContents: async () => `// Generated by auto imports
+${options.autoImport ? await ctx.generateTypeDeclarations({ resolvePath: r }) : "// Implicit auto importing is disabled, you can use explicitly import from `#imports` instead."}`
+  });
+}
+
+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 _require = createRequire(import.meta.url);
+const ImportProtectionPlugin = createUnplugin((options) => {
+  const cache = {};
+  const importersToExclude = options?.exclude || [];
+  return {
+    name: "nuxt:import-protection",
+    enforce: "pre",
+    resolveId(id, importer) {
+      if (!importer)
+        return;
+      if (id.startsWith("."))
+        id = join(importer, "..", id);
+      if (isAbsolute(id))
+        id = relative(options.rootDir, id);
+      if (importersToExclude.some((p) => typeof p === "string" ? importer === p : p.test(importer)))
+        return;
+      const invalidImports = options.patterns.filter(([pattern]) => pattern instanceof RegExp ? pattern.test(id) : pattern === id);
+      let matched = false;
+      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 _nitroConfig = flow.options.nitro || {};
+  globalThis.generate = {};
+  const nitroConfig = defu(_nitroConfig, {
+    rootDir: flow.options.rootDir,
+    workspaceDir: flow.options.workspaceDir,
+    srcDir: flow.options.serverDir,
+    dev: flow.options.dev,
+    buildDir: flow.options.buildDir,
+    scanDirs: flow.options._layers.map((layer) => (layer.config.serverDir || layer.config.srcDir) && resolve(layer.cwd, layer.config.serverDir || resolve(layer.config.srcDir, "server"))).filter(Boolean),
+    renderer: resolve(distDir, "core/runtime/nitro/renderer"),
+    nodeModulesDirs: flow.options.modulesDir,
+    handlers: [
+      {
+        middleware: true,
+        handler: resolve(distDir, "core/runtime/nitro/flow")
+      },
+      ...flow.options.serverHandlers
+    ],
+    output: {
+      dir: resolve(flow.options.buildDir, "output")
+    },
+    devHandlers: [],
+    baseURL: flow.options.app.baseURL,
+    virtual: {},
+    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: [
+      {
+        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 ?? void 0,
+      routes: [].concat(flow.options.generate.routes).concat(flow.options._generate ? ["/_urls", ...flow.options.generate.routes] : [])
+    },
+    sourceMap: flow.options.sourcemap.server,
+    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: [""]
+    }
+  });
+  nitroConfig.rollupConfig.plugins.push(
+    ImportProtectionPlugin.rollup({
+      rootDir: flow.options.rootDir,
+      patterns: [
+        ...["#app", /^#build(\/|$)/].map((p) => [p, "Vue app aliases are not allowed in server routes."])
+      ],
+      exclude: [/core[\\/]runtime[\\/]nitro[\\/]renderer/]
+    })
+  );
+  await flow.callHook("nitro:config", nitroConfig);
+  const nitro = await createNitro(nitroConfig);
+  flow._nitro = nitro;
+  flow.nitro = nitro;
+  await flow.callHook("nitro:init", nitro);
+  nitro.vfs = flow.vfs = nitro.vfs || flow.vfs || {};
+  flow.hook("close", () => nitro.hooks.callHook("close"));
+  nitro.hooks.hook("prerender:routes", (routes) => {
+    flow.callHook("prerender:routes", { routes });
+  });
+  const devMiddlewareHandler = dynamicEventHandler();
+  nitro.options.devHandlers.unshift({ handler: devMiddlewareHandler });
+  nitro.options.devHandlers.push(...flow.options.devServerHandlers);
+  nitro.options.handlers.unshift({
+    route: "/__nuxt_error",
+    lazy: true,
+    handler: resolve(distDir, "core/runtime/nitro/renderer")
+  });
+  flow.hook("prepare:types", async (opts) => {
+    if (!flow.options.dev) {
+      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$1(nitro);
+    } else {
+      await prepare(nitro);
+      await copyPublicAssets(nitro);
+      await prerender(nitro);
+      if (!flow.options._generate) {
+        await build$1(nitro);
+      } else {
+        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("vite:compiled", () => {
+      flow.server.reload();
+    });
+    flow.hook("server:devHandler", (h) => {
+      devMiddlewareHandler.set(h);
+    });
+    flow.server = createDevServer(nitro);
+    const waitUntilCompile = new Promise((resolve2) => nitro.hooks.hook("compiled", () => resolve2()));
+    flow.hook("build:done", () => waitUntilCompile);
+  }
+}
+
+const addModuleTranspiles = (opts = {}) => {
+  const flow = useNuxt();
+  const modules = [
+    ...opts.additionalModules || [],
+    ...flow.options.buildModules,
+    ...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).filter((x) => !!x);
+  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.106",
+    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) {
+  flow.hooks.addHooks(flow.options.hooks);
+  nuxtCtx.set(flow);
+  flow.hook("close", () => nuxtCtx.unset());
+  await flow.callHook("modules:before");
+  const modulesToInstall = [
+    ...flow.options.buildModules,
+    ...flow.options.modules,
+    ...flow.options._modules
+  ];
+  flow.hooks.deprecateHooks({
+    "autoImports:sources": {
+      to: "imports:sources",
+      message: "`autoImports:sources` hook is deprecated. Use `addImportsSources()` from `@nuxt/kit` or `imports:dirs` with `nuxt>=3.0.0-rc.10`."
+    },
+    "autoImports:dirs": {
+      to: "imports:dirs",
+      message: "`autoImports:dirs` hook is deprecated. Use `addImportsDir()` from `@nuxt/kit` or `imports:dirs` with `nuxt>=3.0.0-rc.9`."
+    },
+    "autoImports:extend": {
+      to: "imports:extend",
+      message: "`autoImports:extend` hook is deprecated. Use `addImports()` from `@nuxt/kit` or `imports:extend` with `nuxt>=3.0.0-rc.9`."
+    }
+  });
+  for (const m of modulesToInstall) {
+    if (Array.isArray(m))
+      await installModule(m[0], m[1]);
+    else
+      await installModule(m, {});
+  }
+  await flow.callHook("modules:done");
+  flow.options.build.transpile = flow.options.build.transpile.map((t) => typeof t === "string" ? normalize(t) : t);
+  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);
+  options._modules.push([importsModule, {
+    transform: {
+      include: options._layers.filter((i) => i.cwd && i.cwd.includes("node_modules")).map((i) => new RegExp(`(^|\\/)${escapeRE(i.cwd.split("node_modules/").pop())}(\\/|$)(?!node_modules\\/)`))
+    }
+  }]);
+  options.modulesDir.push(resolve(options.workspaceDir, "node_modules"));
+  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;
+    const exports = [];
+    const imports = [];
+    for (const plugin of serverPlugins) {
+      const path = relative(ctx.nuxt.options.rootDir, plugin.src);
+      const variable = `${genSafeVariableName(path).replace(/_(45|46|47)/g, "_")}_${hash(path)}`;
+      exports.push(variable);
+      imports.push(genImport(plugin.src, variable));
+    }
+    return [
+      ...imports,
+      `export default ${genArrayFromRaw(exports)}`
+    ].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 = ["imports", "meta", "pages"];
+const schemaTemplate = {
+  filename: "types/schema.d.ts",
+  getContents: async ({ 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));
+    const relativeRoot = relative(resolve(nuxt.options.buildDir, "types"), nuxt.options.rootDir);
+    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.startsWith(".") ? `./${join(relativeRoot, meta.importName)}` : meta.importName, { wrapper: false })}.default extends FlowModule<infer O> ? Partial<O> : Record<string, any>`
+      ),
+      "  }",
+      generateTypes(
+        await resolveSchema(Object.fromEntries(Object.entries(nuxt.options.runtimeConfig).filter(([key]) => key !== "public"))),
+        {
+          interfaceName: "RuntimeConfig",
+          addExport: false,
+          addDefaults: false,
+          allowExtraKeys: false,
+          indentation: 2
+        }
+      ),
+      generateTypes(
+        await resolveSchema(nuxt.options.runtimeConfig.public),
+        {
+          interfaceName: "PublicRuntimeConfig",
+          addExport: false,
+          addDefaults: false,
+          allowExtraKeys: false,
+          indentation: 2
+        }
+      ),
+      "}"
+    ].join("\n");
+  }
+};
+const publicPathTemplate = {
+  filename: "paths.mjs",
+  async getContents({ nuxt }) {
+    return [
+      `import { joinURL } from '${await _resolveId("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");
+  }
+};
+function _resolveId(id) {
+  return resolvePath(id, {
+    url: [
+      global.__NUXT_PREPATHS__,
+      import.meta.url,
+      process.cwd(),
+      global.__NUXT_PATHS__
+    ]
+  });
+}
+
+const defaultTemplates = {
+  __proto__: null,
+  serverPluginTemplate: serverPluginTemplate,
+  pluginsDeclaration: pluginsDeclaration,
+  schemaTemplate: schemaTemplate,
+  publicPathTemplate: publicPathTemplate
+};
+
+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;
+}
+
+function createApp(flow, options = {}) {
+  return defu(options, {
+    dir: flow.options.srcDir,
+    extensions: flow.options.extensions,
+    plugins: [],
+    templates: []
+  });
+}
+async function generateApp(flow, app, options) {
+  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 || [],
+      ...config.srcDir ? await resolveFilesFlow(config.srcDir, [
+        `${config.dir?.plugins || "plugins"}/*.{ts,js,mjs,cjs,mts,cts}`,
+        `${config.dir?.plugins || "plugins"}/*/index.*{ts,js,mjs,cjs,mts,cts}`
+      ]) : []
+    ].map((plugin) => normalizePlugin(plugin)));
+  }
+  app.configs = [];
+  for (const config of flow.options._layers.map((layer) => layer.config)) {
+    const appConfigPath = await findPath(resolve(config.srcDir, "app.config"));
+    if (appConfigPath)
+      app.configs.push(appConfigPath);
+  }
+  await flow.callHook("app:resolve", app);
+  app.plugins = uniqueBy(app.plugins, "src");
+}
+
+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"),
+      replace({
+        ...Object.fromEntries([";", "(", "{", "}", " ", "	", "\n"].map((d) => [`${d}global.`, `${d}globalThis.`])),
+        preventAssignment: true
+      })
+    ]
+  });
+  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({});
+  await import('./chunks/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", (options) => {
+      if (options)
+        return generateApp(flow, app);
+      return generateApp$1();
+    });
+  }
+  await flow.callHook("build:before");
+  if (!flow.options._prepare) {
+    await bundle(flow);
+    await flow.callHook("build:done");
+  }
+  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 { build, createFlow, defineFlowConfig, loadFlow };