bun-workspaces 1.0.1-alpha → 1.0.1

package/src/cli/globalOptions/globalOptions.d.ts

@@ -0,0 +1,40 @@
+import { type Command } from "commander";
+export declare const initializeWithGlobalOptions: (
+  program: Command,
+  args: string[],
+  defaultCwd: string,
+) => {
+  project: import("../../internal/core").Simplify<{
+    readonly rootDirectory: string;
+    readonly workspaces: import("../..").Workspace[];
+    readonly name: string;
+    readonly sourceType: "fileSystem";
+    readonly config: import("../../project").ProjectConfig;
+    readonly rootWorkspace: import("../..").Workspace;
+    runWorkspaceScript(
+      options: import("../..").RunWorkspaceScriptOptions,
+    ): import("../..").RunWorkspaceScriptResult;
+    runScriptAcrossWorkspaces(
+      options: import("../..").RunScriptAcrossWorkspacesOptions,
+    ): import("../..").RunScriptAcrossWorkspacesResult;
+    listWorkspacesWithScript(scriptName: string): import("../..").Workspace[];
+    mapScriptsToWorkspaces(): Record<
+      string,
+      import("../..").WorkspaceScriptMetadata
+    >;
+    findWorkspaceByName(
+      workspaceName: string,
+    ): import("../..").Workspace | null;
+    findWorkspaceByAlias(alias: string): import("../..").Workspace | null;
+    findWorkspaceByNameOrAlias(
+      nameOrAlias: string,
+    ): import("../..").Workspace | null;
+    findWorkspacesByPattern(
+      ...workspacePatterns: string[]
+    ): import("../..").Workspace[];
+    createScriptCommand(
+      options: import("../..").CreateProjectScriptCommandOptions,
+    ): import("../..").CreateProjectScriptCommandResult;
+  }>;
+  projectError: Error | null;
+};

package/src/cli/globalOptions/globalOptions.mjs

@@ -0,0 +1,105 @@
+import fs from "fs";
+import path from "path";
+import { Option } from "commander";
+import { defineErrors } from "../../internal/core/index.mjs";
+import { logger } from "../../internal/logger/index.mjs";
+import {
+  createFileSystemProject,
+  createMemoryProject,
+} from "../../project/index.mjs";
+import { getCliGlobalOptionConfig } from "./globalOptionsConfig.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "commander"
+// CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "../../project/index.mjs"
+// CONCATENATED MODULE: external "./globalOptionsConfig.mjs"
+// CONCATENATED MODULE: ./src/cli/globalOptions/globalOptions.ts
+
+const ERRORS = defineErrors(
+  "WorkingDirectoryNotFound",
+  "WorkingDirectoryNotADirectory",
+);
+const addGlobalOption = (program, optionName, defaultOverride) => {
+  const { mainOption, shortOption, description, param, values, defaultValue } =
+    getCliGlobalOptionConfig(optionName);
+  let option = new Option(
+    `${shortOption} ${mainOption}${param ? ` <${param}>` : ""}`,
+    description,
+  );
+  const effectiveDefaultValue = defaultOverride ?? defaultValue;
+  if (effectiveDefaultValue) {
+    option = option.default(effectiveDefaultValue);
+  }
+  if (values?.length) {
+    option = option.choices(values);
+  }
+  program.addOption(option);
+  if (!param) {
+    program.option(
+      mainOption.replace(/^--/, "--no-"),
+      `Set ${mainOption} as false`,
+    );
+  }
+};
+const getWorkingDirectoryFromArgs = (program, args, defaultCwd) => {
+  addGlobalOption(program, "cwd", defaultCwd);
+  program.parseOptions(args);
+  return program.opts().cwd;
+};
+const defineGlobalOptions = (program, args, defaultCwd) => {
+  const cwd = getWorkingDirectoryFromArgs(program, args, defaultCwd);
+  if (!fs.existsSync(cwd)) {
+    throw new ERRORS.WorkingDirectoryNotFound(
+      `Working directory not found at path "${cwd}"`,
+    );
+  }
+  if (!fs.statSync(cwd).isDirectory()) {
+    throw new ERRORS.WorkingDirectoryNotADirectory(
+      `Working directory is not a directory at path "${cwd}"`,
+    );
+  }
+  addGlobalOption(program, "logLevel");
+  addGlobalOption(program, "includeRoot");
+  return {
+    cwd,
+  };
+};
+const applyGlobalOptions = (options) => {
+  logger.printLevel = options.logLevel;
+  logger.debug("Log level: " + options.logLevel);
+  let project;
+  let error = null;
+  try {
+    project = createFileSystemProject({
+      rootDirectory: options.cwd,
+      includeRootWorkspace: options.includeRoot,
+    });
+    logger.debug(
+      `Project: ${JSON.stringify(project.name)} (${project.workspaces.length} workspace${project.workspaces.length === 1 ? "" : "s"})`,
+    );
+    logger.debug("Project root: " + path.resolve(project.rootDirectory));
+  } catch (_error) {
+    error = _error;
+    project = createMemoryProject({
+      workspaces: [],
+    });
+  }
+  return {
+    project,
+    projectError: error,
+  };
+};
+const initializeWithGlobalOptions = (program, args, defaultCwd) => {
+  program.allowUnknownOption(true);
+  const { cwd } = defineGlobalOptions(program, args, defaultCwd);
+  program.parseOptions(args);
+  program.allowUnknownOption(false);
+  const options = program.opts();
+  return applyGlobalOptions({
+    ...options,
+    cwd,
+  });
+};
+
+export { initializeWithGlobalOptions };

package/src/cli/globalOptions/globalOptionsConfig.d.ts

@@ -0,0 +1,43 @@
+import { type LogLevelSetting } from "../../internal/logger";
+export interface CliGlobalOptions {
+  logLevel: LogLevelSetting;
+  cwd: string;
+  includeRoot: boolean;
+}
+export interface CliGlobalOptionConfig {
+  mainOption: string;
+  shortOption: string;
+  description: string;
+  defaultValue: string;
+  values: string[] | null;
+  param: string;
+}
+export type CliGlobalOptionName = keyof CliGlobalOptions;
+export declare const getCliGlobalOptionConfig: (
+  optionName: CliGlobalOptionName,
+) =>
+  | {
+      readonly mainOption: "--log-level";
+      readonly shortOption: "-l";
+      readonly description: "Log levels";
+      readonly defaultValue: "info";
+      readonly values: ("debug" | "info" | "warn" | "error" | "silent")[];
+      readonly param: "level";
+    }
+  | {
+      readonly mainOption: "--cwd";
+      readonly shortOption: "-d";
+      readonly description: "Working directory";
+      readonly defaultValue: ".";
+      readonly values: null;
+      readonly param: "path";
+    }
+  | {
+      readonly mainOption: "--include-root";
+      readonly shortOption: "-r";
+      readonly description: "Include the root workspace as a normal workspace";
+      readonly defaultValue: "";
+      readonly values: null;
+      readonly param: "";
+    };
+export declare const getCliGlobalOptionNames: () => CliGlobalOptionName[];

package/src/cli/globalOptions/globalOptionsConfig.mjs

@@ -0,0 +1,34 @@
+import { LOG_LEVELS } from "../../internal/logger/index.mjs"; // CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: ./src/cli/globalOptions/globalOptionsConfig.ts
+
+const CLI_GLOBAL_OPTIONS_CONFIG = {
+  logLevel: {
+    mainOption: "--log-level",
+    shortOption: "-l",
+    description: "Log levels",
+    defaultValue: "info",
+    values: [...LOG_LEVELS, "silent"],
+    param: "level",
+  },
+  cwd: {
+    mainOption: "--cwd",
+    shortOption: "-d",
+    description: "Working directory",
+    defaultValue: ".",
+    values: null,
+    param: "path",
+  },
+  includeRoot: {
+    mainOption: "--include-root",
+    shortOption: "-r",
+    description: "Include the root workspace as a normal workspace",
+    defaultValue: "",
+    values: null,
+    param: "",
+  },
+};
+const getCliGlobalOptionConfig = (optionName) =>
+  CLI_GLOBAL_OPTIONS_CONFIG[optionName];
+const getCliGlobalOptionNames = () => Object.keys(CLI_GLOBAL_OPTIONS_CONFIG);
+
+export { getCliGlobalOptionConfig, getCliGlobalOptionNames };

package/src/cli/globalOptions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./globalOptionsConfig";
+export * from "./globalOptions";

package/src/cli/globalOptions/index.mjs

@@ -0,0 +1,2 @@
+export * from "./globalOptionsConfig.mjs";
+export * from "./globalOptions.mjs"; // CONCATENATED MODULE: ./src/cli/globalOptions/index.ts

package/src/cli/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./createCli";
+export * from "./commands";
+export * from "./globalOptions";

package/src/cli/index.mjs

@@ -0,0 +1,3 @@
+export * from "./createCli.mjs";
+export * from "./commands/index.mjs";
+export * from "./globalOptions/index.mjs"; // CONCATENATED MODULE: ./src/cli/index.ts

package/src/cli/middleware.d.ts

@@ -0,0 +1,72 @@
+import type { Command as CommanderProgram } from "commander";
+import type { FileSystemProject } from "../project";
+import type { CliCommandName, CliGlobalCommandName } from "./commands";
+import type {
+  GlobalCommandContext,
+  ProjectCommandContext,
+} from "./commands/commandHandlerUtils";
+export type InitProgramContext = {
+  commanderProgram: CommanderProgram;
+  argv: string[];
+};
+export type ProcessArgvContext = {
+  args: string[];
+  postTerminatorArgs: string[];
+};
+export type FindProjectContext = {
+  commanderProgram: CommanderProgram;
+  project: FileSystemProject;
+  projectError: Error | null;
+};
+export type PreParseContext = {
+  commanderProgram: CommanderProgram;
+  args: string[];
+  project: FileSystemProject;
+  projectError: Error | null;
+};
+export type PostParseContext = {
+  commanderProgram: CommanderProgram;
+  args: string[];
+  project: FileSystemProject;
+  projectError: Error | null;
+};
+export type CommandMiddlewareContext<C extends CliCommandName> = {
+  commanderProgram: CommanderProgram;
+  commandName: C;
+  commandContext: C extends CliGlobalCommandName
+    ? GlobalCommandContext
+    : ProjectCommandContext;
+  commanderActionArgs: unknown[];
+};
+export type CommandMiddleware = <C extends CliCommandName>(
+  context: CommandMiddlewareContext<C>,
+) => CommanderProgram;
+export type PostCleanupContext = {
+  commanderProgram: CommanderProgram;
+  args: string[];
+  project: FileSystemProject;
+  projectError: Error | null;
+};
+export type CliMiddleware = {
+  /** The first callback when the Commander program is created */
+  initProgram: (context: InitProgramContext) => CommanderProgram;
+  /** Before the true parsing, just splitting the argv into args and post-terminator args */
+  processArgv: (context: ProcessArgvContext) => CommanderProgram;
+  /** After the project has been initialized from global options */
+  findProject: (context: FindProjectContext) => CommanderProgram;
+  /** Before the Commander program parses the args */
+  preParse: (context: PreParseContext) => CommanderProgram;
+  /** After the Commander program has parsed the args (runs in finally block) */
+  postParse: (context: PostParseContext) => CommanderProgram;
+  /** Before a command is handled */
+  preHandleCommand: CommandMiddleware;
+  /** After a command is handled */
+  postHandleCommand: CommandMiddleware;
+  /** After the program has been parsed */
+  catchError: (error: Error) => unknown;
+};
+export type CliMiddlewareOptions = Partial<CliMiddleware>;
+export declare const resolveMiddleware: (
+  defaultMiddleware: CliMiddlewareOptions,
+  runMiddleware: CliMiddlewareOptions,
+) => CliMiddleware;

package/src/cli/middleware.mjs

@@ -0,0 +1,38 @@
+import { defineErrors } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/index.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../internal/logger/index.mjs"
+// CONCATENATED MODULE: ./src/cli/middleware.ts
+
+const MIDDLEWARE_ERRORS = defineErrors("MiddlewareHandlerFailed");
+const resolveMiddleware = (defaultMiddleware, runMiddleware) =>
+  Object.keys({
+    catchError: null,
+    initProgram: null,
+    processArgv: null,
+    findProject: null,
+    preParse: null,
+    postParse: null,
+    preHandleCommand: null,
+    postHandleCommand: null,
+  }).reduce((acc, _key) => {
+    const key = _key;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    acc[key] = (ctx) => {
+      try {
+        let result = defaultMiddleware?.[key]?.(ctx);
+        result = runMiddleware?.[key]?.(ctx);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return result;
+      } catch (error) {
+        logger.error(
+          new MIDDLEWARE_ERRORS.MiddlewareHandlerFailed(
+            `Error in middleware handler "${key}"`,
+          ),
+        );
+        throw error;
+      }
+    };
+    return acc;
+  }, {});
+
+export { resolveMiddleware };

package/src/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./workspaceConfig";
+export * from "./rootConfig";
+export * from "./util";

package/src/config/index.mjs

@@ -0,0 +1,3 @@
+export * from "./workspaceConfig/index.mjs";
+export * from "./rootConfig/index.mjs";
+export * from "./util/index.mjs"; // CONCATENATED MODULE: ./src/config/index.ts

package/src/config/rootConfig/errors.d.ts

@@ -0,0 +1 @@
+export declare const ROOT_CONFIG_ERRORS: import("../../internal/core").DefinedErrors<"InvalidRootConfig">;

package/src/config/rootConfig/errors.mjs

@@ -0,0 +1,6 @@
+import { defineErrors } from "../../internal/core/index.mjs"; // CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/config/rootConfig/errors.ts
+
+const ROOT_CONFIG_ERRORS = defineErrors("InvalidRootConfig");
+
+export { ROOT_CONFIG_ERRORS };

package/src/config/rootConfig/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./rootConfigSchema";
+export * from "./rootConfig";
+export * from "./loadRootConfig";
+export * from "./errors";
+export * from "./rootConfigLocation";

package/src/config/rootConfig/index.mjs

@@ -0,0 +1,5 @@
+export * from "./rootConfigSchema.mjs";
+export * from "./rootConfig.mjs";
+export * from "./loadRootConfig.mjs";
+export * from "./errors.mjs";
+export * from "./rootConfigLocation.mjs"; // CONCATENATED MODULE: ./src/config/rootConfig/index.ts

package/src/config/rootConfig/loadRootConfig.d.ts

@@ -0,0 +1,3 @@
+export declare const loadRootConfig: (
+  rootDirectory: string,
+) => import("./rootConfig").ResolvedRootConfig;

package/src/config/rootConfig/loadRootConfig.mjs

@@ -0,0 +1,22 @@
+import { loadConfig } from "../util/loadConfig.mjs";
+import { createDefaultRootConfig, resolveRootConfig } from "./rootConfig.mjs";
+import {
+  ROOT_CONFIG_FILE_NAME,
+  ROOT_CONFIG_PACKAGE_JSON_KEY,
+} from "./rootConfigLocation.mjs"; // CONCATENATED MODULE: external "../util/loadConfig.mjs"
+// CONCATENATED MODULE: external "./rootConfig.mjs"
+// CONCATENATED MODULE: external "./rootConfigLocation.mjs"
+// CONCATENATED MODULE: ./src/config/rootConfig/loadRootConfig.ts
+
+const loadRootConfig = (rootDirectory) => {
+  const config = loadConfig(
+    "root",
+    rootDirectory,
+    ROOT_CONFIG_FILE_NAME,
+    ROOT_CONFIG_PACKAGE_JSON_KEY,
+    (content) => resolveRootConfig(content),
+  );
+  return config ?? createDefaultRootConfig();
+};
+
+export { loadRootConfig };

package/src/config/rootConfig/rootConfig.d.ts

@@ -0,0 +1,17 @@
+import { type FromSchema } from "json-schema-to-ts";
+import { type ScriptShellOption } from "../../runScript";
+import type { ROOT_CONFIG_JSON_SCHEMA } from "./rootConfigSchema";
+export type RootConfig = FromSchema<typeof ROOT_CONFIG_JSON_SCHEMA>;
+export type ResolvedRootConfig = {
+  defaults: {
+    parallelMax: number;
+    shell: ScriptShellOption;
+    /** `undefined` means the value was not set in the input config */
+    includeRootWorkspace: boolean | undefined;
+  };
+};
+export declare const validateRootConfig: (config: RootConfig) => void;
+export declare const createDefaultRootConfig: () => ResolvedRootConfig;
+export declare const resolveRootConfig: (
+  config: RootConfig,
+) => ResolvedRootConfig;

package/src/config/rootConfig/rootConfig.mjs

@@ -0,0 +1,43 @@
+import validateRootConfig from "../../internal/generated/ajv/validateRootConfig.mjs";
+import {
+  determineParallelMax,
+  resolveScriptShell,
+} from "../../runScript/index.mjs";
+import { getUserEnvVar } from "../userEnvVars/index.mjs";
+import { executeValidator } from "../util/validateConfig.mjs";
+import { ROOT_CONFIG_ERRORS } from "./errors.mjs"; // CONCATENATED MODULE: external "../../internal/generated/ajv/validateRootConfig.mjs"
+// CONCATENATED MODULE: external "../../runScript/index.mjs"
+// CONCATENATED MODULE: external "../userEnvVars/index.mjs"
+// CONCATENATED MODULE: external "../util/validateConfig.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: ./src/config/rootConfig/rootConfig.ts
+
+const rootConfig_validateRootConfig = (config) =>
+  executeValidator(
+    validateRootConfig,
+    "RootConfig",
+    config,
+    ROOT_CONFIG_ERRORS.InvalidRootConfig,
+  );
+const createDefaultRootConfig = () => resolveRootConfig({});
+const resolveRootConfig = (config) => {
+  rootConfig_validateRootConfig(config);
+  return {
+    defaults: {
+      parallelMax: determineParallelMax(
+        config.defaults?.parallelMax ?? "default",
+        " (set by root config)",
+      ),
+      shell: resolveScriptShell(config.defaults?.shell),
+      includeRootWorkspace:
+        config.defaults?.includeRootWorkspace ??
+        getUserEnvVar("includeRootWorkspaceDefault") === "true",
+    },
+  };
+};
+
+export {
+  createDefaultRootConfig,
+  resolveRootConfig,
+  rootConfig_validateRootConfig as validateRootConfig,
+};

package/src/config/rootConfig/rootConfigLocation.d.ts

@@ -0,0 +1,2 @@
+export declare const ROOT_CONFIG_FILE_NAME = "bw.root";
+export declare const ROOT_CONFIG_PACKAGE_JSON_KEY = "bw-root";

package/src/config/rootConfig/rootConfigLocation.mjs

@@ -0,0 +1,5 @@
+// CONCATENATED MODULE: ./src/config/rootConfig/rootConfigLocation.ts
+const ROOT_CONFIG_FILE_NAME = "bw.root";
+const ROOT_CONFIG_PACKAGE_JSON_KEY = "bw-root";
+
+export { ROOT_CONFIG_FILE_NAME, ROOT_CONFIG_PACKAGE_JSON_KEY };

package/src/config/rootConfig/rootConfigSchema.d.ts

@@ -0,0 +1,21 @@
+export declare const ROOT_CONFIG_JSON_SCHEMA: {
+  readonly type: "object";
+  readonly additionalProperties: false;
+  readonly properties: {
+    readonly defaults: {
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly properties: {
+        readonly parallelMax: {
+          readonly type: readonly ["number", "string"];
+        };
+        readonly shell: {
+          readonly type: "string";
+        };
+        readonly includeRootWorkspace: {
+          readonly type: "boolean";
+        };
+      };
+    };
+  };
+};

package/src/config/rootConfig/rootConfigSchema.mjs

@@ -0,0 +1,24 @@
+// CONCATENATED MODULE: ./src/config/rootConfig/rootConfigSchema.ts
+const ROOT_CONFIG_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    defaults: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        parallelMax: {
+          type: ["number", "string"],
+        },
+        shell: {
+          type: "string",
+        },
+        includeRootWorkspace: {
+          type: "boolean",
+        },
+      },
+    },
+  },
+};
+
+export { ROOT_CONFIG_JSON_SCHEMA };

package/src/config/userEnvVars/index.d.ts

@@ -0,0 +1 @@
+export * from "./userEnvVars";

package/src/config/userEnvVars/index.mjs

@@ -0,0 +1 @@
+export * from "./userEnvVars.mjs"; // CONCATENATED MODULE: ./src/config/userEnvVars/index.ts

package/src/config/userEnvVars/userEnvVars.d.ts

@@ -0,0 +1,13 @@
+export declare const USER_ENV_VARS: {
+  readonly parallelMaxDefault: "BW_PARALLEL_MAX_DEFAULT";
+  readonly scriptShellDefault: "BW_SHELL_DEFAULT";
+  readonly includeRootWorkspaceDefault: "BW_INCLUDE_ROOT_WORKSPACE_DEFAULT";
+};
+export type UserEnvVarName = keyof typeof USER_ENV_VARS;
+export declare const getUserEnvVar: (key: UserEnvVarName) => string | undefined;
+export declare const getUserEnvVarName: (
+  key: UserEnvVarName,
+) =>
+  | "BW_PARALLEL_MAX_DEFAULT"
+  | "BW_SHELL_DEFAULT"
+  | "BW_INCLUDE_ROOT_WORKSPACE_DEFAULT";

package/src/config/userEnvVars/userEnvVars.mjs

@@ -0,0 +1,10 @@
+// CONCATENATED MODULE: ./src/config/userEnvVars/userEnvVars.ts
+const USER_ENV_VARS = {
+  parallelMaxDefault: "BW_PARALLEL_MAX_DEFAULT",
+  scriptShellDefault: "BW_SHELL_DEFAULT",
+  includeRootWorkspaceDefault: "BW_INCLUDE_ROOT_WORKSPACE_DEFAULT",
+};
+const getUserEnvVar = (key) => process.env[USER_ENV_VARS[key]];
+const getUserEnvVarName = (key) => USER_ENV_VARS[key];
+
+export { USER_ENV_VARS, getUserEnvVar, getUserEnvVarName };

package/src/config/util/ajvTypes.d.ts

@@ -0,0 +1,10 @@
+export type AjvJsonSchemaErrorObject = {
+  instancePath?: string;
+  schemaPath?: string;
+  keyword?: string;
+  params?: Record<string, unknown>;
+  message?: string;
+};
+export type AjvSchemaValidator<T = unknown> = ((data: unknown) => data is T) & {
+  errors?: AjvJsonSchemaErrorObject[] | null;
+};

package/src/config/util/ajvTypes.mjs

@@ -0,0 +1,2 @@
+// CONCATENATED MODULE: ./src/config/util/ajvTypes.ts
+// Types for AJV-generated JSON schema validators

package/src/config/util/configLocation.d.ts

@@ -0,0 +1,12 @@
+export declare const CONFIG_LOCATION_TYPES: string[];
+export type ConfigLocationType = (typeof CONFIG_LOCATION_TYPES)[number];
+export type ConfigLocation = {
+  type: ConfigLocationType;
+  content: unknown;
+  path: string;
+};
+export declare const createConfigLocationPath: (
+  locationType: ConfigLocationType,
+  name: string,
+  packageJsonKey: string,
+) => string;

package/src/config/util/configLocation.mjs

@@ -0,0 +1,11 @@
+// CONCATENATED MODULE: ./src/config/util/configLocation.ts
+const CONFIG_LOCATION_TYPES = ["jsoncFile", "jsonFile", "packageJson"];
+const CONFIG_LOCATION_PATHS = {
+  jsoncFile: (name) => `${name}.jsonc`,
+  jsonFile: (name) => `${name}.json`,
+  packageJson: (_, packageJsonKey) => `package.json["${packageJsonKey}"]`,
+};
+const createConfigLocationPath = (locationType, name, packageJsonKey) =>
+  CONFIG_LOCATION_PATHS[locationType](name, packageJsonKey);
+
+export { CONFIG_LOCATION_TYPES, createConfigLocationPath };

package/src/config/util/index.d.ts

@@ -0,0 +1,4 @@
+export type * from "./ajvTypes";
+export * from "./loadConfig";
+export * from "./validateConfig";
+export * from "./configLocation";

package/src/config/util/index.mjs

@@ -0,0 +1,3 @@
+export * from "./loadConfig.mjs";
+export * from "./validateConfig.mjs";
+export * from "./configLocation.mjs"; // CONCATENATED MODULE: ./src/config/util/index.ts

package/src/config/util/loadConfig.d.ts

@@ -0,0 +1,16 @@
+import { type AnyFunction } from "../../internal/core";
+import { type ConfigLocation } from "./configLocation";
+export declare const InvalidJSONError: typeof import("../..").BunWorkspacesError;
+export declare const getConfigLocation: (
+  name: string,
+  directory: string,
+  fileName: string,
+  packageJsonKey: string,
+) => ConfigLocation | null;
+export declare const loadConfig: <ProcessContent extends AnyFunction>(
+  name: string,
+  directory: string,
+  fileName: string,
+  packageJsonKey: string,
+  processContent: ProcessContent,
+) => ReturnType<ProcessContent> | null;