@fastkit/plugboy 0.3.0 → 1.0.0-next.1

package/dist/chunk-IDJLTVUE.mjs

@@ -1,1619 +0,0 @@
-// src/types/hook.ts
-function createHooksDefaults() {
-  return {
-    setupWorkspace: [],
-    createWorkspace: [],
-    preparePackageJSON: [],
-    onSuccess: []
-  };
-}
-
-// src/types/dts.ts
-function normalizeDTSPreserveTypeTarget(target) {
-  const { from, typeName } = target;
-  return {
-    from: typeof from === "string" ? new RegExp(`${from}`, "g") : from,
-    typeName
-  };
-}
-function normalizeDTSPreserveTypeSettings(settings) {
-  return {
-    ...settings,
-    targets: settings.targets.map(normalizeDTSPreserveTypeTarget)
-  };
-}
-function normalizeDTSSettings(settings) {
-  const {
-    inline = false,
-    preserveType = [],
-    normalizers = []
-  } = settings || {};
-  return {
-    inline,
-    preserveType: preserveType.map(normalizeDTSPreserveTypeSettings),
-    normalizers
-  };
-}
-function mergeDTSSettingsList(...settingsList) {
-  const merged = {};
-  settingsList.forEach((settings) => {
-    if (!settings) return;
-    const { inline, preserveType, normalizers } = settings;
-    if (inline !== void 0) merged.inline = inline;
-    if (preserveType) {
-      merged.preserveType = merged.preserveType || [];
-      merged.preserveType.push(...preserveType);
-    }
-    if (normalizers) {
-      merged.normalizers = merged.normalizers || [];
-      merged.normalizers.push(...normalizers);
-    }
-  });
-  return normalizeDTSSettings(merged);
-}
-
-// src/types/css.ts
-function resolveOptimizeCSSOptions(options) {
-  const resolved = {};
-  const { layer = true, media = true, combineRules, cssnano = true } = options;
-  if (layer !== false) {
-    resolved.layer = layer === true ? {} : layer;
-  }
-  if (media !== false) {
-    resolved.media = media === true ? {} : media;
-  }
-  if (combineRules) {
-    resolved.combineRules = combineRules;
-  }
-  if (cssnano !== false) {
-    resolved.cssnano = cssnano === true ? { preset: ["default", { normalizeWhitespace: false }] } : cssnano;
-  }
-  return resolved;
-}
-
-// src/types/workspace.ts
-var WORKSPACE_REQUIRED_FIELDS = ["name", "version"];
-var TSUP_SYNC_OPTIONS = [
-  "define",
-  "noExternal",
-  "external",
-  "replaceNodeEnv",
-  "skipNodeModulesBundle"
-];
-
-// src/types/project.ts
-var PROJECT_REQUIRED_FIELDS = ["name"];
-
-// src/utils/general.ts
-function isPromise(obj) {
-  return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
-}
-async function resolveListable(raw) {
-  const result = [];
-  const list = Array.isArray(raw) ? raw : [raw];
-  for (let row of list) {
-    if (isPromise(row)) {
-      row = await row;
-    }
-    if (!row) continue;
-    if (Array.isArray(row)) {
-      result.push(...await resolveListable(row));
-      continue;
-    }
-    result.push(row);
-  }
-  return result;
-}
-
-// src/utils/file.ts
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-function getFilename(importMetaURL) {
-  return fileURLToPath(importMetaURL);
-}
-function getDirname(importMetaURL) {
-  return path.dirname(getFilename(importMetaURL));
-}
-var FILE_NOT_FOUND_EXCEPTION_CODES = ["ENOTDIR", "ENOENT"];
-function isFileNotFoundException(source) {
-  return !!source && typeof source === "object" && FILE_NOT_FOUND_EXCEPTION_CODES.includes(
-    source.code
-  );
-}
-async function pathExists(target, type) {
-  try {
-    const stats = await fs.promises.stat(target);
-    if (!type) return true;
-    return type === "file" ? stats.isFile() : stats.isDirectory();
-  } catch (err) {
-    if (isFileNotFoundException(err)) return false;
-    throw err;
-  }
-}
-function normalizeFileMatcher(matcher) {
-  if (typeof matcher === "function") {
-    return matcher;
-  }
-  if (typeof matcher === "string") {
-    return (file) => file.name.includes(matcher);
-  }
-  return (file) => matcher.test(file.name);
-}
-async function findFile(dir, matcher, recursive = true) {
-  const files = await fs.promises.readdir(dir, { withFileTypes: true });
-  const _matcher = normalizeFileMatcher(matcher);
-  const dirs = recursive ? [] : void 0;
-  for (const file of files) {
-    if (dirs && file.isDirectory()) {
-      dirs.push(file);
-      continue;
-    }
-    if (await _matcher(file, dir)) {
-      return path.join(dir, file.name);
-    }
-  }
-  if (dirs) {
-    for (const subDir of dirs) {
-      const hit = await findFile(
-        path.join(dir, subDir.name),
-        _matcher,
-        recursive
-      );
-      if (hit) return hit;
-    }
-  }
-}
-var FIND_CONFIG_OR_RE = /\(.+?\)/g;
-function parseFindConfigFileName(source) {
-  const matches = source.match(FIND_CONFIG_OR_RE);
-  if (!matches) return [source];
-  return matches.map((matched) => {
-    const parts = matched.slice(1, matched.length - 1).split("|");
-    return parts.map((part) => {
-      const chunk = source.replace(matched, part);
-      return parseFindConfigFileName(chunk);
-    }).flat();
-  }).flat();
-}
-function parseRawFindConfigFileName(source) {
-  return Array.isArray(source) ? source.map(parseFindConfigFileName).flat() : parseFindConfigFileName(source);
-}
-async function findConfig(fileNameOrSettings, dir = process.cwd(), currentDepth = 0) {
-  const settings = typeof fileNameOrSettings === "object" && !Array.isArray(fileNameOrSettings) ? fileNameOrSettings : { fileName: fileNameOrSettings };
-  const { fileName, test, depth = 10, allowMissing } = settings;
-  const fileNames = parseRawFindConfigFileName(fileName);
-  if (depth && currentDepth === depth) {
-    if (allowMissing) return null;
-    throw new Error(
-      `Failed to retrieve the "${fileName}" file because the maximum depth was reached.`
-    );
-  }
-  const next = (err) => {
-    const nextDir = path.dirname(dir);
-    if (nextDir !== dir) {
-      return findConfig(settings, nextDir, currentDepth + 1);
-    }
-    if (allowMissing) return null;
-    throw err || new Error(`missing config "${fileName}"`);
-  };
-  const result = await (async () => {
-    for (const fileName2 of fileNames) {
-      try {
-        const _path = path.join(dir, fileName2);
-        const code = await fs.promises.readFile(_path, "utf-8");
-        const _result = {
-          fileName: fileName2,
-          dir,
-          path: _path,
-          code
-        };
-        if (!test || test(_result)) {
-          return _result;
-        }
-      } catch (err) {
-        if (!isFileNotFoundException(err)) {
-          throw err;
-        }
-      }
-    }
-  })();
-  if (!result) {
-    return next();
-  }
-  return result;
-}
-function _rmrf(_path) {
-  return fs.promises.rm(_path, {
-    recursive: true,
-    force: true
-  }).catch((err) => {
-    if (isFileNotFoundException(err)) return;
-    throw err;
-  });
-}
-async function rmrf(...paths) {
-  await Promise.all(paths.map((_path) => _rmrf(_path)));
-}
-function copyDirSync(srcDir, destDir) {
-  if (!fs.existsSync(srcDir)) return;
-  fs.mkdirSync(destDir, { recursive: true });
-  for (const file of fs.readdirSync(srcDir)) {
-    const srcFile = path.resolve(srcDir, file);
-    if (srcFile === destDir) {
-      continue;
-    }
-    const destFile = path.resolve(destDir, file);
-    const stat = fs.statSync(srcFile);
-    if (stat.isDirectory()) {
-      copyDirSync(srcFile, destFile);
-    } else {
-      fs.copyFileSync(srcFile, destFile);
-    }
-  }
-}
-
-// src/utils/expose.ts
-import path2 from "path";
-import { glob } from "glob";
-function resolveRawExposeEntriesSettings(rawSettings) {
-  return typeof rawSettings === "string" ? { dir: rawSettings } : rawSettings;
-}
-var TRIM_PATH_RE = /(^\.?\/|\/$)/g;
-var TRIM_EXT_RE = /\.ts$/;
-async function exposeEntries(rawSettings) {
-  const { dir: _dir, prefix: _prefix } = resolveRawExposeEntriesSettings(rawSettings);
-  const dir = path2.resolve(_dir);
-  const prefix = _prefix ? _prefix.replace(TRIM_PATH_RE, "") : "";
-  const pattern = path2.join(dir, "**/*.ts");
-  const files = await glob(pattern);
-  const entries = {};
-  for (const file of files) {
-    const id = (prefix + file.replace(dir, "")).replace(TRIM_EXT_RE, "").replace(TRIM_PATH_RE, "");
-    entries[id] = {
-      src: file
-    };
-  }
-  return entries;
-}
-
-// src/utils/project.ts
-import { bundleRequire } from "bundle-require";
-
-// src/constants.ts
-var PROJECT_CONFIG_BASENAME = "plugboy.project";
-var WORKSPACE_CONFIG_BASENAME = "plugboy.workspace";
-var PACKAGE_JSON_FILENAME = "package.json";
-var WORKSPACE_SPEC_PREFIX = "workspace:";
-var SEARCH_BUNDLE_EXTENSIONS_MATCH = "(ts|mjs|js|json)";
-
-// src/utils/plugin.ts
-async function resolveUserPluginOptions(pluginOptions) {
-  if (!pluginOptions) return [];
-  return resolveListable(pluginOptions);
-}
-function definePlugin(options) {
-  return options;
-}
-async function extractProjectPlugins(searchDir) {
-  const config = await loadProjectConfig(searchDir);
-  return config ? config.plugins : [];
-}
-async function findProjectPlugin(pluginName, searchDir) {
-  const plugins = await extractProjectPlugins(searchDir);
-  return plugins.find((plugin) => plugin.name === pluginName);
-}
-
-// src/utils/project.ts
-function isProjectPackageJson(json) {
-  return !!json.private && PROJECT_REQUIRED_FIELDS.every((filed) => !!json[filed]);
-}
-async function resolveUserProjectConfig(userConfig) {
-  const {
-    workspacesDir = "packages",
-    scripts = [],
-    peerDependencies = {},
-    tsconfig,
-    readme = (json) => `# ${json.name}
-`,
-    plugins,
-    optimizeCSS = true
-  } = userConfig;
-  return {
-    workspacesDir,
-    scripts: Array.isArray(scripts) ? scripts : [{ name: "", scripts }],
-    peerDependencies,
-    tsconfig,
-    readme,
-    plugins: await resolveUserPluginOptions(plugins),
-    optimizeCSS: optimizeCSS === true ? {} : optimizeCSS
-  };
-}
-function defineProjectConfig(config) {
-  return resolveUserProjectConfig(config);
-}
-async function loadProjectConfig(searchDir, depth) {
-  const hit = await findConfig(
-    {
-      fileName: `${PROJECT_CONFIG_BASENAME}.${SEARCH_BUNDLE_EXTENSIONS_MATCH}`,
-      depth,
-      allowMissing: true
-    },
-    searchDir
-  );
-  const userConfig = hit ? (await bundleRequire({
-    filepath: hit.path
-  })).mod.default : {};
-  return resolveUserProjectConfig(await userConfig);
-}
-
-// src/utils/workspace.ts
-import { bundleRequire as bundleRequire2 } from "bundle-require";
-function isWorkspacePackageJson(json) {
-  return !json.private && WORKSPACE_REQUIRED_FIELDS.every((filed) => !!json[filed]);
-}
-function resolveRawWorkspaceEntry(entry) {
-  const { src, css } = typeof entry === "string" ? { src: entry } : entry;
-  return {
-    src,
-    css: css || src.endsWith(".css") || src.endsWith(".scss")
-  };
-}
-function resolveRawWorkspaceEntries(entries) {
-  if (!entries) return {};
-  return Object.fromEntries(
-    Object.entries(entries).map(([name, raw]) => [
-      name,
-      resolveRawWorkspaceEntry(raw)
-    ])
-  );
-}
-async function resolveUserWorkspaceConfig(userConfig) {
-  const {
-    ignoreProjectConfig = false,
-    entries,
-    plugins,
-    optimizeCSS = true
-  } = userConfig;
-  return {
-    ...userConfig,
-    ignoreProjectConfig,
-    entries: resolveRawWorkspaceEntries(entries),
-    plugins: await resolveUserPluginOptions(plugins),
-    optimizeCSS: optimizeCSS === true ? {} : optimizeCSS
-  };
-}
-function defineWorkspaceConfig(config) {
-  return resolveUserWorkspaceConfig(config);
-}
-async function loadWorkspaceConfig(searchDir, depth) {
-  const hit = await findConfig(
-    {
-      fileName: `${WORKSPACE_CONFIG_BASENAME}.${SEARCH_BUNDLE_EXTENSIONS_MATCH}`,
-      depth,
-      allowMissing: true
-    },
-    searchDir
-  );
-  const userConfig = hit ? (await bundleRequire2({
-    filepath: hit.path
-  })).mod.default : {};
-  return resolveUserWorkspaceConfig(await userConfig);
-}
-
-// src/utils/hook.ts
-async function resolveUserHooks(...userHooks) {
-  const hooks = createHooksDefaults();
-  if (!userHooks) return hooks;
-  for (const userHook of userHooks) {
-    if (!userHook) continue;
-    for (const [hookName, _hooks] of Object.entries(userHook)) {
-      if (hooks) {
-        hooks[hookName].push(...await resolveListable(_hooks));
-      }
-    }
-  }
-  return hooks;
-}
-function buildHooks(resolvedHooks) {
-  const hooks = {};
-  Object.entries(resolvedHooks).forEach(([hookName, fns]) => {
-    hooks[hookName] = async (...args) => {
-      const results = [];
-      for (const fn of fns) {
-        results.push(await fn(...args));
-      }
-      return results;
-    };
-  });
-  return hooks;
-}
-
-// src/path.ts
-import path3 from "path";
-import fs2 from "fs";
-var Path = class _Path {
-  _value;
-  _stats;
-  get value() {
-    return this._value;
-  }
-  set value(value) {
-    const _value = path3.resolve(value);
-    if (_value === this._value) return;
-    this._value = path3.resolve(value);
-    delete this._stats;
-  }
-  get dirname() {
-    return path3.dirname(this.value);
-  }
-  get basename() {
-    return path3.basename(this.value);
-  }
-  get extname() {
-    return path3.extname(this.value);
-  }
-  get stats() {
-    let { _stats } = this;
-    if (!_stats) {
-      _stats = fs2.statSync(this.value);
-      this._stats = _stats;
-    }
-    return _stats;
-  }
-  get isDirectory() {
-    return this.stats.isDirectory;
-  }
-  get isFile() {
-    return this.stats.isFile;
-  }
-  constructor(value) {
-    this._value = path3.resolve(value);
-  }
-  toString() {
-    return this.value;
-  }
-  valueOf() {
-    return this.value;
-  }
-  toJSON() {
-    return this.value;
-  }
-  relative(to) {
-    return new _Path(path3.relative(this.value, to));
-  }
-  join(...paths) {
-    return new _Path(path3.join(this.value, ...paths));
-  }
-  resolve(...paths) {
-    return new _Path(path3.resolve(this.value, ...paths));
-  }
-  _join(...paths) {
-    const _paths = paths.filter((_path) => !!_path);
-    return _paths.length ? path3.join(this.value, ..._paths) : this.value;
-  }
-  async readdir(...paths) {
-    const dir = this._join(...paths);
-    const files = await fs2.promises.readdir(dir);
-    return files.map((file) => new _Path(path3.join(dir, file)));
-  }
-  readFile(pathAppend, defaults) {
-    return new Promise((resolve, reject) => {
-      fs2.readFile(this._join(pathAppend), "utf-8", (err, data) => {
-        if (err) {
-          if (defaults !== void 0 && isFileNotFoundException(err)) {
-            return resolve(defaults);
-          }
-          return reject(err);
-        }
-        resolve(data);
-      });
-    });
-  }
-  async readJSON(pathAppend, defaults) {
-    try {
-      const file = await this.readFile(pathAppend);
-      return JSON.parse(file);
-    } catch (err) {
-      if (defaults === void 0) {
-        throw err;
-      }
-      return defaults;
-    }
-  }
-};
-
-// src/package.ts
-import fs3 from "fs/promises";
-import path4 from "path";
-async function getProjectPackageJson(searchDir, allowMissing) {
-  const hit = await findConfig(
-    {
-      fileName: PACKAGE_JSON_FILENAME,
-      allowMissing,
-      test: (result) => isProjectPackageJson(JSON.parse(result.code))
-    },
-    searchDir
-  );
-  if (!hit) {
-    if (allowMissing) return null;
-    throw new Error("missing project package.");
-  }
-  return {
-    dir: new Path(hit.dir),
-    json: JSON.parse(hit.code)
-  };
-}
-async function getWorkspacePackageJson(searchDir, allowMissing) {
-  const hit = await findConfig(
-    {
-      fileName: PACKAGE_JSON_FILENAME,
-      allowMissing,
-      test: (result) => isWorkspacePackageJson(JSON.parse(result.code))
-    },
-    searchDir
-  );
-  if (!hit) {
-    if (allowMissing) return null;
-    throw new Error("missing workspace package.");
-  }
-  return {
-    dir: new Path(hit.dir),
-    json: JSON.parse(hit.code)
-  };
-}
-async function findWorkspacePackages(dir) {
-  const results = [];
-  const searchDir = path4.resolve(dir);
-  const dirs = await fs3.readdir(searchDir);
-  const pkgs = await Promise.all(
-    dirs.map(
-      (dirName) => getWorkspacePackageJson(path4.join(searchDir, dirName), true)
-    )
-  );
-  pkgs.forEach((pkg) => {
-    pkg && results.push(pkg);
-  });
-  return results;
-}
-
-// src/workspace/builder.ts
-import { build } from "tsup";
-import fs4 from "fs/promises";
-import path6 from "path";
-import { glob as glob2 } from "glob";
-
-// src/workspace/dts.ts
-import { execa } from "execa";
-import path5 from "path";
-async function emitDTS(opts = {}) {
-  const { cwd = process.cwd(), outDir = path5.join(cwd, "dist/dts") } = opts;
-  await execa(
-    "tsc",
-    [
-      "--declaration true",
-      "--skipLibCheck",
-      "--noEmit false",
-      "--emitDeclarationOnly",
-      `--outDir ${outDir}`
-    ],
-    { cwd, shell: true, stdio: "inherit" }
-  );
-}
-
-// src/workspace/builder.ts
-var SHEBANG_MATCH_RE = /^(#!.+?)\n/;
-function safeRemoveCSSMap(cssFilePath) {
-  const mapFilePath = `${cssFilePath}.map`;
-  return fs4.rm(mapFilePath, { force: true });
-}
-var SOURCE_MAPPING_URL_COMMENT_RE = /\/\*# sourceMappingURL=.+? \*\//g;
-var allLayerDefRe = /(^|\n)@layer\s+([a-zA-Z\d\-_$. ,]+);/g;
-var layerDefTrimRe = /((^|\n)@layer\s+|;)/g;
-async function getPostcss(options) {
-  const { layer, media, combineRules, cssnano } = options;
-  const [postcss, _layer, _media, _combineRules, _cssnano] = await Promise.all([
-    import("postcss").then((mod) => mod.default),
-    layer && import("./optimize-layer-Q35C25P4.mjs").then(
-      (mod) => mod.OptimizeLayer(layer)
-    ),
-    media && import("./optimize-media-ZZWDHLLV.mjs").then(
-      (mod) => mod.OptimizeMedia(media)
-    ),
-    combineRules && import("./combine-rules-2CRG6D4B.mjs").then(
-      (mod) => mod.CombineRules(combineRules)
-    ),
-    cssnano && import("cssnano").then((mod) => mod.default(cssnano))
-  ]);
-  const plugins = [];
-  _layer && plugins.push(_layer);
-  _media && plugins.push(_media);
-  _combineRules && plugins.push(_combineRules);
-  _cssnano && plugins.push(_cssnano);
-  return postcss(plugins);
-}
-var Builder = class {
-  workspace;
-  _tsupOptions;
-  _postcssCache;
-  get entry() {
-    return this.workspace.entry;
-  }
-  get dts() {
-    return this.workspace.dts;
-  }
-  constructor(workspace) {
-    this.workspace = workspace;
-  }
-  async tsupOptions(overrides) {
-    let { _tsupOptions } = this;
-    if (_tsupOptions) return _tsupOptions;
-    const { entry, dts } = this;
-    const esbuildPlugins = await this.workspace.getESBuildPlugins();
-    _tsupOptions = {
-      publicDir: true,
-      format: ["esm"],
-      dts: dts.inline ? false : {
-        resolve: ["@fastkit/plugboy"]
-      },
-      treeshake: true,
-      esbuildPlugins,
-      entry,
-      splitting: true,
-      outExtension: ({ format }) => ({
-        js: `.mjs`
-      }),
-      sourcemap: true,
-      clean: true,
-      ...overrides
-    };
-    for (const opt of TSUP_SYNC_OPTIONS) {
-      _tsupOptions[opt] = this.workspace.config[opt];
-    }
-    const PLUGBOY_VAR_ENVS = {
-      __PLUGBOY_DEV__: "false",
-      __PLUGBOY_STUB__: "false"
-    };
-    const DEFINE_VAR_INJECTS = Object.fromEntries(
-      Object.keys(PLUGBOY_VAR_ENVS).map((envName) => [envName, `$$${envName}`])
-    );
-    _tsupOptions.define = {
-      ..._tsupOptions.define,
-      ...DEFINE_VAR_INJECTS
-    };
-    const PLUGBOY_VAR_ENVS_BANNER = [
-      ...Object.entries(PLUGBOY_VAR_ENVS).map(
-        ([envName, variable]) => `const $$${envName} = /* @PLUGBOY:${envName}:start */${variable}/* @PLUGBOY:${envName}:end */;`
-      ),
-      `const $$__PLUGBOY_RELATIVE_PATH_FOR_WORKSPACE__ = '@@__PLUGBOY_RELATIVE_PATH_FOR_WORKSPACE__';`
-    ].join("\n");
-    const ENV_FN_INJECTS = `
-import __plugboy_path from 'node:path';
-import { fileURLToPath as __plugboy_fileURLToPath } from 'node:url';
-
-function __plugboyFilename() {
-  return __plugboy_fileURLToPath(import.meta.url);
-}
-
-function __plugboyDirname() {
-  return __plugboy_path.dirname(__plugboyFilename());
-}
-
-function __plugboyWorkspaceDir(...paths) {
-  return __plugboy_path.join(__plugboy_path.resolve(__plugboyDirname(), $$__PLUGBOY_RELATIVE_PATH_FOR_WORKSPACE__), ...paths);
-}
-
-function __plugboySrcDir(...paths) {
-  return __plugboy_path.join(__plugboyWorkspaceDir(), 'src', ...paths);
-}
-
-function __plugboyPublicDir(...paths) {
-  return __plugboy_path.join(__plugboyWorkspaceDir(), 'dist', ...paths);
-}
-    `.trim();
-    const banner = { ..._tsupOptions.banner };
-    banner.js = `${banner.js ? `${banner.js}
-
-` : ""}${PLUGBOY_VAR_ENVS_BANNER}
-
-${ENV_FN_INJECTS}`;
-    _tsupOptions.banner = banner;
-    _tsupOptions.external = _tsupOptions.external || [];
-    _tsupOptions.external.push(
-      /^(@fastkit\/)?plugboy/,
-      ...this.workspace.dependencies
-    );
-    this._tsupOptions = _tsupOptions;
-    return _tsupOptions;
-  }
-  async _stubLinkJS(from, to) {
-    const fromParsed = path6.parse(from);
-    const fromDir = fromParsed.dir;
-    const toParsed = path6.parse(to);
-    const toRelativeDir = path6.relative(fromDir, toParsed.dir);
-    const location = path6.join(toRelativeDir, toParsed.base);
-    const source = await fs4.readFile(to, "utf-8");
-    const shebang = source.match(SHEBANG_MATCH_RE)?.[1];
-    const STUB_FN_ERROR = `() => { throw new Error('Path resolution methods cannot be executed in stub mode.') }`;
-    const PLUGBOY_ENVS = {
-      __PLUGBOY_DEV__: "true",
-      __PLUGBOY_STUB__: "true",
-      __plugboyWorkspaceDir: STUB_FN_ERROR,
-      __plugboySrcDir: STUB_FN_ERROR,
-      __plugboyPublicDir: STUB_FN_ERROR
-      // __plugboyWorkspaceDir: `(...paths) => path.join('${this.workspace.dir.value}', ...paths)`,
-      // __plugboySrcDir: `(...paths) => path.join(__plugboySrcDir(), 'src', ...paths)`,
-      // __plugboyPublicDir: `(...paths) => path.join(__plugboySrcDir(), 'dist', ...paths)`,
-    };
-    const ENV_INJECTS = Object.entries(PLUGBOY_ENVS).map(([envName, variable]) => `globalThis.${envName} = ${variable};`).join("\n");
-    const disableChecks = "/* eslint-disable */\n// @ts-nocheck\n";
-    const code = `${disableChecks}${ENV_INJECTS}
-export * from '${location}';`;
-    const dtsPath = path6.join(fromDir, `${fromParsed.name}.d.ts`);
-    const dtsCode = `${disableChecks}export * from '${location.replace(
-      /\.ts$/,
-      ""
-    )}';`;
-    const srcFromDir = path6.dirname(from);
-    const dtsDir = path6.dirname(dtsPath);
-    await Promise.all(
-      [srcFromDir, dtsDir].map((dir) => fs4.mkdir(dir, { recursive: true }))
-    );
-    await Promise.all([
-      fs4.writeFile(from, `${shebang ? `${shebang}
-` : ""}${code}`),
-      fs4.writeFile(dtsPath, dtsCode)
-    ]);
-  }
-  async _stubLinkCSS(from) {
-    const code = `/* noop */`;
-    await fs4.writeFile(from, code);
-  }
-  async copyPublicDir() {
-    const publicDir = this.workspace.dir.join("public").value;
-    await copyDirSync(publicDir, this.workspace.dirs.dist.value);
-  }
-  async stub() {
-    const links = this.workspace.getStubLinks();
-    await this.copyPublicDir();
-    await Promise.all(
-      links.map((link) => {
-        if (link.type === "js") {
-          return this._stubLinkJS(link.from, link.to);
-        }
-        if (link.type === "css") {
-          return this._stubLinkCSS(link.from);
-        }
-        throw new Error(`non supported type`);
-      })
-    );
-    await fs4.writeFile(
-      this.workspace.dirs.dist.join(".stub").value,
-      "",
-      "utf-8"
-    );
-  }
-  normalizeDTSBySettings(dts, settings) {
-    const { targets, pkg } = settings;
-    const myPackageName = this.workspace.json.name;
-    const packageIsOwn = myPackageName === pkg;
-    const pkgImports = (() => {
-      if (!pkg || packageIsOwn) return;
-      const importRe = new RegExp(`import {([^\\{\\}]+)} from '${pkg}'`);
-      const importMatched = dts.match(importRe);
-      const imports = importMatched && importMatched[1];
-      if (!imports) return;
-      return {
-        pkg,
-        importRe,
-        imports
-      };
-    })();
-    const hitTypeNames = [];
-    targets.forEach(({ from, typeName }) => {
-      const matched = dts.match(from);
-      if (matched) {
-        hitTypeNames.push(typeName);
-        dts = dts.replace(from, typeName);
-      }
-    });
-    if (!hitTypeNames.length) return;
-    if (pkgImports) {
-      const { pkg: pkg2, imports, importRe } = pkgImports;
-      const mods = imports.trim().split(",").map((row) => {
-        row = row.split(" as ")[0].trim();
-        return row;
-      });
-      const appends = [];
-      hitTypeNames.forEach((typeName) => {
-        const re = new RegExp(`(^|
-)import { ${typeName} } from '${pkg2}'`);
-        if (!re.test(dts) && !mods.includes(typeName)) {
-          appends.push(typeName);
-        }
-      });
-      if (appends.length) {
-        dts = dts.replace(
-          importRe,
-          `import { $1, ${appends.join(", ")} } from '${pkg2}'`
-        );
-      }
-    } else if (pkg && !packageIsOwn) {
-      const mods = [];
-      hitTypeNames.forEach((typeName) => {
-        if (!dts.includes(`export declare type ${typeName} = `)) {
-          mods.push(typeName);
-        }
-      });
-      if (mods.length) {
-        dts = `import { ${mods.join(", ")} } from '${pkg}';
-${dts}`;
-      }
-    }
-    return dts;
-  }
-  async normalizeDTSFile(filePath) {
-    const dts = await fs4.readFile(filePath, "utf-8");
-    const { preserveType, normalizers } = this.dts;
-    let normalized = dts;
-    let processed = false;
-    for (const settings of preserveType) {
-      const _normalized = this.normalizeDTSBySettings(normalized, settings);
-      if (_normalized) {
-        processed = true;
-        normalized = _normalized;
-      }
-    }
-    for (const normalizer of normalizers) {
-      const _normalized = await normalizer(normalized, this);
-      if (_normalized && normalized !== _normalized) {
-        processed = true;
-        normalized = _normalized;
-      }
-    }
-    if (!processed) {
-      return;
-    }
-    await fs4.writeFile(filePath, normalized, "utf-8");
-  }
-  async normalizeDTSFiles(dtsFiles = this.workspace.dtsFiles) {
-    const { preserveType } = this.dts;
-    if (!preserveType.length || !dtsFiles.length) return;
-    await Promise.all(
-      dtsFiles.map((filePath) => this.normalizeDTSFile(filePath))
-    );
-  }
-  async emitInlineDTS() {
-    const { dir, dirs, exports } = this.workspace;
-    const cwd = dir.value;
-    const outDir = dirs.dist.join(".dts-generate").value;
-    const dtsSrcDir = path6.join(outDir, "src");
-    const dtsDest = dirs.dist.join(".dts").value;
-    await emitDTS({
-      cwd,
-      outDir
-    });
-    await fs4.rename(dtsSrcDir, dtsDest);
-    await rmrf(outDir);
-    const objectExports = [];
-    exports.forEach(({ at }) => {
-      typeof at === "object" && objectExports.push(at);
-    });
-    await Promise.all(
-      objectExports.map(async (at) => {
-        const typesDir = path6.dirname(at.types);
-        const dtsDestDir = path6.dirname(at.dtsDest);
-        const relativeDir = path6.relative(typesDir, dtsDestDir);
-        const relativePath = path6.join(
-          relativeDir,
-          path6.basename(at.dtsDest).replace(/\.d\.ts$/, "")
-        );
-        const code = `export * from './${relativePath}';`;
-        await fs4.writeFile(at.types, code, "utf-8");
-      })
-    );
-    const dtsFiles = await glob2(path6.join(dtsDest, "**/*.d.ts"));
-    await this.normalizeDTSFiles(dtsFiles);
-  }
-  async build() {
-    const _outputFiles = [];
-    const options = await this.tsupOptions();
-    await build({
-      ...options,
-      esbuildPlugins: [
-        ...options.esbuildPlugins,
-        {
-          name: "output-collection",
-          setup(_build) {
-            _build.onEnd((result) => {
-              const { outputFiles } = result;
-              if (!outputFiles) return;
-              _outputFiles.push(...outputFiles);
-            });
-          }
-        }
-      ],
-      onSuccess: async () => {
-        const emptyNativeNodeModuleRe = /(^|\n)import 'node:.+?';?/g;
-        await Promise.all(
-          _outputFiles.map(async ({ path: filePath }) => {
-            if (filePath.endsWith(".css")) {
-              await this._handleCSSOutput(filePath);
-              return;
-            }
-            if (!filePath.endsWith(".mjs")) return;
-            const code = await fs4.readFile(filePath, "utf-8");
-            const replaced = code.replace(emptyNativeNodeModuleRe, "");
-            if (code === replaced) return;
-            await fs4.writeFile(filePath, replaced.trimStart(), "utf-8");
-          })
-        );
-        await this.workspace.hooks.onSuccess(this, _outputFiles);
-      }
-    });
-    if (this.dts.inline) {
-      await this.emitInlineDTS();
-    } else {
-      await this.normalizeDTSFiles();
-    }
-  }
-  async optimizeCSS(cssFilePath) {
-    const options = this.workspace.optimizeCSSOptions;
-    if (!options) return Promise.resolve();
-    let postcss = this._postcssCache;
-    if (!postcss) {
-      postcss = await getPostcss(options);
-      this._postcssCache = postcss;
-    }
-    function prepare(css2) {
-      const layerDefs = (() => {
-        const matched = css2.match(allLayerDefRe);
-        if (!matched) return "";
-        const layerNames = [];
-        matched.forEach((row) => {
-          const trimmed = row.replace(layerDefTrimRe, "");
-          const chunks = trimmed.split(",");
-          chunks.forEach((chunk) => layerNames.push(chunk.trim()));
-        });
-        const uniqued = Array.from(new Set(layerNames));
-        const def = `@layer ${uniqued.join(", ")};
-`;
-        return def;
-      })();
-      return layerDefs + css2.replace(allLayerDefRe, "").replace(SOURCE_MAPPING_URL_COMMENT_RE, "");
-    }
-    const css = prepare(await fs4.readFile(cssFilePath, "utf-8"));
-    const result = await postcss.process(css, { from: cssFilePath });
-    await fs4.writeFile(cssFilePath, result.css);
-  }
-  async _handleCSSOutput(cssFilePath) {
-    await Promise.all([
-      this.optimizeCSS(cssFilePath),
-      safeRemoveCSSMap(cssFilePath)
-    ]);
-  }
-};
-
-// src/project/project.ts
-import fs5 from "fs/promises";
-import path7 from "path";
-import { glob as glob3 } from "glob";
-var PlugboyProject = class {
-  /** Path instance of the project directory */
-  dir;
-  /** package.json */
-  json;
-  /**
-   * Project Configuration
-   * @see {@link ResolvedProjectConfig}
-   */
-  config;
-  /** Names of all packages on which the project depends */
-  dependencies;
-  /** Directory names of all workspaces owned by the project */
-  resolvedWorkspaces;
-  /**
-   * Name of the project's package.json
-   */
-  get name() {
-    return this.json.name;
-  }
-  /**
-   * Plug-in List
-   * @see {@link ResolvedProjectConfig.plugins}
-   */
-  get plugins() {
-    return this.config.plugins;
-  }
-  /**
-   * List of all user hook settings
-   * @see {@link UserHooks}
-   */
-  get hooks() {
-    const { hooks: _hooks, plugins } = this.config;
-    const pluginHooks = plugins.map((plugin) => plugin.hooks);
-    return [_hooks, ...pluginHooks].filter((hook) => !!hook);
-  }
-  constructor(ctx) {
-    const { dir, json, config, resolvedWorkspaces } = ctx;
-    this.dir = dir;
-    this.json = json;
-    this.config = config;
-    const allDeps = {
-      ...json.dependencies,
-      ...json.devDependencies
-    };
-    this.dependencies = Object.keys(allDeps);
-    this.resolvedWorkspaces = resolvedWorkspaces;
-  }
-};
-async function getProject(searchDir, allowMissing, skipLoadConfig) {
-  const hit = await getProjectPackageJson(searchDir, allowMissing);
-  if (!hit) {
-    return null;
-  }
-  const { dir, json } = hit;
-  const resolvedWorkspaces = [];
-  const { workspaces = [] } = json;
-  if (!Array.isArray(workspaces)) {
-    throw new Error("workspaces only supports arrays.");
-  }
-  const workspacesPattern = workspaces.map(
-    (workspace) => dir.join(workspace, PACKAGE_JSON_FILENAME).value
-  );
-  const workspaceHits = await glob3(workspacesPattern);
-  for (const _hit of workspaceHits) {
-    const _json = JSON.parse(await fs5.readFile(_hit, "utf-8"));
-    if (!isWorkspacePackageJson(_json)) {
-      continue;
-    }
-    resolvedWorkspaces.push(path7.dirname(_hit));
-  }
-  resolvedWorkspaces.sort((a, b) => {
-    if (a < b) return -1;
-    if (a > b) return 1;
-    return 0;
-  });
-  const config = skipLoadConfig ? await resolveUserProjectConfig({}) : await loadProjectConfig(dir.value, 0);
-  const ctx = {
-    dir,
-    json,
-    config,
-    resolvedWorkspaces
-  };
-  return new PlugboyProject(ctx);
-}
-
-// src/workspace/workspace.ts
-import sortPackageJson from "sort-package-json";
-import fs6 from "fs/promises";
-import path8 from "path";
-function extractWorkspaceObjectExport(at) {
-  if (typeof at === "string") return at;
-  const { types, import: _import } = at;
-  return {
-    types,
-    import: _import
-  };
-}
-var WORKSPACE_PACKAGE_SYNC_FIELDS = [
-  "repository",
-  "author",
-  "publishConfig",
-  "license"
-];
-function syncWorkspacePackageFields(projectJSON, workspaceJSON) {
-  for (const field of WORKSPACE_PACKAGE_SYNC_FIELDS) {
-    const value = projectJSON[field];
-    if (value && !workspaceJSON[field]) {
-      workspaceJSON[field] = value;
-    }
-  }
-}
-var BUILD_TARGET_SRC_MATCH_RE = /\.(tsx?|s?css)$/;
-var PlugboyWorkspace = class {
-  name;
-  dir;
-  config;
-  project;
-  dirs;
-  dependencies;
-  projectDependencies;
-  meta;
-  entry;
-  exports;
-  builder;
-  plugins;
-  hooks;
-  dtsFiles = [];
-  dts;
-  optimizeCSSOptions;
-  _json;
-  get json() {
-    return this._json;
-  }
-  constructor(ctx) {
-    const {
-      dir,
-      json,
-      config,
-      project,
-      dirs,
-      dependencies,
-      projectDependencies,
-      meta,
-      plugins,
-      hooks,
-      dts,
-      optimizeCSS
-    } = ctx;
-    this.name = dir.basename;
-    this.dir = dir;
-    this._json = json;
-    this.project = project;
-    this.dirs = dirs;
-    this.dependencies = dependencies;
-    this.projectDependencies = projectDependencies;
-    this.meta = meta;
-    this.config = config;
-    this.plugins = plugins;
-    this.hooks = hooks;
-    this.dts = dts;
-    this.optimizeCSSOptions = optimizeCSS ? resolveOptimizeCSSOptions(optimizeCSS) : false;
-    const entry = {};
-    const exports = [
-      {
-        id: `./${PACKAGE_JSON_FILENAME}`,
-        at: `./${PACKAGE_JSON_FILENAME}`
-      }
-    ];
-    Object.entries(config.entries).forEach(([id, { src, css }]) => {
-      if (!BUILD_TARGET_SRC_MATCH_RE.test(src)) return;
-      const isMainEntry = id === ".";
-      const normalizedId = isMainEntry ? this.name : id;
-      const exportId = id.startsWith(".") ? id : `./${id}`;
-      const srcIsCSS = src.endsWith(".css") || src.endsWith(".scss");
-      const ext = srcIsCSS ? "css" : "mjs";
-      const dest = `./dist/${normalizedId}.${ext}`;
-      const destFullPath = dir.join(dest).value;
-      entry[normalizedId] = src;
-      if (css) {
-        const cssDest = `./dist/${normalizedId}.css`;
-        exports.push({
-          id: `./${normalizedId}.css`,
-          at: cssDest,
-          stubLink: {
-            type: "css",
-            from: cssDest
-          }
-        });
-        if (srcIsCSS) return;
-      }
-      const types = `./dist/${normalizedId}.d.ts`;
-      const dtsDest = `./dist/${src.replace(/^\.\/src/, ".dts").replace(/\.ts$/, ".d.ts")}`;
-      this.dtsFiles.push(dir.join(types).value);
-      exports.push({
-        id: exportId,
-        at: {
-          src,
-          types,
-          dtsDest,
-          import: {
-            default: dest
-          }
-        },
-        stubLink: {
-          from: destFullPath,
-          to: path8.isAbsolute(src) ? src : dir.join(src).value,
-          type: "js"
-        }
-      });
-    });
-    this.entry = entry;
-    this.exports = exports;
-    this.builder = new Builder(this);
-  }
-  clean(withDepsAndCache) {
-    const { dir, dirs } = this;
-    const paths = [dirs.dist.value];
-    if (withDepsAndCache) {
-      paths.push(dir.join("node_modules").value, dir.join(".turbo").value);
-    }
-    return rmrf(...paths);
-  }
-  async preparePackageJSON() {
-    const { exports, json, project } = this;
-    const _exports = {};
-    const typesVersions = {};
-    let main;
-    let mainTypes;
-    exports.forEach(({ id, at }) => {
-      const _at = extractWorkspaceObjectExport(at);
-      _exports[id] = _at;
-      if (typeof _at !== "object") return;
-      const isMainExport = id === ".";
-      const trimmedId = isMainExport ? id : id.replace(/^\.\//, "");
-      typesVersions[trimmedId] = [_at.types];
-      if (isMainExport) {
-        main = _at.import.default;
-        mainTypes = _at.types;
-      }
-    });
-    if (json.exports) {
-      const entries = Object.entries(json.exports);
-      entries.forEach(([id, at]) => {
-        const types = Object.keys(at);
-        if (types.length === 1 && types[0] === "types") {
-          _exports[id] = at;
-        }
-      });
-    }
-    _exports["./*"] = "./dist/*";
-    const originalJSONString = JSON.stringify(json);
-    const cloned = JSON.parse(originalJSONString);
-    cloned.exports = _exports;
-    cloned.typesVersions = {
-      "*": typesVersions
-    };
-    if (main) cloned.main = main;
-    if (mainTypes) cloned.types = mainTypes;
-    const projectPeerDependencies = project?.config.peerDependencies;
-    ["dependencies", "devDependencies", "peerDependencies"].forEach(
-      (prop) => {
-        const deps = cloned[prop];
-        if (!deps) return;
-        Object.keys(deps).forEach((dep) => {
-          const version = deps[dep];
-          if (version.startsWith(WORKSPACE_SPEC_PREFIX)) {
-            deps[dep] = `${WORKSPACE_SPEC_PREFIX}^`;
-          } else if (projectPeerDependencies && projectPeerDependencies[dep] && !deps[dep]) {
-            deps[dep] = projectPeerDependencies[dep];
-          }
-        });
-      }
-    );
-    cloned.files = cloned.files || [];
-    if (!cloned.files.some((file) => /(\.\/)?dist\/?/.test(file))) {
-      cloned.files.unshift("dist");
-    }
-    if (project) {
-      syncWorkspacePackageFields(project.json, cloned);
-    }
-    cloned.type = cloned.type || "module";
-    await this.hooks.preparePackageJSON(json, this);
-    const sorted = sortPackageJson(cloned);
-    const toStr = JSON.stringify(sorted, null, 2);
-    if (originalJSONString !== toStr) {
-      await fs6.writeFile(this.dir.join(PACKAGE_JSON_FILENAME).value, toStr);
-      this._json = sorted;
-    }
-    return sorted;
-  }
-  getStubLinks() {
-    const links = [];
-    this.exports.forEach(({ stubLink }) => {
-      stubLink && links.push(stubLink);
-    });
-    return links;
-  }
-  async stub() {
-    await this.clean();
-    await fs6.mkdir(this.dirs.dist.value);
-    return this.builder.stub();
-  }
-  async getESBuildPlugins() {
-    const results = [];
-    results.push({
-      name: "plugboy-workspace-env",
-      setup: (build2) => {
-        const isJS = /\.m?js$/;
-        const RELATIVE_PATH_FOR_WORKSPACE = "@@__PLUGBOY_RELATIVE_PATH_FOR_WORKSPACE__";
-        const encoder = new TextEncoder();
-        build2.onEnd(({ outputFiles, errors, warnings }) => {
-          const result = { errors, warnings };
-          if (!outputFiles || !outputFiles.length || errors.length)
-            return result;
-          for (const file of outputFiles) {
-            const { path: filePath, text } = file;
-            if (!isJS.test(filePath) || !text.includes(RELATIVE_PATH_FOR_WORKSPACE)) {
-              continue;
-            }
-            const relativePath = path8.relative(
-              path8.dirname(filePath),
-              this.dir.value
-            );
-            const content = text.replace(
-              RELATIVE_PATH_FOR_WORKSPACE,
-              relativePath
-            );
-            file.contents = encoder.encode(content);
-          }
-          return result;
-        });
-      }
-    });
-    const { plugins } = this;
-    for (const plugin of plugins) {
-      const { esbuildPlugins } = plugin;
-      if (!esbuildPlugins) continue;
-      for (const chunk of esbuildPlugins) {
-        const esbuildPlugin = (
-          // eslint-disable-next-line no-await-in-loop
-          typeof chunk === "function" ? await chunk(this) : await chunk
-        );
-        if (esbuildPlugin) {
-          results.push(esbuildPlugin);
-        }
-      }
-    }
-    return results;
-  }
-  async build() {
-    await this.clean();
-    return this.builder.build();
-  }
-};
-async function getWorkspace(searchDir, allowMissing) {
-  const hit = await getWorkspacePackageJson(searchDir, allowMissing);
-  if (!hit) {
-    return null;
-  }
-  const { dir, json } = hit;
-  const config = await loadWorkspaceConfig(dir.value, 0);
-  const project = await getProject(dir.value, true, config.ignoreProjectConfig);
-  const dirs = {
-    src: dir.join("src"),
-    dist: dir.join("dist")
-  };
-  const { dependencies, peerDependencies, optionalDependencies } = json;
-  const allDeps = {
-    ...dependencies,
-    ...peerDependencies,
-    ...optionalDependencies
-  };
-  const _dependencies = Object.keys(allDeps);
-  const projectDependencies = Object.entries(allDeps).filter(([dep, spec]) => spec.startsWith(WORKSPACE_SPEC_PREFIX)).map(([dep]) => dep);
-  const meta = {};
-  const packagePlugins = project?.plugins || [];
-  const packageHooks = project?.hooks || [];
-  const plugins = [...packagePlugins, ...config.plugins];
-  const _hooks = [...packageHooks];
-  if (config.hooks) {
-    _hooks.push(config.hooks);
-  }
-  const resolvedHooks = await resolveUserHooks(..._hooks);
-  const hooks = buildHooks(resolvedHooks);
-  const dts = mergeDTSSettingsList(project?.config.dts, config.dts);
-  let { optimizeCSS } = config;
-  if (optimizeCSS !== false && project && project.config.optimizeCSS) {
-    optimizeCSS = {
-      ...project.config.optimizeCSS,
-      ...optimizeCSS
-    };
-  }
-  const ctx = {
-    dir,
-    json,
-    config,
-    project,
-    dirs,
-    dependencies: _dependencies,
-    projectDependencies,
-    meta,
-    plugins,
-    hooks,
-    dts,
-    optimizeCSS
-  };
-  await hooks.setupWorkspace(ctx);
-  const workspace = new PlugboyWorkspace(ctx);
-  await hooks.createWorkspace(workspace);
-  return workspace;
-}
-
-// src/workspace/generate.ts
-import path9 from "path";
-import fs7 from "fs/promises";
-import sortPackageJson2 from "sort-package-json";
-import * as prompts from "@inquirer/prompts";
-async function generateWorkspace(workspaceName, cwd = process.cwd()) {
-  const project = await getProject(cwd);
-  const { config } = project;
-  while (!workspaceName) {
-    const value = await prompts.input({
-      message: "Enter a workspace name"
-    });
-    if (value) {
-      workspaceName = value;
-    }
-  }
-  const description = await prompts.input({
-    default: workspaceName,
-    message: "Please enter a description of your package"
-  });
-  let version;
-  while (!version) {
-    const value = await prompts.input({
-      default: "0.0.0",
-      message: "Please enter the initial version"
-    });
-    if (value) {
-      version = value;
-    }
-  }
-  const rawKeywords = await prompts.input({
-    message: "Enter as many keywords, if any, as needed, separated by commas"
-  });
-  const keywords = rawKeywords.split(",").map((word) => word.trim()).filter((word) => word.length);
-  const scriptsTemplates = config.scripts;
-  let scriptsTemplate;
-  if (scriptsTemplates && scriptsTemplates.length) {
-    const value = await prompts.rawlist({
-      message: "Select a scripts template",
-      choices: [
-        { name: "None", value: "" },
-        ...scriptsTemplates.map((tpl) => ({
-          name: tpl.name,
-          value: tpl.name
-        }))
-      ]
-    });
-    scriptsTemplate = scriptsTemplates.find((tpl) => tpl.name === value);
-  }
-  const scripts = scriptsTemplate?.scripts || {};
-  const peerDependencies = await (async () => {
-    const deps = await prompts.checkbox({
-      message: "Select the dependent packages, if any, to be used in the package",
-      choices: Object.keys(config.peerDependencies).map((dep) => ({
-        name: dep,
-        value: dep
-      }))
-    });
-    if (!deps.length) return;
-    return Object.fromEntries(
-      deps.map((dep) => [dep, config.peerDependencies[dep]])
-    );
-  })();
-  const dependencies = await (async () => {
-    const deps = await prompts.checkbox({
-      message: "Select the internal package to be used, if any.",
-      choices: project.resolvedWorkspaces.map((workspace) => {
-        const name = path9.basename(workspace);
-        return {
-          name,
-          value: name
-        };
-      })
-    });
-    if (!deps.length) return;
-    return Object.fromEntries(
-      deps.map((dep) => [
-        `@${project.name}/${dep}`,
-        `${WORKSPACE_SPEC_PREFIX}^`
-      ])
-    );
-  })();
-  const withGenSource = await prompts.confirm({
-    message: "Generate source files?",
-    default: true
-  });
-  const _json = {
-    name: `@${project.name}/${workspaceName}`,
-    type: "module",
-    description,
-    version,
-    keywords,
-    scripts,
-    peerDependencies,
-    dependencies
-  };
-  syncWorkspacePackageFields(project.json, _json);
-  const json = sortPackageJson2(_json);
-  const workspaceDir = path9.join(config.workspacesDir, workspaceName);
-  console.log("");
-  console.log("========================================");
-  console.log(`Directory: ${workspaceDir}`);
-  console.log(`Generate source: ${withGenSource ? "Yes" : "No"}`);
-  console.log(json);
-  console.log("========================================");
-  const confirmation = await prompts.confirm({
-    message: "Is this OK?",
-    default: true
-  });
-  if (!confirmation) {
-    console.log("Skipped.");
-    process.exit(1);
-  }
-  await fs7.mkdir(workspaceDir);
-  await fs7.writeFile(
-    path9.join(workspaceDir, "package.json"),
-    JSON.stringify(json, null, 2)
-  );
-  await fs7.writeFile(path9.join(workspaceDir, "README.md"), config.readme(json));
-  if (withGenSource) {
-    const srcDir = path9.join(workspaceDir, "src");
-    await fs7.mkdir(srcDir);
-    const indexCode = `export * from './${workspaceName}';
-`;
-    const modCode = `export const PACKAGE_NAME = './${workspaceName}';
-`;
-    await fs7.writeFile(path9.join(srcDir, "index.ts"), indexCode);
-    await fs7.writeFile(path9.join(srcDir, `${workspaceName}.ts`), modCode);
-    const { tsconfig } = config;
-    if (tsconfig) {
-      await fs7.writeFile(
-        path9.join(workspaceDir, "tsconfig.json"),
-        JSON.stringify(tsconfig, null, 2)
-      );
-    }
-    const configFileCode = `${`
-import { defineWorkspaceConfig } from '@fastkit/plugboy';
-
-export default defineWorkspaceConfig({
-  entries: {
-    '.': './src/index.ts',
-  },
-});
-    `.trim()}
-`;
-    await fs7.writeFile(
-      path9.join(workspaceDir, `${WORKSPACE_CONFIG_BASENAME}.ts`),
-      configFileCode
-    );
-    const workspace = await getWorkspace(workspaceDir);
-    await workspace.preparePackageJSON();
-  }
-}
-
-export {
-  createHooksDefaults,
-  normalizeDTSPreserveTypeTarget,
-  normalizeDTSPreserveTypeSettings,
-  normalizeDTSSettings,
-  mergeDTSSettingsList,
-  resolveOptimizeCSSOptions,
-  WORKSPACE_REQUIRED_FIELDS,
-  TSUP_SYNC_OPTIONS,
-  PROJECT_REQUIRED_FIELDS,
-  isPromise,
-  resolveListable,
-  getFilename,
-  getDirname,
-  isFileNotFoundException,
-  pathExists,
-  findFile,
-  findConfig,
-  rmrf,
-  copyDirSync,
-  resolveRawExposeEntriesSettings,
-  exposeEntries,
-  isProjectPackageJson,
-  resolveUserProjectConfig,
-  defineProjectConfig,
-  loadProjectConfig,
-  resolveUserPluginOptions,
-  definePlugin,
-  extractProjectPlugins,
-  findProjectPlugin,
-  isWorkspacePackageJson,
-  resolveRawWorkspaceEntry,
-  resolveRawWorkspaceEntries,
-  resolveUserWorkspaceConfig,
-  defineWorkspaceConfig,
-  loadWorkspaceConfig,
-  resolveUserHooks,
-  buildHooks,
-  Path,
-  getProjectPackageJson,
-  getWorkspacePackageJson,
-  findWorkspacePackages,
-  Builder,
-  PlugboyProject,
-  getProject,
-  WORKSPACE_PACKAGE_SYNC_FIELDS,
-  syncWorkspacePackageFields,
-  PlugboyWorkspace,
-  getWorkspace,
-  generateWorkspace
-};
-//# sourceMappingURL=chunk-IDJLTVUE.mjs.map