@monkeyplus/flow 5.0.0-rc.1 → 5.0.0-rc.10

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

@@ -1,4 +1,5 @@
+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(): {};
+export declare function useRoute(): RouteLocationNormalizedLoaded;

package/dist/core/runtime/nitro/renderer.mjs

@@ -18,7 +18,8 @@ export default eventHandler(async (event) => {
   const templateContext = {};
   const dynamyc = params?._;
   const contextPage = {};
-  const utils = Object.assign({ getLocale: () => locale }, flow.app.utils);
+  const contextInject = {};
+  const utils = Object.assign({ getLocale: () => locale, injectContext: (key, value) => contextInject[key] = value }, flow.app.utils);
   templateContext.url = url;
   templateContext.locale = locale;
   templateContext.view = view;
@@ -46,6 +47,9 @@ export default eventHandler(async (event) => {
   templateContext.getBodyChunks = () => {
     return chunks.body.join("\n");
   };
+  templateContext.getInjectContext = () => {
+    return `<script id="__FLOW_DATA__" type="application/json">${JSON.stringify(contextInject)}<\/script>`;
+  };
   const query = useQuery(event);
   if (query?.context)
     return { ...templateContext, utils: Object.keys(utils) };

package/dist/index.mjs

@@ -27,7 +27,7 @@ import { isExternal as isExternal$1, ExternalsDefaults } from 'externality';
 import { createHash } from 'node:crypto';
 import MagicString from 'magic-string';
 
-const version = "5.0.0-rc.1";
+const version = "5.0.0-rc.10";
 
 let _distDir = dirname(fileURLToPath(import.meta.url));
 if (_distDir.endsWith("chunks"))
@@ -87,6 +87,13 @@ const commonPresets = [
     imports: [
       "useHead"
     ]
+  }),
+  defineUnimportPreset({
+    from: "#_pages",
+    imports: [
+      "definePage",
+      "defineDinamycPage"
+    ]
   })
 ];
 const appPreset = defineUnimportPreset({
@@ -223,11 +230,11 @@ ${ctx.generateTypeDecarations({ resolvePath: r })}`
 
 async function resolvePagesRoutes() {
   const nuxt = useNuxt();
-  const pagesDirs = [...new Set(nuxt.options._layers.map((layer) => resolve(layer.config.srcDir, layer.config.dir?.pages || "pages")))];
+  const pagesDirs = [resolve(nuxt.options.srcDir, nuxt.options.dir?.pages || "pages")];
   const allRoutes = (await Promise.all(pagesDirs.map(async (dir) => {
     const files = await resolveFilesFlow(dir, `**/*{${nuxt.options.extensions.join(",")}}`);
     files.sort();
-    return files.map((file) => {
+    return files.filter((file) => !file.includes(" copy")).map((file) => {
       const segments = relative(dir, file).replace(new RegExp(`${escapeRE(extname(file))}$`), "").split("/").join("_");
       return {
         file,
@@ -241,7 +248,10 @@ function normalizePages(pages) {
   const imports = pages.map((page) => genImport(page.file, [{ name: "pages", as: page.name }])).join("\n");
   return {
     imports,
-    exports: pages.reduce((acc, curr) => `${curr.name || ""},${acc}`, "")
+    exports: pages.reduce((acc, curr) => {
+      const name = curr.name;
+      return `${name}:typeof ${name}==='function'?${name}():${name},${acc}`;
+    }, "")
   };
 }
 
@@ -263,6 +273,7 @@ const pagesModule = defineNuxtModule({
   },
   async setup(_options, flow) {
     const runtimeDir = resolve(distDir, "pages/runtime");
+    flow.options.alias["#_pages"] = runtimeDir;
     const pages = [];
     flow.hook("builder:watch", async (event, path) => {
       const dirs = [
@@ -279,6 +290,7 @@ const pagesModule = defineNuxtModule({
       ...pagesTypeTemplate,
       options
     });
+    const pagesDirs = [{ path: resolve(flow.options.srcDir, flow.options.dir.pages) }];
     flow.options.alias["#pages"] = resolve(flow.options.buildDir, "pages.mjs");
     addTemplate({
       filename: "pages.mjs",
@@ -294,6 +306,13 @@ const pagesModule = defineNuxtModule({
     flow.hook("prepare:types", ({ references }) => {
       references.push({ path: resolve(flow.options.buildDir, "pages.d.ts") });
     });
+    flow.hook("builder:watch", async (event, path) => {
+      if (!["add", "unlink"].includes(event))
+        return;
+      const fPath = resolve(flow.options.rootDir, path);
+      if (pagesDirs.find((dir) => fPath.startsWith(dir.path)))
+        await flow.callHook("builder:generateApp");
+    });
     addPlugin({ src: resolve(runtimeDir, "plugin") });
   }
 });
@@ -486,7 +505,6 @@ async function initNitro(flow) {
       "@babel/parser": "unenv/runtime/mock/proxy",
       "#paths": resolve(distDir, "core/runtime/nitro/paths"),
       "#server": "#build/dist/server/server.mjs",
-      "#app": flow.options.appDir,
       ...flow.options.alias
     },
     rollupConfig: {
@@ -630,6 +648,7 @@ async function initFlow(flow) {
 async function loadFlow(opts) {
   const options = await loadFlowConfig(opts);
   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"));
@@ -1158,7 +1177,7 @@ const buildServer = async (ctx) => {
     await onBuild();
     ctx.flow.callHook("bundler:change", {});
   };
-  const doBuild = debounce(_doBuild);
+  const doBuild = debounce(_doBuild, 50);
   await _doBuild();
   viteServer.watcher.on("all", (_event, file) => {
     file = normalize(file);

package/dist/pages/runtime/index.d.ts

@@ -1,3 +1,3 @@
 import type { DynamicPage, SimplePage } from '@monkeyplus/flow-schema';
-export declare function definePage(page: SimplePage): SimplePage;
-export declare function defineDinamycPage(page: DynamicPage): DynamicPage;
+export declare function definePage(...pages: SimplePage[]): SimplePage[];
+export declare function defineDinamycPage(...pages: DynamicPage[]): DynamicPage[];

package/dist/pages/runtime/index.mjs

@@ -1,6 +1,6 @@
-export function definePage(page) {
-  return page;
+export function definePage(...pages) {
+  return pages;
 }
-export function defineDinamycPage(page) {
-  return page;
+export function defineDinamycPage(...pages) {
+  return pages;
 }

package/dist/pages/runtime/plugin.mjs

@@ -1,20 +1,26 @@
 import { joinURL } from "ufo";
+import consola from "consola";
 import { definePage } from "./helpers/index.mjs";
 import { defineFlowPlugin, useRuntimeConfig } from "#app";
 import pages from "#pages";
 export default defineFlowPlugin(async (flow) => {
   const { app } = useRuntimeConfig();
   const allPages = [];
-  Object.entries(pages).forEach(([name, page]) => {
-    const { getPages } = definePage({
-      name,
-      ...page
-    });
-    const _pages = getPages(app.locale.location, app.locale.language);
-    _pages.forEach((page2) => {
-      flow.router.byUrl.insert(page2.url, page2.context);
-      flow.router.byName.insert(page2.name, page2.context);
-      allPages.push(page2.context);
+  const basePages = Object.entries(pages);
+  consola.success("Parsed %i pages files", basePages.length);
+  basePages.forEach(([name, _pages]) => {
+    const __pages = Array.isArray(_pages) ? _pages : [_pages];
+    __pages.forEach((page) => {
+      const { getPages } = definePage({
+        name,
+        ...page
+      });
+      const _pages2 = getPages(app.locale.location, app.locale.language);
+      _pages2.forEach((page2) => {
+        flow.router.byUrl.insert(page2.url, page2.context);
+        flow.router.byName.insert(page2.name, page2.context);
+        allPages.push(page2.context);
+      });
     });
   });
   function getUrl(namePage, localeCode) {

package/package.json

@@ -1,22 +1,33 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "5.0.0-rc.1",
+  "version": "5.0.0-rc.10",
   "license": "MIT",
   "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./types.d.ts",
+  "bin": {
+    "flow": "./bin/flow.mjs"
+  },
   "exports": {
     ".": "./dist/index.mjs",
     "./app": "./dist/app/index.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.mjs",
-  "types": "./types.d.ts",
-  "bin": {
-    "flow": "./bin/flow.mjs"
+  "imports": {
+    "#app": "./dist/app/index.mjs",
+    "#head": "./dist/head/runtime/index.mjs",
+    "#pages": "./dist/pages/runtime/index.mjs"
   },
+  "files": [
+    "app.d.ts",
+    "bin",
+    "types.d.ts",
+    "dist"
+  ],
   "dependencies": {
-    "@monkeyplus/flow-cli": "5.0.0-rc.1",
-    "@monkeyplus/flow-kit": "5.0.0-rc.1",
-    "@monkeyplus/flow-schema": "5.0.0-rc.1",
+    "@monkeyplus/flow-cli": "5.0.0-rc.10",
+    "@monkeyplus/flow-kit": "5.0.0-rc.10",
+    "@monkeyplus/flow-schema": "5.0.0-rc.10",
     "@rollup/plugin-replace": "^4.0.0",
     "@vueuse/head": "^0.7.6",
     "c12": "^0.2.7",
@@ -58,7 +69,8 @@
     "vue": "^3.2.33"
   },
   "devDependencies": {
-    "@types/fs-extra": "^9.0.13"
+    "@types/fs-extra": "^9.0.13",
+    "vue-router": "^4.0.15"
   },
   "engines": {
     "node": "^16.11.0 || ^17.0.0 || ^18.0.0"

package/build.config.ts

@@ -1,25 +0,0 @@
-import type { BuildEntry } from 'unbuild';
-import { defineBuildConfig } from 'unbuild';
-
-export default defineBuildConfig({
-  declaration: true,
-  entries: [
-    'src/index',
-    { input: 'src/app/', outDir: 'dist/app/' },
-    ...[
-      'core',
-      'head',
-      'pages',
-      'vite-client',
-    ].map((name) => ({ input: `src/${name}/runtime/`, outDir: `dist/${name}/runtime`, format: 'esm' } as BuildEntry)),
-    // { input: 'src/runtime/', outDir: 'dist/runtime', format: 'esm' },
-  ],
-  dependencies: [
-    '@monkeyplus/flow-cli',
-    'ohmyfetch',
-
-  ],
-  externals: [
-
-  ],
-});

package/src/app/composables/index.ts

@@ -1,20 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-//* fake to nuxt Compatibilities
-
-export function useCookie(name: string, _opts?: any) {
-  // console.log('Cookie', name, _opts);
-
-  return {};
-}
-
-export function refreshNuxtData(keys?: string | string[]): Promise<void> {
-  return Promise.resolve();
-}
-
-export function useAsyncData(key: string, handlers: () => Promise<any>) {
-  return handlers();
-}
-
-export function useRoute() {
-  return {};
-}

package/src/app/entry.ts

@@ -1,36 +0,0 @@
-
-import type { RuntimeConfig } from '@monkeyplus/flow-schema';
-import { config, configure, render } from 'eta';
-import { applyPlugins, createFlowApp } from './flow';
-// @ts-ignore
-import plugins from '#build/plugins';
-
-export default async(runtimeConfig: RuntimeConfig) => {
-  const flow = createFlowApp({ runtimeConfig });
-  try {
-    await applyPlugins(flow, plugins);
-    // console.log(flow.eta);
-
-    configure(flow.eta);
-    flow.render = (view: Record<string, string>, data: any) => {
-      // eslint-disable-next-line no-template-curly-in-string
-      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,
-      });
-    };
-
-    // await flow.hooks.callHook('app:created', vueApp);
-  }
-  catch (err) {
-    console.log(err);
-    // await flow.callHook('app:error', err);
-    // ssrContext.error = ssrContext.error || err;
-  }
-
-  return flow;
-};

package/src/app/flow.ts

@@ -1,157 +0,0 @@
-import type { RadixRouter } from 'radix3';
-import { createRouter } from 'radix3';
-import type { Hookable } from 'hookable';
-import { createHooks } from 'hookable';
-import type { FlowPage, RuntimeConfig } from '@monkeyplus/flow-schema';
-import { getContext } from 'unctx';
-import { globby } from 'globby';
-import { join, resolve } from 'pathe';
-
-const flowAppCtx = getContext<FlowApp>('flow-app');
-
-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: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: Record<string, any>
-    plugins: Record<string, any>
-    globals: Record<string, any>
-  }
-  engine: 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 const FlowPluginIndicator = '__flow_plugin';
-export 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 function createFlowApp({ runtimeConfig }: OptionsApp): FlowApp {
-  //
-
-  const viewsDir = join(runtimeConfig.app.rootDir, 'views');
-
-  const flowApp: FlowApp = {
-    router: { byUrl: createRouter(), byName: createRouter() },
-    app: {
-      utils: {},
-      globals: {},
-    },
-    eta: {
-      views: viewsDir,
-      plugins: [],
-    },
-    engine: 'eta',
-    engines: { },
-    generate: runtimeConfig.generate,
-  } as FlowApp;
-
-  flowApp.engines.eta = (template: string) => {
-    return `<%~ await includeFile('templates/${template}',it) %>`;
-  };
-  flowApp.hooks = createHooks<FlowAppHooks>();
-  flowApp.hook = flowApp.hooks.hook;
-  flowApp.callHook = flowApp.hooks.callHook;
-
-  flowApp.provide = (name: string, value: any) => {
-    const $name = `$${name}`;
-    defineGetter(flowApp, $name, value);
-    // defineGetter(nuxtApp.vueApp.config.globalProperties, $name, value);
-  };
-  flowApp.setUtil = (name: string, method: any) => {
-    flowApp.app.utils[name] = method;
-  };
-
-  flowApp.hook('eta:plugin', (_plugin) => {
-    flowApp.eta.plugins.push(_plugin);
-  });
-
-  flowApp.provide('config', runtimeConfig);
-
-  return flowApp;
-}
-
-export function defineFlowPlugin<T>(plugin: Plugin<T>) {
-  plugin[FlowPluginIndicator] = true;
-  return plugin;
-}
-
-export function defineNuxtPlugin<T>(plugin: Plugin<T>) {
-  plugin[NuxtPluginIndicator] = true;
-  return plugin;
-}
-
-export async function applyPlugin(flowApp: FlowApp, plugin: 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: FlowApp, plugins: Plugin[]) {
-  for (const plugin of plugins)
-    await applyPlugin(flowApp, plugin);
-}
-
-/**
- * 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 function callWithFlow<T extends(...args: any[]) => any> (flow: FlowApp, setup: T, args?: Parameters<T>) {
-  const fn = () => args ? setup(...args as Parameters<T>) : setup();
-  // TODO: posible error
-  flowAppCtx.set(flow);
-  return flowAppCtx.callAsync<ReturnType<T>>(flow, fn);
-}
-/**
- * Returns the current Nuxt instance.
- */
-export function useFlowApp() {
-  const flowAppInstance = flowAppCtx.use();
-  if (!flowAppInstance)
-    throw new Error('flow instance unavailable');
-
-  return flowAppInstance;
-}
-export function useRuntimeConfig(): RuntimeConfig {
-  return useFlowApp().$config;
-}
-
-function defineGetter<K extends string | number | symbol, V>(obj: Record<K, V>, key: K, val: V) {
-  Object.defineProperty(obj, key, { get: () => val });
-}
-
-export async function resolveFiles(path: string, pattern: string | string[]) {
-  const files = await globby(pattern, { cwd: path, followSymbolicLinks: true });
-  return files.filter((file) => !file.includes('copy.ts')).map((p) => resolve(path, p));
-}

package/src/app/index.ts

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

package/src/auto-imports/module.ts

@@ -1,143 +0,0 @@
-import { addPluginTemplate, addTemplate, addVitePlugin, defineNuxtModule, logger, resolveAlias, useNuxt } from '@monkeyplus/flow-kit';
-import { isAbsolute, join, normalize, relative, resolve } from 'pathe';
-import type { Import, Unimport } from 'unimport';
-import { createUnimport, scanDirExports, toImports } from 'unimport';
-import type { AutoImportsOptions, FlowModule, ImportPresetWithDeprecation } from '@monkeyplus/flow-schema';
-import { TransformPlugin } from './transform';
-import { defaultPresets } from './presets';
-
-export default defineNuxtModule<Partial<AutoImportsOptions>>({
-  meta: {
-    name: 'auto-imports',
-    configKey: 'autoImports',
-  },
-  defaults: {
-    presets: defaultPresets,
-    global: false,
-    imports: [],
-    dirs: [],
-    transform: {
-      exclude: undefined,
-    },
-  },
-  async setup(options, flow) {
-    // Allow modules extending sources
-    await flow.callHook('autoImports:sources', options.presets as ImportPresetWithDeprecation[]);
-
-    options.presets.forEach((i: ImportPresetWithDeprecation) => {
-      if (typeof i !== 'string' && i.names && !i.imports) {
-        i.imports = i.names;
-        logger.warn('auto-imports: presets.names is deprecated, use presets.imports instead');
-      }
-    });
-
-    // Filter disabled sources
-    // options.sources = options.sources.filter(source => source.disabled !== true)
-
-    // Create a context to share state between module internals
-    const ctx = createUnimport({
-      presets: options.presets,
-      imports: options.imports,
-    });
-
-    // composables/ dirs from all layers
-    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));
-
-    // Support for importing from '#imports'
-    addTemplate({
-      filename: 'imports.mjs',
-      getContents: () => ctx.toExports(),
-    });
-    flow.options.alias['#imports'] = join(flow.options.buildDir, 'imports');
-
-    // Transpile and injection
-    // @ts-ignore temporary disabled due to #746
-    if (flow.options.dev && options.global) {
-      // Add all imports to globalThis in development mode
-      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}\n\n${globalThisSet}\n\nexport default () => {};`;
-        },
-      });
-    }
-    else {
-      // Transform to inject imports in production mode
-      addVitePlugin(TransformPlugin.vite({ ctx, options, sourcemap: flow.options.sourcemap }));
-    }
-
-    const regenerateAutoImports = async() => {
-      ctx.clearDynamicImports();
-      await ctx.modifyDynamicImports(async(imports) => {
-        // Scan composables/
-        imports.push(...await scanDirExports(composablesDirs));
-        // Modules extending
-        await flow.callHook('autoImports:extend', imports);
-      });
-    };
-
-    await regenerateAutoImports();
-
-    // Generate types
-    addDeclarationTemplates(ctx);
-
-    // Add generated types to `nuxt.d.ts`
-    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') });
-    });
-
-    // Watch composables/ directory
-    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();
-    });
-  },
-}) as FlowModule<any>;
-
-function addDeclarationTemplates(ctx: Unimport) {
-  const nuxt = useNuxt();
-
-  // Remove file extension for benefit of TypeScript
-  const stripExtension = (path: string) => path.replace(/\.[a-z]+$/, '');
-
-  const resolved = {};
-  const r = ({ from }: Import) => {
-    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\n${ctx.generateTypeDecarations({ resolvePath: r })}`,
-  });
-}

package/src/auto-imports/presets.ts

@@ -1,49 +0,0 @@
-import type { Preset } from 'unimport';
-import { defineUnimportPreset } from 'unimport';
-
-export const commonPresets: Preset[] = [
-  // #head
-  defineUnimportPreset({
-    from: '#head',
-    imports: [
-      'useHead',
-    ],
-  }),
-
-];
-
-export const appPreset = defineUnimportPreset({
-  from: '#app',
-  imports: [
-    'useRuntimeConfig',
-    'defineFlowPlugin',
-    'defineNuxtPlugin',
-    'useCookie',
-    'refreshNuxtData',
-    'useAsyncData',
-    'useRoute',
-
-  ],
-});
-
-// * Compatibilitie Nuxt
-export const vuePreset = defineUnimportPreset({
-  from: 'vue',
-  imports: [
-    // Components
-    'defineComponent',
-    'getCurrentInstance',
-    'useSlots',
-    'h',
-
-    // Reactivity
-    'computed',
-
-  ],
-});
-
-export const defaultPresets = [
-  ...commonPresets,
-  appPreset,
-  vuePreset,
-];