@vixt/core 0.5.17 → 0.6.0

package/dist/node/index.mjs

@@ -1,457 +0,0 @@
-import { loadConfig } from 'c12';
-import fs from 'fs-extra';
-import path, { resolve, normalize } from 'pathe';
-import { env, cwd } from 'node:process';
-import { cac } from 'cac';
-import { findUpSync } from 'find-up';
-import { loadEnv as loadEnv$1 } from 'vite';
-import defu from 'defu';
-import { pathToFileURL } from 'mlly';
-import 'tsx/esm';
-import Checker from 'vite-plugin-checker';
-
-function defineVixtConfig(input) {
-  return input;
-}
-async function loadVixtConfig(opts) {
-  const result = await loadConfig({
-    name: "vixt",
-    rcFile: false,
-    ...opts
-  });
-  const { config, cwd } = result;
-  config.rootDir ??= cwd;
-  config.buildDir ??= resolve(config.rootDir, ".vixt");
-  config.buildTypesDir ??= resolve(config.buildDir, "types");
-  config.buildLayersDir ??= resolve(config.buildDir, "layers");
-  config.buildImportsDir ??= resolve(config.buildDir, "imports");
-  config.srcDir ??= resolve(config.rootDir, "src");
-  return result;
-}
-function applyLayers(layers, config) {
-  const { rootDir, buildLayersDir } = config;
-  return layers.filter((e) => e.cwd).map((layer) => {
-    const meta = layer.config?.meta ?? {};
-    const layerName = meta.name || layer.cwd.split("/").pop();
-    if (!isSamePath(layer.cwd, resolve(rootDir))) {
-      meta.alias = `#/layers/${layerName}`;
-    }
-    if (layer.cwd?.includes("node_modules")) {
-      const newCwd = resolve(buildLayersDir, layerName);
-      fs.removeSync(newCwd);
-      fs.copySync(layer.cwd, newCwd, {
-        filter: (src) => {
-          const nodeModulesPath = resolve(layer.cwd, "node_modules");
-          const tsConfigPath = resolve(layer.cwd, "tsconfig.json");
-          return !isSamePath(src, nodeModulesPath) && !isSamePath(src, tsConfigPath);
-        }
-      });
-      layer.cwd = newCwd;
-    }
-    layer.config ??= {};
-    layer.config.rootDir ??= layer.cwd;
-    layer.config.srcDir ??= resolve(layer.config.rootDir, "src");
-    return { ...layer, meta };
-  });
-}
-function isSamePath(a, b) {
-  return normalize(a) === normalize(b);
-}
-function resolveLayersDirs(layers = []) {
-  const dirs = {};
-  for (const layer of layers) {
-    const srcPath = layer.config.srcDir;
-    const isExist = fs.existsSync(srcPath);
-    const contents = isExist ? fs.readdirSync(srcPath) : [];
-    for (const content of contents) {
-      const fileOrDirPath = resolve(srcPath, content);
-      if (fs.statSync(fileOrDirPath).isDirectory()) {
-        dirs[content] ??= [];
-        dirs[content].push(fileOrDirPath);
-      }
-    }
-  }
-  return dirs;
-}
-
-function loadEnv(mode, envDir, prefixes) {
-  const parsedArgv = cac().parse();
-  mode = mode || parsedArgv.options.mode || parsedArgv.options.m || env.NODE_ENV;
-  return {
-    MODE: mode,
-    DEV: env.NODE_ENV !== "production",
-    PROD: env.NODE_ENV === "production",
-    ...loadWorkspaceEnv(mode, prefixes),
-    ...loadEnv$1(mode, envDir || cwd(), prefixes)
-  };
-}
-function findUpWorkspaceDir() {
-  const workspaceManifestLocation = findUpSync(["pnpm-workspace.yaml", "pnpm-workspace.yml"]);
-  return workspaceManifestLocation && path.dirname(workspaceManifestLocation);
-}
-function loadWorkspaceEnv(mode, prefixes) {
-  const workspaceDir = findUpWorkspaceDir();
-  return workspaceDir ? loadEnv$1(mode, workspaceDir, prefixes) : {};
-}
-
-function defineVitePlugin(pluginFn) {
-  return pluginFn;
-}
-function defineVixtModule(definition) {
-  if (typeof definition == "function")
-    return defineVixtModule({ setup: definition });
-  const module = definition;
-  function getOptions(inlineOptions, vixt) {
-    const configKey = module.meta?.configKey || module.meta?.name;
-    const configOptions = configKey ? vixt.options[configKey] : {};
-    const defaultOptions = typeof module.defaults === "function" ? module.defaults(vixt) : module.defaults;
-    const resolvedOptions = defu(inlineOptions, configOptions, defaultOptions);
-    if (configKey) {
-      vixt.options[configKey] = resolvedOptions;
-    }
-    return resolvedOptions;
-  }
-  function normalizedModule(inlineOptions, vixt) {
-    const options = getOptions(inlineOptions, vixt);
-    return module.setup?.(options, vixt);
-  }
-  normalizedModule.getMeta = () => module.meta;
-  normalizedModule.getOptions = getOptions;
-  return normalizedModule;
-}
-function installModule(module, inlineOptions, vixt) {
-  return module(inlineOptions, vixt);
-}
-async function applyLayerModules(layers) {
-  const { modules: modulesDirs = [] } = resolveLayersDirs(layers);
-  const modules = [];
-  for (const m of modulesDirs.reverse()) {
-    if (fs.existsSync(m)) {
-      const files = fs.readdirSync(m);
-      for (const f of files.filter((f2) => !f2.includes(".") || /\.[jt]s$/.test(f2))) {
-        try {
-          const fileURL = pathToFileURL(path.resolve(m, f));
-          const module = await import(
-            /* @vite-ignore */
-            fileURL
-          ).then((m2) => m2.default);
-          modules.push(module);
-        } catch (error) {
-          console.error("[VixtModule Error]:", error);
-        }
-      }
-    }
-  }
-  return modules;
-}
-
-const name$1 = "vixt:config";
-const config = defineVixtModule({
-  meta: { name: name$1 },
-  setup(_, vixt) {
-    let env;
-    return {
-      name: name$1,
-      enforce: "pre",
-      config(config2) {
-        const { rootDir, buildDir, srcDir, app } = vixt.options;
-        const defaultAlias = {
-          "@": srcDir,
-          "~": srcDir,
-          "@@": rootDir,
-          "~~": rootDir
-        };
-        for (const layer of vixt._layers) {
-          if (layer.meta?.alias) {
-            defaultAlias[layer.meta.alias] = layer.cwd;
-          }
-        }
-        defaultAlias["#"] = buildDir;
-        env = loadEnv(config2.mode, config2.envDir, config2.envPrefix);
-        const defineEnv = Object.fromEntries(
-          Object.entries(env).filter(([k]) => !["MODE", "DEV", "PROD"].includes(k)).map(([k, v]) => [`import.meta.env.${k}`, JSON.stringify(v)])
-        );
-        return {
-          root: rootDir,
-          base: app?.baseURL,
-          resolve: {
-            alias: defaultAlias
-          },
-          define: defineEnv
-        };
-      },
-      configResolved(config2) {
-        Object.assign(config2.env, { ...env, ...config2.env });
-        vixt.options.vite = config2;
-      },
-      configureServer(server) {
-        const mode = server.config.mode;
-        const watchFiles = [];
-        const configFiles = vixt._layers.map((layer) => layer.configFile).filter((e) => !e.includes("node_modules"));
-        const modulesDirs = vixt._layers.map((layer) => path.resolve(layer.config.srcDir, "modules")).filter((e) => !e.includes("node_modules"));
-        watchFiles.push(...configFiles, ...modulesDirs);
-        const workspaceManifestLocation = findUpSync(["pnpm-workspace.yaml", "pnpm-workspace.yml"]);
-        if (workspaceManifestLocation) {
-          const workspaceDir = path.dirname(workspaceManifestLocation);
-          const envFiles = [`${workspaceDir}/.env`, `${workspaceDir}/.env.local`, `${workspaceDir}/.env.${mode}`, `${workspaceDir}/.env.${mode}.local`];
-          watchFiles.push(...envFiles);
-        }
-        server.watcher.add(watchFiles);
-        server.watcher.on("all", (_2, file) => {
-          const match = watchFiles.some((e) => path.normalize(file).match(e));
-          if (match)
-            server.restart();
-        });
-      }
-    };
-  }
-});
-
-function generateTsConfig(options, vixt) {
-  const { buildDir } = vixt.options;
-  const codePath = path.resolve(buildDir, "tsconfig.json");
-  const code = JSON.stringify(options.tsConfig, null, 2);
-  fs.outputFileSync(codePath, code);
-}
-function generateVixtDts(options, vixt) {
-  const { buildDir } = vixt.options;
-  const codePath = path.resolve(buildDir, "vixt.d.ts");
-  const code = options.references?.map((reference) => {
-    if (typeof reference === "string") {
-      return `/// <reference path="${reference}" />`;
-    } else if (typeof reference === "object" && reference.path && reference.content) {
-      fs.outputFileSync(path.resolve(buildDir, reference.path), reference.content);
-      return `/// <reference path="${reference.path}" />`;
-    } else {
-      return "";
-    }
-  }).concat("export {}").join("\n");
-  if (code)
-    fs.outputFileSync(codePath, code);
-}
-function genarateShim(options, vixt) {
-  if (!options.shim)
-    return;
-  const { buildTypesDir } = vixt.options;
-  const code = `
-declare module '*.vue' {
-  import type { DefineComponent } from 'vue'
-
-  const component: DefineComponent
-  export default component
-}
-`;
-  const codePath = path.resolve(buildTypesDir, "vue-shim.d.ts");
-  fs.outputFileSync(codePath, code);
-}
-function generateEnvDts(env, vixt) {
-  const { buildTypesDir } = vixt.options;
-  const codePath = path.resolve(buildTypesDir, "vite-env.d.ts");
-  const values = Object.entries(env).map(([key, value]) => `/** ${key}=${value} */
-  ${key}: ${typeof value}`).join("\n  ");
-  const code = `interface ImportMeta {
-  readonly env: ImportMetaEnv
-}
-interface ImportMetaEnv {
-  ${values}
-}
-`;
-  fs.outputFileSync(codePath, code);
-}
-const name = "vixt:typescript";
-const typescript = defineVixtModule({
-  meta: { name, configKey: "typescript" },
-  defaults(vixt) {
-    const { rootDir, srcDir } = vixt.options;
-    const rootAlias = {};
-    if (rootDir)
-      rootAlias["@@/*"] = rootAlias["~~/*"] = [`${rootDir}/*`];
-    const srcAlias = {};
-    if (srcDir)
-      srcAlias["@/*"] = srcAlias["~/*"] = [`${srcDir}/*`];
-    const layersDirs = [];
-    const layersAlias = {};
-    for (const layer of vixt._layers) {
-      layersDirs.push(layer.cwd);
-      if (layer.meta?.alias)
-        layersAlias[`${layer.meta.alias}/*`] = [`${layer.cwd}/*`];
-    }
-    return {
-      tsConfig: {
-        extends: "@vue/tsconfig/tsconfig.dom.json",
-        compilerOptions: {
-          baseUrl: rootDir,
-          paths: { "#/*": ["./*"], ...layersAlias, ...rootAlias, ...srcAlias },
-          types: ["vite/client"]
-        },
-        include: ["./**/*", ...layersDirs]
-      },
-      typeCheck: {
-        enableBuild: false,
-        overlay: { initialIsOpen: false }
-      }
-    };
-  },
-  setup(options, vixt) {
-    return [
-      {
-        name,
-        configResolved(config) {
-          generateTsConfig(options, vixt);
-          generateVixtDts(options, vixt);
-          genarateShim(options, vixt);
-          generateEnvDts(config.env, vixt);
-        }
-      },
-      Checker(options.typeCheck ?? {})
-    ];
-  }
-});
-
-function generateAppConfig(vixt) {
-  const { buildImportsDir } = vixt.options;
-  let appConfigsImportTemplate = "";
-  let appConfigsMergeTemplate = "";
-  let i = 0;
-  for (const layer of vixt._layers) {
-    const appConfigPath = path.resolve(layer.config.srcDir, "app.config.ts");
-    if (fs.existsSync(appConfigPath)) {
-      const appConfigName = `__app_config_${i}`;
-      appConfigsImportTemplate += `import ${appConfigName} from '${appConfigPath}'
-`;
-      appConfigsMergeTemplate += `${appConfigName}, `;
-      i++;
-    }
-  }
-  const globalAppConfigKey = "__VIXT_APP_CONFIG";
-  const appConfigTemplate = `
-import { defu } from 'defu'
-${appConfigsImportTemplate}
-const appConfig = defu(${appConfigsMergeTemplate}{})
-globalThis.${globalAppConfigKey} = appConfig
-`;
-  fs.outputFileSync(path.resolve(buildImportsDir, `app.config.ts`), `// Generated by Vixt
-// @ts-nocheck
-import type { VixtAppConfig } from '@vixt/core/client'
-
-export const useAppConfig = () => globalThis.${globalAppConfigKey} as VixtAppConfig
-`);
-  return appConfigTemplate;
-}
-
-function generateClient(vixt) {
-  const { buildImportsDir } = vixt.options;
-  fs.outputFileSync(
-    path.resolve(buildImportsDir, `client.ts`),
-    `// Generated by Vixt
-export { defineAppConfig, defineVixtPlugin } from '@vixt/core/client'
-`
-  );
-}
-
-function generateCss(options) {
-  const cssTemplate = options?.css?.map((css) => `import '${css}'`).join("\n") ?? "";
-  return cssTemplate;
-}
-
-function resolveHeadTag(tag, attrs) {
-  const attrsStr = Object.entries(attrs).filter(([k]) => k !== "children").map(([k, v]) => `${k}="${v}"`).join(" ");
-  return attrs?.children ? `<${tag} ${attrsStr}>${attrs.children}</${tag}>` : `<${tag} ${attrsStr} />`;
-}
-function generateIndexHtml(options, vixt) {
-  const { buildDir, rootDir, srcDir } = vixt.options;
-  const indexHtmlPath = path.resolve(rootDir, "index.html");
-  if (!fs.existsSync(indexHtmlPath))
-    fs.outputFileSync(indexHtmlPath, `<!-- Generated by Vixt -->
-<!-- This file transform from '${path.basename(buildDir)}/index.html' -->
-`);
-  const { head = {}, rootTag, rootId, entryFile } = options;
-  const heads = Object.entries(head);
-  const headTemplate = heads.filter(([k]) => k !== "noscript").map(([tag, attrs]) => attrs.map((e) => resolveHeadTag(tag, e)).reverse()).flat().join("\n");
-  const noscriptTemplate = heads.filter(([k]) => k === "noscript").map(([tag, attrs]) => attrs.map((e) => resolveHeadTag(tag, e)).reverse()).flat().join("\n");
-  let { loadingTemplate = "" } = options;
-  if (!loadingTemplate) {
-    for (const layer of vixt._layers) {
-      const loadingTemplatePath = path.resolve(layer.cwd, "loading.html");
-      if (fs.existsSync(loadingTemplatePath)) {
-        loadingTemplate = fs.readFileSync(loadingTemplatePath, "utf-8");
-        break;
-      }
-    }
-  }
-  const entryFilePath = /&\.|\//.test(entryFile ?? "") ? entryFile : `${srcDir.replace(rootDir, "")}/${entryFile}`;
-  const code = `<!DOCTYPE html>
-<html>
-  <head>
-${headTemplate}
-  </head>
-  <body>
-    <${rootTag} id="${rootId}">
-${loadingTemplate}
-    </${rootTag}>
-    <script type="module" src="${entryFilePath}"><\/script>
-${noscriptTemplate}
-  </body>
-</html>
-`;
-  fs.outputFileSync(path.resolve(buildDir, "index.html"), code);
-  return code;
-}
-
-function generatePlugins(vixt) {
-  const { plugins: pluginsDirs = [] } = resolveLayersDirs(vixt._layers);
-  let pluginsImportTemplate = "";
-  let pluginsMergeTemplate = "";
-  let i = 0;
-  for (const pluginsDir of pluginsDirs.reverse()) {
-    const files = fs.existsSync(pluginsDir) ? fs.readdirSync(pluginsDir) : [];
-    for (const f of files.filter((f2) => /[jt]sx?$/.test(f2))) {
-      const p = path.resolve(pluginsDir, f);
-      const pluginName = `__plugin_${i}`;
-      pluginsImportTemplate += `import ${pluginName} from '${p}'
-`;
-      pluginsMergeTemplate += `${pluginName}, `;
-      i++;
-    }
-  }
-  const pluginsTemplate = `
-${pluginsImportTemplate}
-const plugins = [${pluginsMergeTemplate}]
-function usePlugins(options) {
-  for (const plugin of plugins) {
-    typeof plugin === 'function' && plugin(options)
-  }
-}
-`;
-  return pluginsTemplate;
-}
-
-async function loadVixt(opts) {
-  const result = await loadVixtConfig(defu(opts, {
-    defaults: {
-      modules: [config, typescript]
-    }
-  }));
-  const parsedArgv = cac().parse();
-  const isForce = !!parsedArgv.options.force;
-  if (isForce) {
-    fs.removeSync(result.config.buildDir);
-  }
-  result.layers = applyLayers(result.layers ?? [], result.config);
-  const layerModules = await applyLayerModules(result.layers ?? []);
-  const vixt = {
-    options: result.config,
-    _layers: result.layers ?? [],
-    _modules: [...result.config.modules ?? [], ...layerModules]
-  };
-  return vixt;
-}
-function createVixtPlugin(loadOptions) {
-  return defineVitePlugin(async (vixtOptions) => {
-    const vixt = await loadVixt(defu({ defaults: vixtOptions }, loadOptions));
-    const plugins = vixt._modules.map((module) => module({}, vixt));
-    return plugins;
-  });
-}
-
-export { applyLayerModules, applyLayers, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, findUpWorkspaceDir, generateAppConfig, generateClient, generateCss, generateIndexHtml, generatePlugins, installModule, isSamePath, loadEnv, loadVixt, loadVixtConfig, loadWorkspaceEnv, resolveLayersDirs, typescript };