@fastkit/plugboy 0.0.1

package/dist/chunk-QSOC5WYP.mjs

@@ -0,0 +1,1493 @@
+// src/types/hook.ts
+function createHooksDefaults() {
+  return {
+    setupWorkspace: [],
+    createWorkspace: [],
+    preparePackageJSON: []
+  };
+}
+
+// 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 = [] } = settings || {};
+  return {
+    inline,
+    preserveType: preserveType.map(normalizeDTSPreserveTypeSettings)
+  };
+}
+function mergeDTSSettingsList(...settingsList) {
+  const merged = {};
+  settingsList.forEach((settings) => {
+    if (!settings)
+      return;
+    const { inline, preserveType } = settings;
+    if (inline !== void 0)
+      merged.inline = inline;
+    if (preserveType) {
+      merged.preserveType = merged.preserveType || [];
+      merged.preserveType.push(...preserveType);
+    }
+  });
+  return normalizeDTSSettings(merged);
+}
+
+// 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 "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node: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(fileName, 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 result2 = {
+          fileName: fileName2,
+          dir,
+          path: _path,
+          code
+        };
+        if (!test || test(result2)) {
+          return result2;
+        }
+      } catch (err) {
+        if (!isFileNotFoundException(err)) {
+          throw err;
+        }
+      }
+    }
+  })();
+  if (!result) {
+    return next();
+  }
+  return result;
+}
+function _rmrf(path9) {
+  return fs.promises.rm(path9, {
+    recursive: true,
+    force: true
+  }).catch((err) => {
+    if (isFileNotFoundException(err))
+      return;
+    throw err;
+  });
+}
+async function rmrf(...paths) {
+  await Promise.all(paths.map((path9) => _rmrf(path9)));
+}
+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/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
+  } = userConfig;
+  return {
+    workspacesDir,
+    scripts: Array.isArray(scripts) ? scripts : [{ name: "", scripts }],
+    peerDependencies,
+    tsconfig,
+    readme,
+    plugins: await resolveUserPluginOptions(plugins)
+  };
+}
+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 } = userConfig;
+  return {
+    ...userConfig,
+    ignoreProjectConfig,
+    entries: resolveRawWorkspaceEntries(entries),
+    plugins: await resolveUserPluginOptions(plugins)
+  };
+}
+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 path2 from "node:path";
+import fs2 from "node:fs";
+var Path = class {
+  _value;
+  _stats;
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    const _value = path2.resolve(value);
+    if (_value === this._value)
+      return;
+    this._value = path2.resolve(value);
+    delete this._stats;
+  }
+  get dirname() {
+    return path2.dirname(this.value);
+  }
+  get basename() {
+    return path2.basename(this.value);
+  }
+  get extname() {
+    return path2.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 = path2.resolve(value);
+  }
+  toString() {
+    return this.value;
+  }
+  valueOf() {
+    return this.value;
+  }
+  toJSON() {
+    return this.value;
+  }
+  relative(to) {
+    return new Path(path2.relative(this.value, to));
+  }
+  join(...paths) {
+    return new Path(path2.join(this.value, ...paths));
+  }
+  resolve(...paths) {
+    return new Path(path2.resolve(this.value, ...paths));
+  }
+  _join(...paths) {
+    const _paths = paths.filter((path9) => !!path9);
+    return _paths.length ? path2.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) => {
+      return new Path(path2.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 "node:fs/promises";
+import path3 from "node: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 = path3.resolve(dir);
+  const dirs = await fs3.readdir(searchDir);
+  const pkgs = await Promise.all(
+    dirs.map(
+      (dirName) => getWorkspacePackageJson(path3.join(searchDir, dirName), true)
+    )
+  );
+  pkgs.forEach((pkg) => {
+    pkg && results.push(pkg);
+  });
+  return results;
+}
+
+// src/workspace/builder.ts
+import { build } from "tsup";
+import fs4 from "node:fs/promises";
+import path5 from "node:path";
+
+// src/workspace/dts.ts
+import { execa } from "execa";
+import path4 from "node:path";
+async function emitDTS(opts = {}) {
+  const { cwd = process.cwd(), outDir = path4.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
+import { glob } from "glob";
+var SHEBANG_MATCH_RE = /^(#!.+?)\n/;
+var Builder = class {
+  workspace;
+  _tsupOptions;
+  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 + "\n\n" : ""}${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 = path5.parse(from);
+    const fromDir = fromParsed.dir;
+    const toParsed = path5.parse(to);
+    const toRelativeDir = path5.relative(fromDir, toParsed.dir);
+    const location = path5.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 = path5.join(fromDir, `${fromParsed.name}.d.ts`);
+    const dtsCode = `${disableChecks}export * from '${location.replace(
+      /\.ts$/,
+      ""
+    )}';`;
+    await Promise.all([
+      fs4.writeFile(from, `${shebang ? shebang + "\n" : ""}${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);
+        } else if (link.type === "css") {
+          return this._stubLinkCSS(link.from);
+        }
+      })
+    );
+  }
+  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 } = 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;
+      }
+    }
+    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 = path5.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 = path5.dirname(at.types);
+        const dtsDestDir = path5.dirname(at.dtsDest);
+        const relativeDir = path5.relative(typesDir, dtsDestDir);
+        const relativePath = path5.join(
+          relativeDir,
+          path5.basename(at.dtsDest).replace(/\.d\.ts$/, "")
+        );
+        const code = `export * from './${relativePath}';`;
+        await fs4.writeFile(at.types, code, "utf-8");
+      })
+    );
+    const dtsFiles = await glob(path5.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(build2) {
+            build2.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(".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");
+          })
+        );
+      }
+    });
+    if (this.dts.inline) {
+      await this.emitInlineDTS();
+    } else {
+      await this.normalizeDTSFiles();
+    }
+  }
+};
+
+// src/project/project.ts
+import fs5 from "node:fs/promises";
+import path6 from "node:path";
+import glob2 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;
+  const workspacesPattern = workspaces.map(
+    (workspace) => dir.join(workspace, PACKAGE_JSON_FILENAME).value
+  );
+  const workspaceHits = await glob2(workspacesPattern);
+  for (const hit2 of workspaceHits) {
+    const json2 = JSON.parse(await fs5.readFile(hit2, "utf-8"));
+    if (!isWorkspacePackageJson(json2)) {
+      continue;
+    }
+    resolvedWorkspaces.push(path6.dirname(hit2));
+  }
+  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 "node:fs/promises";
+import path7 from "node: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;
+  _json;
+  get json() {
+    return this._json;
+  }
+  constructor(ctx) {
+    const {
+      dir,
+      json,
+      config,
+      project,
+      dirs,
+      dependencies,
+      projectDependencies,
+      meta,
+      plugins,
+      hooks,
+      dts
+    } = 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;
+    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: 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 trimedId = isMainExport ? id : id.replace(/^\.\//, "");
+      typesVersions[trimedId] = [_at.types];
+      if (isMainExport) {
+        main = _at.import.default;
+        mainTypes = _at.types;
+      }
+    });
+    _exports["./*"] = "./dist/*";
+    const cloned = JSON.parse(JSON.stringify(json));
+    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:")) {
+            deps[dep] = "workspace:*";
+          } else if (projectPeerDependencies && projectPeerDependencies[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 fromStr = JSON.stringify(cloned, null, 2);
+    const toStr = JSON.stringify(sorted, null, 2);
+    if (fromStr !== toStr || process) {
+      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 = path7.relative(
+              path7.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 = 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);
+  const ctx = {
+    dir,
+    json,
+    config,
+    project,
+    dirs,
+    dependencies: _dependencies,
+    projectDependencies,
+    meta,
+    plugins,
+    hooks,
+    dts
+  };
+  await hooks.setupWorkspace(ctx);
+  const workspace = new PlugboyWorkspace(ctx);
+  await hooks.createWorkspace(workspace);
+  return workspace;
+}
+
+// src/workspace/generate.ts
+import path8 from "node:path";
+import fs7 from "node:fs/promises";
+import sortPackageJson2 from "sort-package-json";
+import inquirer from "inquirer";
+async function generateWorkspace(workspaceName, cwd = process.cwd()) {
+  const project = await getProject(cwd);
+  const { config } = project;
+  while (!workspaceName) {
+    const { value } = await inquirer.prompt({
+      type: "input",
+      name: "value",
+      message: "Enter a workspace name"
+    });
+    if (value) {
+      workspaceName = value;
+    }
+  }
+  const { description } = await inquirer.prompt({
+    type: "input",
+    name: "description",
+    default: workspaceName,
+    message: "Please enter a description of your package"
+  });
+  let version;
+  while (!version) {
+    const { value } = await inquirer.prompt({
+      type: "input",
+      name: "value",
+      default: "0.0.0",
+      message: "Please enter the initial version"
+    });
+    if (value) {
+      version = value;
+    }
+  }
+  const { rawKeywords } = await inquirer.prompt({
+    type: "input",
+    name: "rawKeywords",
+    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 inquirer.prompt({
+      type: "rawlist",
+      message: "Select a scripts template",
+      name: "value",
+      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 inquirer.prompt({
+      type: "checkbox",
+      message: "Select the dependent packages, if any, to be used in the package",
+      name: "deps",
+      choices: Object.keys(config.peerDependencies).map((dep) => {
+        return {
+          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 inquirer.prompt({
+      type: "checkbox",
+      message: "Select the internal package to be used, if any.",
+      name: "deps",
+      choices: project.resolvedWorkspaces.map((workspace) => {
+        const name = path8.basename(workspace);
+        return {
+          name,
+          value: name
+        };
+      })
+    });
+    if (!deps.length)
+      return;
+    return Object.fromEntries(
+      deps.map((dep) => [`@${project.name}/${dep}`, "workspace:*"])
+    );
+  })();
+  const { withGenSource } = await inquirer.prompt({
+    type: "confirm",
+    name: "withGenSource",
+    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 = path8.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 inquirer.prompt({
+    type: "confirm",
+    name: "confirmation",
+    message: "Is this OK?",
+    default: true
+  });
+  if (!confirmation) {
+    console.log("Skiped.");
+    process.exit(1);
+  }
+  await fs7.mkdir(workspaceDir);
+  await fs7.writeFile(
+    path8.join(workspaceDir, "package.json"),
+    JSON.stringify(json, null, 2)
+  );
+  await fs7.writeFile(path8.join(workspaceDir, "README.md"), config.readme(json));
+  if (withGenSource) {
+    const srcDir = path8.join(workspaceDir, "src");
+    await fs7.mkdir(srcDir);
+    const indexCode = `export * from './${workspaceName}';
+`;
+    const modCode = `export const PACKAGE_NAME = './${workspaceName}';
+`;
+    await fs7.writeFile(path8.join(srcDir, "index.ts"), indexCode);
+    await fs7.writeFile(path8.join(srcDir, `${workspaceName}.ts`), modCode);
+    const { tsconfig } = config;
+    if (tsconfig) {
+      await fs7.writeFile(
+        path8.join(workspaceDir, "tsconfig.json"),
+        JSON.stringify(tsconfig, null, 2)
+      );
+    }
+    const configFileCode = `
+import { defineWorkspaceConfig } from '@fastkit/plugboy';
+
+export default defineWorkspaceConfig({
+  entries: {
+    '.': './src/index.ts',
+  },
+});
+    `.trim() + "\n";
+    await fs7.writeFile(
+      path8.join(workspaceDir, `${WORKSPACE_CONFIG_BASENAME}.ts`),
+      configFileCode
+    );
+    const workspace = await getWorkspace(workspaceDir);
+    await workspace.preparePackageJSON();
+  }
+}
+
+export {
+  createHooksDefaults,
+  normalizeDTSPreserveTypeTarget,
+  normalizeDTSPreserveTypeSettings,
+  normalizeDTSSettings,
+  mergeDTSSettingsList,
+  WORKSPACE_REQUIRED_FIELDS,
+  TSUP_SYNC_OPTIONS,
+  PROJECT_REQUIRED_FIELDS,
+  isPromise,
+  resolveListable,
+  getFilename,
+  getDirname,
+  isFileNotFoundException,
+  pathExists,
+  findFile,
+  findConfig,
+  rmrf,
+  copyDirSync,
+  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-QSOC5WYP.mjs.map