@monkeyplus/flow 5.0.0-rc.2 → 5.0.0-rc.20

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,
-];

package/src/auto-imports/transform.ts

@@ -1,48 +0,0 @@
-import { pathToFileURL } from 'node:url';
-import { createUnplugin } from 'unplugin';
-import { parseQuery, parseURL } from 'ufo';
-import type { Unimport } from 'unimport';
-import type { AutoImportsOptions } from '@monkeyplus/flow-schema';
-
-export const TransformPlugin = createUnplugin(({ ctx, options, sourcemap }: { ctx: Unimport; options: Partial<AutoImportsOptions>; sourcemap?: boolean }) => {
-  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 || [];
-
-      // Exclude node_modules by default
-      if (exclude.some((pattern) => id.match(pattern)))
-        return false;
-
-      // Custom includes
-      if (include.some((pattern) => id.match(pattern)))
-        return true;
-
-      // vue files
-      if (
-        pathname.endsWith('.vue')
-        && (type === 'template' || type === 'script' || macro || !search)
-      )
-        return true;
-
-      // js files
-      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 }),
-      };
-    },
-  };
-});

package/src/core/app.ts

@@ -1,90 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import type { Flow, FlowApp, FlowPlugin } from '@monkeyplus/flow-schema';
-import { compileTemplate, normalizePlugin, normalizeTemplate, resolveFilesFlow, templateUtils } from '@monkeyplus/flow-kit';
-import defu from 'defu';
-
-import { dirname, resolve } from 'pathe';
-
-import * as defaultTemplates from './templates';
-
-export function createApp(flow: Flow, options: Partial<FlowApp> = {}): FlowApp {
-  return defu(options, {
-    dir: flow.options.srcDir,
-    extensions: flow.options.extensions,
-    plugins: [],
-    templates: [],
-
-  } as FlowApp);
-}
-
-export async function generateApp(flow: Flow, app: FlowApp) {
-  await resolveApp(flow, app);
-  // User templates from options.build.templates
-  app.templates = Object.values(defaultTemplates).concat(
-    flow.options.build.templates,
-  );
-
-  // Extend templates with hook
-  await flow.callHook('app:templates', app);
-  // Normalize templates
-  app.templates = app.templates.map((tmpl) => normalizeTemplate(tmpl));
-
-  // Compile templates into vfs
-  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;
-
-      // In case a non-normalized absolute path is called for on Windows
-      if (process.platform === 'win32')
-        flow.vfs[fullPath.replace(/\//g, '\\')] = contents;
-
-      if (template.write) {
-        await fsp.mkdir(dirname(fullPath), { recursive: true });
-        await fsp.writeFile(fullPath, contents, 'utf8');
-      }
-    }),
-  );
-
-  await flow.callHook('app:templatesGenerated', app);
-}
-
-export async function resolveApp(flow: Flow, app: FlowApp) {
-  // Resolve plugins
-  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 as FlowPlugin)),
-    );
-  }
-  app.plugins = uniqueBy(app.plugins, 'src');
-
-  // Extend app
-  await flow.callHook('app:resolve', app);
-}
-
-function uniqueBy<T, K extends keyof T>(arr: T[], key: K) {
-  const res: T[] = [];
-  const seen = new Set<T[K]>();
-  for (const item of arr) {
-    if (seen.has(item[key]))
-      continue;
-
-    seen.add(item[key]);
-    res.push(item);
-  }
-  return res;
-}

package/src/core/builder.ts

@@ -1,60 +0,0 @@
-import { normalize } from 'pathe';
-import chokidar from 'chokidar';
-import type { Flow } from '@monkeyplus/flow-schema';
-import { isIgnoredFlow } from '@monkeyplus/flow-kit';
-import { debounce } from 'perfect-debounce';
-import { generateApp as _generateApp, createApp } from './app';
-
-import { bundleVite } from './vite/builder';
-
-export async function build(flow: Flow) {
-  const app = createApp(flow);
-  const generateApp = debounce(() => _generateApp(flow, app), undefined, { leading: true });
-  await generateApp();
-
-  if (flow.options.dev) {
-    watch(flow);
-    flow.hook('builder:watch', async(event, path) => {
-      if (event !== 'change' && /app|error|plugins/i.test(path))
-        await generateApp();
-    });
-    flow.hook('builder:generateApp', generateApp);
-  }
-
-  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: Flow) {
-  const watcher = chokidar.watch(flow.options.srcDir, {
-    ...flow.options.watchers.chokidar,
-    cwd: flow.options.srcDir,
-    ignoreInitial: true,
-    ignored: [
-      isIgnoredFlow,
-      '.flow',
-      'node_modules',
-    ],
-  });
-
-  const watchHook = debounce((event: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir', path: string) => flow.callHook('builder:watch', event, normalize(path)));
-  watcher.on('all', watchHook);
-  flow.hook('close', () => watcher.close());
-  return watcher;
-}
-
-async function bundle(nuxt: Flow) {
-  try {
-    return bundleVite(nuxt);
-  }
-  catch (error) {
-    await nuxt.callHook('build:error', error);
-    throw error;
-  }
-}

package/src/core/flow.ts

@@ -1,93 +0,0 @@
-import { createHooks } from 'hookable';
-import type { Flow, FlowConfig, FlowHooks, FlowOptions, ModuleContainer } from '@monkeyplus/flow-schema';
-import { resolve } from 'pathe';
-import type { LoadFlowOptions } from '@monkeyplus/flow-kit';
-import { installModule, loadFlowConfig, nuxtCtx } from '@monkeyplus/flow-kit';
-import { version } from '../../package.json';
-import { distDir, pkgDir } from '../dirs';
-import metaModule from '../head/module';
-import autoImportsModule from '../auto-imports/module';
-import pagesModule from '../pages/module';
-import viteModule from '../vite-client/module';
-
-import { initNitro } from './nitro';
-import { addModuleTranspiles } from './modules';
-
-export function createFlow(options: FlowOptions): Flow {
-  const hooks = createHooks<FlowHooks>();
-
-  const flow: Flow = {
-    //* Include nuxt version
-    _version: '3.0.0-rc.3',
-    //* Include version
-    // @ts-ignore
-    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): Promise<void> {
-  // Register user hooks
-  nuxtCtx.set(flow);
-
-  flow.hook('close', () => nuxtCtx.unset());
-  // flow.hook('prepare:types', (opts) => {...})
-
-  await flow.callHook('modules:before', { nuxt: flow } as ModuleContainer);
-
-  const modulesToInstall = [
-    // ...flow.options.buildModules,
-    ...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 } as ModuleContainer);
-
-  await addModuleTranspiles();
-
-  await initNitro(flow);
-
-  await flow.callHook('ready', flow);
-}
-
-export async function loadFlow(opts: LoadFlowOptions): Promise<Flow> {
-  const options = await loadFlowConfig(opts);
-  options.appDir = resolve(distDir, 'app');
-  options._majorVersion = 3;
-  options._modules.push(pagesModule, metaModule, autoImportsModule, viteModule);
-  options.modulesDir.push(resolve(pkgDir, 'node_modules'));
-  // options.build.transpile.push('@nuxt/ui-templates');
-  // options.alias['vue-demi'] = resolve(options.appDir, 'compat/vue-demi');
-  // options.alias['@vue/composition-api'] = resolve(options.appDir, 'compat/capi');
-  // if (options.telemetry !== false && !process.env.NUXT_TELEMETRY_DISABLED)
-  //   options._modules.push('@nuxt/telemetry');
-
-  const flow = createFlow(options);
-
-  if (opts.ready !== false)
-    await flow.ready();
-
-  return flow;
-}
-
-export function defineFlowConfig(config: FlowConfig): FlowConfig {
-  return config;
-}
-
-export type { FlowConfig };

package/src/core/modules.ts

@@ -1,32 +0,0 @@
-import { useNuxt } from '@monkeyplus/flow-kit';
-
-export interface AddModuleTranspilesOptions {
-  additionalModules?: string[]
-}
-
-export const addModuleTranspiles = (opts: AddModuleTranspilesOptions = {}) => {
-  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());
-
-  // Try to sanitize modules to better match imports
-  flow.options.build.transpile
-    = flow.options.build.transpile.map((m) => typeof m === 'string' ? m.split('node_modules/').pop() : m);
-
-  function isTranspilePresent(mod: string) {
-    return flow.options.build.transpile.some((t) => !(t instanceof Function) && (t instanceof RegExp ? t.test(mod) : new RegExp(t).test(mod)));
-  }
-
-  // Automatically add used modules to the transpile
-  for (const module of modules) {
-    if (!isTranspilePresent(module))
-      flow.options.build.transpile.push(module);
-  }
-};