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

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

package/src/core/nitro.ts

@@ -1,206 +0,0 @@
-import { existsSync, promises as fsp } from 'node:fs';
-import {
-  build,
-  copyPublicAssets,
-  createDevServer,
-  createNitro,
-  prepare,
-  prerender,
-  scanHandlers,
-  writeTypes,
-
-} from 'nitropack';
-import fsExtra from 'fs-extra';
-import type { NitroConfig, NitroDevEventHandler, NitroEventHandler } from 'nitropack';
-import defu from 'defu';
-import { join, resolve } from 'pathe';
-import type { Flow } from '@monkeyplus/flow-schema';
-import { dynamicEventHandler, toEventHandler } from 'h3';
-// import { debounce } from 'perfect-debounce';
-import { distDir } from '../dirs';
-import { ImportProtectionPlugin } from './plugins/import-protection';
-
-export async function initNitro(flow: Flow): Promise<void> {
-  const { handlers, devHandlers } = await resolveHandlers(flow);
-
-  const _nitroConfig = ((flow.options as any).nitro || {}) as NitroConfig;
-  // const vite = await createVite(flow);
-  globalThis.generate = {};
-  const nitroConfig: NitroConfig = defu(_nitroConfig, <NitroConfig>{
-    rootDir: flow.options.rootDir,
-    srcDir: join(flow.options.srcDir, 'server'),
-    dev: flow.options.dev,
-    preset: flow.options.dev ? 'nitro-dev' : undefined,
-    buildDir: flow.options.buildDir,
-    scanDirs: flow.options._layers.map((layer) => join(layer.config.srcDir, 'server')),
-    renderer: resolve(distDir, 'core/runtime/nitro/renderer'),
-    // errorHandler: resolve(distDir, 'core/runtime/nitro/error'),
-    nodeModulesDirs: flow.options.modulesDir,
-    handlers,
-    devHandlers: [
-
-    ],
-    baseURL: flow.options.app.baseURL,
-    runtimeConfig: {
-      ...flow.options.runtimeConfig,
-      app: {
-        ...flow.options.runtimeConfig.app,
-        rootDir: flow.options.rootDir,
-        locale: flow.options.locale,
-      },
-      nitro: {
-        envPrefix: 'FLOW_',
-        ...flow.options.runtimeConfig.nitro,
-      },
-      generate: flow.options._generate,
-    },
-    typescript: {
-      generateTsConfig: false,
-    },
-    publicAssets: [
-      {
-        baseURL: flow.options.app.buildAssetsDir,
-        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 ? flow.options.generate.crawler : false,
-      routes: []
-        .concat(flow.options._generate ? ['/_urls', ...flow.options.generate.routes] : []),
-    },
-    sourcemap: flow.options.sourcemap,
-    externals: {
-      inline: [
-        ...(flow.options.dev ? [] : ['eta', '@monkeyplus/', '@vue/', '@nuxt/', flow.options.buildDir]),
-        '@monkeyplus/flow/dist',
-      ],
-    },
-    alias: {
-
-      // Vue 3 mocks
-      'estree-walker': 'unenv/runtime/mock/proxy',
-      '@babel/parser': 'unenv/runtime/mock/proxy',
-      // Paths
-      '#paths': resolve(distDir, 'core/runtime/nitro/paths'),
-      // Shortcut to server main file
-      '#server': '#build/dist/server/server.mjs',
-      //* App dir
-      '#app': flow.options.appDir,
-
-      // Nuxt aliases
-      ...flow.options.alias,
-    },
-    rollupConfig: {
-      plugins: [],
-    },
-
-  });
-  await flow.callHook('nitro:config', nitroConfig);
-
-  // Base middleware
-  nitroConfig.handlers.unshift({
-    middleware: true,
-    handler: resolve(distDir, 'core/runtime/nitro/flow'),
-  });
-
-  // Extend nitro config with hook
-
-  const nitro = await createNitro(nitroConfig);
-
-  // Expose nitro to modules
-  await flow.callHook('nitro:init', nitro);
-
-  // Connect vfs storages
-  nitro.vfs = flow.vfs = nitro.vfs || flow.vfs || {};
-
-  // Connect hooks
-  flow.hook('close', () => nitro.hooks.callHook('close'));
-
-  // Register flow protection patterns
-  nitro.hooks.hook('rollup:before', (nitro) => {
-    const plugin = ImportProtectionPlugin.rollup({
-      rootDir: flow.options.rootDir,
-      patterns: [
-        ...['#app', /^#build(\/|$)/]
-          .map((p) => [p, 'Flow app aliases are not allowed in server routes.']) as [RegExp | string, string][],
-      ],
-    });
-    nitro.options.rollupConfig.plugins.push(plugin);
-  });
-  // Setup handlers
-  const devMidlewareHandler = dynamicEventHandler();
-  nitro.options.devHandlers.unshift({ handler: devMidlewareHandler });
-  nitro.options.devHandlers.push(...devHandlers);
-  nitro.options.handlers.unshift({
-    route: '/__flow_error',
-    lazy: true,
-    handler: resolve(distDir, 'core/runtime/nitro/renderer'),
-  });
-  // Add typed route responses
-  flow.hook('prepare:types', async(opts) => {
-    if (flow.options._prepare) {
-      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);
-    // console.log(nitro.options._config, nitro.vfs['#build/dist/server/server.mjs']);
-
-    if (flow.options.dev) {
-      await build(nitro);
-    }
-    else {
-      await prepare(nitro);
-
-      await copyPublicAssets(nitro);
-
-      await prerender(nitro);
-      if (!flow.options._generate) {
-        await build(nitro);
-      }
-      else {
-        // TODO: refactor to nuxt
-        const nitroDev = await createNitro({
-          ...nitro.options._config,
-          rootDir: nitro.options.rootDir,
-          logLevel: 0,
-          preset: 'nitro-prerender',
-        });
-        flow.server = nitroDev;
-
-        const distDir = resolve(flow.options.rootDir, 'dist');
-        if (!existsSync(distDir))
-          await fsp.symlink(nitro.options.output.publicDir, distDir, 'junction').catch(() => {});
-      }
-    }
-  });
-  if (flow.options.dev) {
-    flow.hook('build:compile', ({ compiler }) => {
-      compiler.outputFileSystem = { ...fsExtra, join } as any;
-    });
-    flow.hook('server:devMiddleware', (m) => { devMidlewareHandler.set(toEventHandler(m)); });
-    flow.server = createDevServer(nitro);
-    flow.hook('build:resources', () => {
-      flow.server.reload();
-    });
-    const waitUntilCompile = new Promise<void>((resolve) => nitro.hooks.hook('compiled', () => resolve()));
-    flow.hook('build:done', () => waitUntilCompile);
-  }
-}
-
-async function resolveHandlers(flow: Flow) {
-  const handlers: NitroEventHandler[] = [...flow.options.serverHandlers];
-  const devHandlers: NitroDevEventHandler[] = [...flow.options.devServerHandlers];
-
-  return {
-    handlers,
-    devHandlers,
-  };
-}

package/src/core/plugins/import-protection.ts

@@ -1,49 +0,0 @@
-import { createRequire } from 'node:module';
-import { createUnplugin } from 'unplugin';
-import { logger } from '@monkeyplus/flow-kit';
-import { isAbsolute, relative } from 'pathe';
-
-const _require = createRequire(import.meta.url);
-
-interface ImportProtectionOptions {
-  rootDir: string
-  patterns: [importPattern: string | RegExp, warning?: string][]
-}
-
-// export const vueAppPatterns = (flow: Flow) => [
-//   [/^(nuxt3|nuxt)$/, '`nuxt3`/`nuxt` cannot be imported directly. Instead, import runtime Nuxt composables from `#app` or `#imports`.'],
-//   [/nuxt\.config/, 'Importing directly from a `nuxt.config` file is not allowed. Instead, use runtime config or a module.'],
-//   [/(^|node_modules\/)@vue\/composition-api/],
-//   ...nuxt.options.modules.filter((m) => typeof m === 'string').map((m: string) =>
-//     [new RegExp(`^${escapeRE(m)}$`), 'Importing directly from module entry points is not allowed.']),
-//   ...[/(^|node_modules\/)@nuxt\/kit/, /^nitropack/]
-//     .map((i) => [i, 'This module cannot be imported in the Vue part of your app.']),
-//   [new RegExp(escapeRE(resolve(nuxt.options.srcDir, (nuxt.options.dir as any).server || 'server'))), 'Importing from server middleware is not allowed in the Vue part of your app.'],
-// ] as ImportProtectionOptions['patterns'];
-
-export const ImportProtectionPlugin = createUnplugin((options: ImportProtectionOptions) => {
-  const cache: Record<string, Map<string | RegExp, boolean>> = {};
-  return {
-    name: 'flow:import-protection',
-    enforce: 'pre',
-    resolveId(id, importer) {
-      const invalidImports = options.patterns.filter(([pattern]) => pattern instanceof RegExp ? pattern.test(id) : pattern === id);
-      let matched: boolean;
-      for (const match of invalidImports) {
-        cache[id] = cache[id] || new Map();
-        const [pattern, warning] = match;
-        // Skip if already warned
-        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;
-    },
-  };
-});

package/src/core/plugins/unctx.ts

@@ -1,31 +0,0 @@
-import type { Nuxt, NuxtApp, NuxtMiddleware } from '@monkeyplus/flow-schema';
-import { createTransformer } from 'unctx/transform';
-import { createUnplugin } from 'unplugin';
-
-export const UnctxTransformPlugin = (nuxt: Nuxt) => {
-  const transformer = createTransformer({
-    asyncFunctions: ['defineNuxtPlugin', 'defineNuxtRouteMiddleware'],
-  });
-
-  let app: NuxtApp | undefined;
-  let middleware: NuxtMiddleware[] = [];
-  nuxt.hook('app:resolve', (_app) => { app = _app; });
-  nuxt.hook('pages:middleware:extend', (_middlewares) => { middleware = _middlewares; });
-
-  return createUnplugin((options: { sourcemap?: boolean } = {}) => ({
-    name: 'unctx:transfrom',
-    enforce: 'post',
-    transformInclude(id) {
-      return Boolean(app?.plugins.find((i) => i.src === id) || middleware.find((m) => m.path === id));
-    },
-    transform(code, id) {
-      const result = transformer.transform(code);
-      if (result) {
-        return {
-          code: result.code,
-          map: options.sourcemap && result.magicString.generateMap({ source: id, includeContent: true }),
-        };
-      }
-    },
-  }));
-};

package/src/core/runtime/nitro/flow.ts

@@ -1,43 +0,0 @@
-import { defineEventHandler } from 'h3';
-// TODO: remove in node 18
-import 'node-fetch-native/polyfill';
-
-// @ts-ignore
-import { useRuntimeConfig } from '#internal/nitro';
-
-// @ts-ignore
-const getServerApp = cachedImport(() => import('#server'));
-
-const getFlowRenderer = cachedResult(async() => {
-  // Load server bundle
-  const createFlowApp = await getServerApp();
-
-  if (!createFlowApp) throw new Error('Server bundle is not available');
-  // Create renderer
-  return createFlowApp(useRuntimeConfig());
-});
-
-export default defineEventHandler(async({ context }) => {
-  const flow = await getFlowRenderer(); // const flow = module.default(_config);
-  context.flow = flow;
-  context.render = flow.render;
-});
-
-function _interopDefault(e: any) {
-  return e && typeof e === 'object' && 'default' in e ? e.default : e;
-}
-
-function cachedImport <M>(importer: () => Promise<M>) {
-  return cachedResult(() => importer().then(_interopDefault).then(_interopDefault)) as () => Promise<M>;
-}
-
-function cachedResult <T>(fn: () => Promise<T>): () => Promise<T> {
-  let res: Promise<T> | null = null;
-  // console.log(res);
-  return () => {
-    if (res === null)
-      res = fn().catch((err) => { res = null; throw err; });
-
-    return res;
-  };
-}

package/src/core/runtime/nitro/paths.ts

@@ -1,20 +0,0 @@
-import { joinURL } from 'ufo';
-// @ts-ignore
-import { useRuntimeConfig } from '#internal/nitro';
-
-export function baseURL(): string {
-  return useRuntimeConfig().app.baseURL;
-}
-
-export function buildAssetsDir(): string {
-  return useRuntimeConfig().app.buildAssetsDir;
-}
-
-export function buildAssetsURL(...path: string[]): string {
-  return joinURL(publicAssetsURL(), useRuntimeConfig().app.buildAssetsDir, ...path);
-}
-
-export function publicAssetsURL(...path: string[]): string {
-  const publicBase = useRuntimeConfig().app.cdnURL || useRuntimeConfig().app.baseURL;
-  return path.length ? joinURL(publicBase, ...path) : publicBase;
-}