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

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

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);
-  }
-};