@monkeyplus/flow 5.0.0-rc.99 → 6.0.1

package/src/runtime/virtual.d.ts

@@ -0,0 +1,103 @@
+declare module 'virtual:flow/pages' {
+  const pages: import('./pages').PageDefinition[];
+
+  export default pages;
+}
+
+declare module 'virtual:flow/client-pages' {
+  export interface FlowClientBundleModule {
+    default?: (payload: import('./boot').FlowBootPayload) => void | Promise<void>;
+  }
+
+  const bundles: Record<string, () => Promise<FlowClientBundleModule>>;
+
+  export default bundles;
+}
+
+declare module 'virtual:flow/client-page-assets' {
+  export interface FlowClientBundleAssets {
+    entry?: string;
+    css?: Array<Record<string, string>>;
+    js?: Array<Record<string, string>>;
+  }
+
+  const bundles: Record<string, FlowClientBundleAssets>;
+
+  export default bundles;
+}
+
+declare module 'virtual:flow/strapi-config' {
+  const config: {
+    apiBase: string;
+    url: string;
+    prefix: string;
+    admin: string;
+    version: 'v5' | 'v4' | 'v3';
+  };
+
+  export default config;
+}
+
+declare module '#strapi' {
+  export interface StrapiFetchOptions extends RequestInit {
+    params?: Record<string, unknown>;
+  }
+
+  export interface StrapiPublicConfig {
+    apiBase: string;
+    url: string;
+    prefix: string;
+    admin: string;
+    version: 'v5' | 'v4' | 'v3';
+  }
+
+  export function useStrapiVersion(): StrapiPublicConfig['version'];
+  export function useStrapiUrl(path?: string): string;
+  export function useStrapiAdminUrl(path?: string): string;
+  export function useStrapiMedia(url?: string | null): string | null | undefined;
+  export function useStrapiClient(): <T>(url: string, options?: StrapiFetchOptions) => Promise<T>;
+  export function useStrapi<T = unknown>(): {
+    find<TResult = T>(contentType: string, params?: Record<string, unknown>, options?: StrapiFetchOptions): Promise<TResult>;
+    findOne<TResult = T>(contentType: string, documentId: string, params?: Record<string, unknown>, options?: StrapiFetchOptions): Promise<TResult>;
+    create<TResult = T>(contentType: string, data: Partial<TResult>, params?: Record<string, unknown>, options?: StrapiFetchOptions): Promise<TResult>;
+    update<TResult = T>(contentType: string, documentId: string, data?: Partial<TResult>, params?: Record<string, unknown>, options?: StrapiFetchOptions): Promise<TResult>;
+    delete(contentType: string, documentId?: string, params?: Record<string, unknown>, options?: StrapiFetchOptions): Promise<void>;
+  };
+  export function useStrapiGraphQL(): <T>(query: string | { loc?: { source?: { body?: string } } }, variables?: Record<string, unknown>, options?: StrapiFetchOptions) => Promise<T>;
+  export const strapiConfig: StrapiPublicConfig;
+}
+
+declare module 'virtual:flow/islands' {
+  export interface FlowIslandHydrateContext {
+    element: HTMLElement;
+    props: Record<string, unknown>;
+    boot?: import('./boot').FlowBootPayload;
+  }
+
+  export interface FlowIslandModule {
+    default?: import('vue').Component;
+    hydrate?: (ctx: FlowIslandHydrateContext) => void | Promise<void>;
+  }
+
+  const islands: Record<string, () => Promise<FlowIslandModule>>;
+
+  export default islands;
+}
+
+declare module 'virtual:flow/templates' {
+  const templates: Record<string, import('vue').Component>;
+
+  export default templates;
+}
+
+declare module 'virtual:flow/layouts' {
+  const layouts: Record<string, import('vue').Component>;
+
+  export default layouts;
+}
+
+declare module 'virtual:flow/bases' {
+  const bases: Record<string, string>;
+
+  export default bases;
+}

package/src/runtime/vite-assets.d.ts

@@ -0,0 +1,9 @@
+declare module '*?assets=client' {
+  const assets: {
+    entry: string;
+    css?: Array<Record<string, string>>;
+    js?: Array<Record<string, string>>;
+  };
+
+  export default assets;
+}

package/src/runtime/vue.d.ts

@@ -0,0 +1,6 @@
+import type { App } from 'vue';
+interface DefaultPlugins {
+    ui: boolean;
+}
+export declare function installFlowVuePlugins(app: App, {}?: DefaultPlugins): App<any>;
+export {};

package/src/runtime/vue.mjs

@@ -0,0 +1,6 @@
+import ui from "@nuxt/ui/vue-plugin";
+export function installFlowVuePlugins(app, {} = { ui: true }) {
+  if (ui)
+    app.use(ui);
+  return app;
+}

package/src/styles.css

@@ -0,0 +1 @@
+@import "tailwindcss";@import "@nuxt/ui";

package/app.d.ts

@@ -1 +0,0 @@
-export * from './dist/app';

package/bin/flow.mjs

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import '@monkeyplus/flow-cli/cli';

package/dist/app/composables/index.d.ts

@@ -1,5 +0,0 @@
-import type { RouteLocationNormalizedLoaded } from 'vue-router';
-export declare function useCookie(name: string, _opts?: any): {};
-export declare function refreshNuxtData(keys?: string | string[]): Promise<void>;
-export declare function useAsyncData(key: string, handlers: () => Promise<any>): Promise<any>;
-export declare function useRoute(): RouteLocationNormalizedLoaded;

package/dist/app/composables/index.mjs

@@ -1,12 +0,0 @@
-export function useCookie(name, _opts) {
-  return {};
-}
-export function refreshNuxtData(keys) {
-  return Promise.resolve();
-}
-export function useAsyncData(key, handlers) {
-  return handlers();
-}
-export function useRoute() {
-  return {};
-}

package/dist/app/entry.async.d.ts

@@ -1,3 +0,0 @@
-import type { RuntimeConfig } from '@monkeyplus/flow-schema';
-declare const _default: (ctx?: RuntimeConfig) => Promise<any>;
-export default _default;

package/dist/app/entry.async.mjs

@@ -1 +0,0 @@
-export default (ctx) => import("#app/entry").then((m) => m.default(ctx));

package/dist/app/entry.d.ts

@@ -1,3 +0,0 @@
-import type { RuntimeConfig } from '@monkeyplus/flow-schema';
-declare const _default: (runtimeConfig: RuntimeConfig) => Promise<import("./flow").FlowApp>;
-export default _default;

package/dist/app/entry.mjs

@@ -1,23 +0,0 @@
-import { config, configure, render } from "eta";
-import { applyPlugins, createFlowApp } from "./flow.mjs";
-import plugins from "#build/plugins";
-export default async (runtimeConfig) => {
-  const flow = createFlowApp({ runtimeConfig });
-  try {
-    await applyPlugins(flow, plugins);
-    configure(flow.eta);
-    flow.render = (view, data) => {
-      const layout = "<%layout(`layouts/${it.view?.layout||'default'}`)%>";
-      const getTemplate = flow.engines[view.engine || flow.engine];
-      const base = `${layout}
-      ${getTemplate(view.template)}`;
-      return render(base, data || {}, {
-        ...config,
-        async: true
-      });
-    };
-  } catch (err) {
-    console.log(err);
-  }
-  return flow;
-};

package/dist/app/flow.d.ts

@@ -1,80 +0,0 @@
-import type { RadixRouter } from 'radix3';
-import type { Hookable } from 'hookable';
-import type { FlowAppUtils, FlowPage, RuntimeConfig } from '@monkeyplus/flow-schema';
-declare type HookResult = Promise<void> | void;
-export interface FlowAppHooks {
-    'flow:pages': (page: FlowPage[]) => HookResult;
-    'eta:plugin': (options: any) => HookResult;
-    'page:scripts': (scripts: {
-        head: string[];
-        bodyEnd: string[];
-        bodyStart: string[];
-    }) => HookResult;
-    'page:links': (links: string[]) => HookResult;
-    'page:context': (ctx: {
-        page: string;
-        localeCode: string;
-    }, utils: any, data: Record<string, any>) => HookResult;
-    'page:chunks': (bundle: string, scripts: {
-        head: string[];
-        body: string[];
-    }) => HookResult;
-    'page:generate': (generate: any) => HookResult;
-}
-export interface FlowApp {
-    router: {
-        byUrl: RadixRouter<FlowPage['context']>;
-        byName: RadixRouter<FlowPage['context']>;
-    };
-    hooks: Hookable<FlowAppHooks>;
-    hook: FlowApp['hooks']['hook'];
-    callHook: FlowApp['hooks']['callHook'];
-    eta: any;
-    app: {
-        utils: FlowAppUtils;
-        plugins: Record<string, any>;
-        globals: Record<string, any>;
-    };
-    engine: string;
-    site: {
-        origin: string;
-    };
-    engines: Record<string, (template: string) => string>;
-    generate: boolean;
-    render: (view: Record<string, string>, data: any) => Promise<string> | void | string;
-    provide: (name: string, value: any) => void;
-    setUtil: (name: string, value: any) => void;
-    [key: string]: any;
-}
-export declare const FlowPluginIndicator = "__flow_plugin";
-export declare const NuxtPluginIndicator = "__nuxt_plugin";
-export interface Plugin<Injections extends Record<string, any> = Record<string, any>> {
-    (flow: FlowApp): Promise<void> | Promise<{
-        provide?: Injections;
-    }> | void | {
-        provide?: Injections;
-    };
-    [FlowPluginIndicator]?: true;
-}
-interface OptionsApp {
-    runtimeConfig: RuntimeConfig;
-}
-export declare function createFlowApp({ runtimeConfig }: OptionsApp): FlowApp;
-export declare function defineFlowPlugin<T>(plugin: Plugin<T>): Plugin<T>;
-export declare function defineNuxtPlugin<T>(plugin: Plugin<T>): Plugin<T>;
-export declare function applyPlugin(flowApp: FlowApp, plugin: Plugin): Promise<void>;
-export declare function applyPlugins(flowApp: FlowApp, plugins: Plugin[]): Promise<void>;
-/**
- * Ensures that the setup function passed in has access to the Nuxt instance via `useNuxt`.
- *
- * @param flow A Flow instance
- * @param setup The function to call
- */
-export declare function callWithFlow<T extends (...args: any[]) => any>(flow: FlowApp, setup: T, args?: Parameters<T>): Promise<ReturnType<T>>;
-/**
- * Returns the current Nuxt instance.
- */
-export declare function useFlowApp(): FlowApp;
-export declare function useRuntimeConfig(): RuntimeConfig;
-export declare function resolveFiles(path: string, pattern: string | string[]): Promise<any[]>;
-export {};

package/dist/app/flow.mjs

@@ -1,88 +0,0 @@
-import { createRouter } from "radix3";
-import { createHooks } from "hookable";
-import { getContext } from "unctx";
-import { globby } from "globby";
-import { join, resolve } from "pathe";
-const flowAppCtx = getContext("flow-app");
-export const FlowPluginIndicator = "__flow_plugin";
-export const NuxtPluginIndicator = "__nuxt_plugin";
-export function createFlowApp({ runtimeConfig }) {
-  const viewsDir = join(runtimeConfig.app.rootDir, "views");
-  const flowApp = {
-    router: { byUrl: createRouter(), byName: createRouter() },
-    app: {
-      utils: {},
-      globals: {}
-    },
-    eta: {
-      views: viewsDir,
-      plugins: []
-    },
-    engine: "eta",
-    engines: {},
-    site: {
-      origin: `${process.env.URL || "http://localhost"}`
-    },
-    generate: runtimeConfig.generate
-  };
-  flowApp.engines.eta = (template) => {
-    return `<%~ await includeFile('templates/${template}',it) %>`;
-  };
-  flowApp.hooks = createHooks();
-  flowApp.hook = flowApp.hooks.hook;
-  flowApp.callHook = flowApp.hooks.callHook;
-  flowApp.provide = (name, value) => {
-    const $name = `$${name}`;
-    defineGetter(flowApp, $name, value);
-  };
-  flowApp.setUtil = (name, method) => {
-    flowApp.app.utils[name] = method;
-  };
-  flowApp.hook("eta:plugin", (_plugin) => {
-    flowApp.eta.plugins.push(_plugin);
-  });
-  flowApp.provide("config", runtimeConfig);
-  return flowApp;
-}
-export function defineFlowPlugin(plugin) {
-  plugin[FlowPluginIndicator] = true;
-  return plugin;
-}
-export function defineNuxtPlugin(plugin) {
-  plugin[NuxtPluginIndicator] = true;
-  return plugin;
-}
-export async function applyPlugin(flowApp, plugin) {
-  if (typeof plugin !== "function")
-    return;
-  const { provide } = await callWithFlow(flowApp, plugin, [flowApp]) || {};
-  if (provide && typeof provide === "object") {
-    for (const key in provide)
-      flowApp.provide(key, provide[key]);
-  }
-}
-export async function applyPlugins(flowApp, plugins) {
-  for (const plugin of plugins)
-    await applyPlugin(flowApp, plugin);
-}
-export function callWithFlow(flow, setup, args) {
-  const fn = () => args ? setup(...args) : setup();
-  flowAppCtx.set(flow);
-  return flowAppCtx.callAsync(flow, fn);
-}
-export function useFlowApp() {
-  const flowAppInstance = flowAppCtx.use();
-  if (!flowAppInstance)
-    throw new Error("flow instance unavailable");
-  return flowAppInstance;
-}
-export function useRuntimeConfig() {
-  return useFlowApp().$config;
-}
-function defineGetter(obj, key, val) {
-  Object.defineProperty(obj, key, { get: () => val });
-}
-export async function resolveFiles(path, pattern) {
-  const files = await globby(pattern, { cwd: path, followSymbolicLinks: true });
-  return files.filter((file) => !file.includes("copy.ts")).map((p) => resolve(path, p));
-}

package/dist/app/index.d.ts

@@ -1,3 +0,0 @@
-export * from './flow';
-export * from './composables';
-export { useHead } from '#head';

package/dist/app/index.mjs

@@ -1,3 +0,0 @@
-export * from "./flow.mjs";
-export * from "./composables/index.mjs";
-export { useHead } from "#head";

package/dist/chunks/dev-bundler.mjs

@@ -1,247 +0,0 @@
-import { pathToFileURL } from 'node:url';
-import { existsSync } from 'node:fs';
-import { builtinModules } from 'node:module';
-import { resolve, normalize, isAbsolute } from 'pathe';
-import { genObjectFromRawEntries, genDynamicImport } from 'knitwork';
-import fse from 'fs-extra';
-import { debounce } from 'perfect-debounce';
-import { isIgnoredFlow, logger } from '@monkeyplus/flow-kit';
-import { h as hashId, c as createIsExternal, u as uniq, i as isCSS } from './external.mjs';
-import { withTrailingSlash, withoutLeadingSlash } from 'ufo';
-import escapeRE from 'escape-string-regexp';
-import { normalizeViteManifest } from 'vue-bundle-renderer';
-import 'ohash';
-import 'externality';
-
-async function writeManifest(ctx, css = []) {
-  const clientDist = resolve(ctx.nuxt.options.buildDir, "dist/client");
-  const serverDist = resolve(ctx.nuxt.options.buildDir, "dist/server");
-  const devClientManifest = {
-    "@vite/client": {
-      isEntry: true,
-      file: "@vite/client",
-      css,
-      module: true,
-      resourceType: "script"
-    },
-    [ctx.entry]: {
-      isEntry: true,
-      file: ctx.entry,
-      module: true,
-      resourceType: "script"
-    }
-  };
-  const clientManifest = ctx.nuxt.options.dev ? devClientManifest : await fse.readJSON(resolve(clientDist, "manifest.json"));
-  const buildAssetsDir = withTrailingSlash(withoutLeadingSlash(ctx.nuxt.options.app.buildAssetsDir));
-  const BASE_RE = new RegExp(`^${escapeRE(buildAssetsDir)}`);
-  for (const key in clientManifest) {
-    if (clientManifest[key].file)
-      clientManifest[key].file = clientManifest[key].file.replace(BASE_RE, "");
-    for (const item of ["css", "assets"]) {
-      if (clientManifest[key][item])
-        clientManifest[key][item] = clientManifest[key][item].map((i) => i.replace(BASE_RE, ""));
-    }
-  }
-  await fse.mkdirp(serverDist);
-  const manifest = normalizeViteManifest(clientManifest);
-  await ctx.nuxt.callHook("build:manifest", manifest);
-  await fse.writeFile(resolve(serverDist, "client.manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
-  await fse.writeFile(resolve(serverDist, "client.manifest.mjs"), `export default ${JSON.stringify(manifest, null, 2)}`, "utf8");
-}
-
-async function transformRequest(opts, id) {
-  if (id && id.startsWith("/@id/__x00__"))
-    id = `\0${id.slice("/@id/__x00__".length)}`;
-  if (id && id.startsWith("/@id/"))
-    id = id.slice("/@id/".length);
-  if (id && !id.startsWith("/@fs/") && id.startsWith("/")) {
-    const resolvedPath = resolve(opts.viteServer.config.root, `.${id}`);
-    if (existsSync(resolvedPath))
-      id = resolvedPath;
-  }
-  id = id.replace(/^\/?(?=\w:)/, "/@fs/");
-  const externalId = id.replace(/\?v=\w+$|^\/@fs/, "");
-  if (await opts.isExternal(externalId)) {
-    const path = builtinModules.includes(externalId.split("node:").pop()) ? externalId : isAbsolute(externalId) ? pathToFileURL(externalId).href : externalId;
-    return {
-      code: `(global, module, _, exports, importMeta, ssrImport, ssrDynamicImport, ssrExportAll) =>
-${genDynamicImport(path, { wrapper: false })}
-  .then(r => {
-    if (r.default && r.default.__esModule)
-      r = r.default
-    exports.default = r.default
-    ssrExportAll(r)
-  })
-  .catch(e => {
-    console.error(e)
-    throw new Error(${JSON.stringify(`[vite dev] Error loading external "${id}".`)})
-  })`,
-      deps: [],
-      dynamicDeps: []
-    };
-  }
-  const res = await opts.viteServer.transformRequest(id, { ssr: true }).catch((err) => {
-    console.warn(`[SSR] Error transforming ${id}:`, err);
-  }) || { code: "", map: {}, deps: [], dynamicDeps: [] };
-  const code = `async function (global, module, exports, __vite_ssr_exports__, __vite_ssr_import_meta__, __vite_ssr_import__, __vite_ssr_dynamic_import__, __vite_ssr_exportAll__) {
-${res.code || "/* empty */"};
-}`;
-  return { code, deps: res.deps || [], dynamicDeps: res.dynamicDeps || [] };
-}
-async function transformRequestRecursive(opts, id, parent = "<entry>", chunks = {}) {
-  if (chunks[id]) {
-    chunks[id].parents.push(parent);
-    return;
-  }
-  const res = await transformRequest(opts, id);
-  const deps = uniq([...res.deps, ...res.dynamicDeps]);
-  chunks[id] = {
-    id,
-    code: res.code,
-    deps,
-    parents: [parent]
-  };
-  for (const dep of deps)
-    await transformRequestRecursive(opts, dep, id, chunks);
-  return Object.values(chunks);
-}
-async function bundleRequest(opts, entryURL) {
-  const chunks = await transformRequestRecursive(opts, entryURL);
-  const listIds = (ids) => ids.map((id) => `// - ${id} (${hashId(id)})`).join("\n");
-  const chunksCode = chunks.map((chunk) => `
-// --------------------
-// Request: ${chunk.id}
-// Parents: 
-${listIds(chunk.parents)}
-// Dependencies: 
-${listIds(chunk.deps)}
-// --------------------
-const ${hashId(`${chunk.id}-${chunk.code}`)} = ${chunk.code}
-`).join("\n");
-  const manifestCode = `const __modules__ = ${genObjectFromRawEntries(chunks.map((chunk) => [chunk.id, hashId(`${chunk.id}-${chunk.code}`)]))}`;
-  const ssrModuleLoader = `
-const __pendingModules__ = new Map()
-const __pendingImports__ = new Map()
-const __ssrContext__ = { global: globalThis }
-
-function __ssrLoadModule__(url, urlStack = []) {
-  const pendingModule = __pendingModules__.get(url)
-  if (pendingModule) { return pendingModule }
-  const modulePromise = __instantiateModule__(url, urlStack)
-  __pendingModules__.set(url, modulePromise)
-  modulePromise.catch(() => { __pendingModules__.delete(url) })
-         .finally(() => { __pendingModules__.delete(url) })
-  return modulePromise
-}
-
-async function __instantiateModule__(url, urlStack) {
-  const mod = __modules__[url]
-  if (mod.stubModule) { return mod.stubModule }
-  const stubModule = { [Symbol.toStringTag]: 'Module' }
-  Object.defineProperty(stubModule, '__esModule', { value: true })
-  mod.stubModule = stubModule
-  // https://vitejs.dev/guide/api-hmr.html
-  const importMeta = { url, hot: { accept() {}, prune() {}, dispose() {}, invalidate() {}, decline() {}, on() {} } }
-  urlStack = urlStack.concat(url)
-  const isCircular = url => urlStack.includes(url)
-  const pendingDeps = []
-  const ssrImport = async (dep) => {
-    // TODO: Handle externals if dep[0] !== '.' | '/'
-    if (!isCircular(dep) && !__pendingImports__.get(dep)?.some(isCircular)) {
-      pendingDeps.push(dep)
-      if (pendingDeps.length === 1) {
-        __pendingImports__.set(url, pendingDeps)
-      }
-      await __ssrLoadModule__(dep, urlStack)
-      if (pendingDeps.length === 1) {
-        __pendingImports__.delete(url)
-      } else {
-        pendingDeps.splice(pendingDeps.indexOf(dep), 1)
-      }
-    }
-    return __modules__[dep].stubModule
-  }
-  function ssrDynamicImport (dep) {
-    // TODO: Handle dynamic import starting with . relative to url
-    return ssrImport(dep)
-  }
-
-  function ssrExportAll(sourceModule) {
-    for (const key in sourceModule) {
-      if (key !== 'default') {
-        try {
-          Object.defineProperty(stubModule, key, {
-            enumerable: true,
-            configurable: true,
-            get() { return sourceModule[key] }
-          })
-        } catch (_err) { }
-      }
-    }
-  }
-
-  const cjsModule = {
-    get exports () {
-      return stubModule.default
-    },
-    set exports (v) {
-      stubModule.default = v
-    },
-  }
-
-  await mod(
-    __ssrContext__.global,
-    cjsModule,
-    stubModule.default,
-    stubModule,
-    importMeta,
-    ssrImport,
-    ssrDynamicImport,
-    ssrExportAll
-  )
-
-  return stubModule
-}
-`;
-  const code = [
-    chunksCode,
-    manifestCode,
-    ssrModuleLoader,
-    `export default await __ssrLoadModule__(${JSON.stringify(entryURL)})`
-  ].join("\n\n");
-  return {
-    code,
-    ids: chunks.map((i) => i.id)
-  };
-}
-async function initViteDevBundler(ctx, onBuild) {
-  const viteServer = ctx.ssrServer;
-  const options = {
-    viteServer,
-    isExternal: createIsExternal(viteServer, ctx.nuxt.options.rootDir)
-  };
-  const _doBuild = async () => {
-    const start = Date.now();
-    const { code, ids } = await bundleRequest(options, ctx.entry);
-    await fse.ensureFile(resolve(ctx.nuxt.options.buildDir, "dist/server/server.mjs"));
-    await fse.writeFile(resolve(ctx.nuxt.options.buildDir, "dist/server/server.mjs"), code, "utf-8");
-    await writeManifest(ctx, ids.filter(isCSS).map((i) => i.slice(1)));
-    const time = Date.now() - start;
-    logger.success(`Vite server built in ${time}ms`);
-    await onBuild();
-    ctx.nuxt.callHook("bundler:change", {});
-  };
-  const doBuild = debounce(_doBuild, 60);
-  await _doBuild();
-  viteServer.watcher.on("all", (_event, file) => {
-    if (file.includes("/pages/"))
-      return;
-    file = normalize(file);
-    if (file.indexOf(ctx.nuxt.options.buildDir) === 0 || isIgnoredFlow(file))
-      return;
-    doBuild();
-  });
-  ctx.nuxt.hook("app:templatesGenerated", () => doBuild());
-}
-
-export { bundleRequest, initViteDevBundler };

package/dist/chunks/external.mjs

@@ -1,37 +0,0 @@
-import 'node:fs';
-import { hash } from 'ohash';
-import 'pathe';
-import { ExternalsDefaults, isExternal } from 'externality';
-
-function uniq(arr) {
-  return Array.from(new Set(arr));
-}
-const IS_CSS_RE = /\.(?:css|scss|sass|postcss|less|stylus|styl)(\?[^.]+)?$/;
-function isCSS(file) {
-  return IS_CSS_RE.test(file);
-}
-function hashId(id) {
-  return `$id_${hash(id)}`;
-}
-
-function createIsExternal(viteServer, rootDir) {
-  const externalOpts = {
-    inline: [
-      /virtual:/,
-      /\.ts$/,
-      ...ExternalsDefaults.inline || [],
-      ...viteServer.config.ssr.noExternal
-    ],
-    external: [
-      ...viteServer.config.ssr.external || [],
-      /node_modules/
-    ],
-    resolve: {
-      type: "module",
-      extensions: [".ts", ".js", ".json", ".vue", ".mjs", ".jsx", ".tsx", ".wasm"]
-    }
-  };
-  return (id) => isExternal(id, rootDir, externalOpts);
-}
-
-export { createIsExternal as c, hashId as h, isCSS as i, uniq as u };