bun-workspaces 1.0.0-alpha.3 → 1.0.0-alpha.30

package/src/internal/core/asyncIterable/asyncIterableQueue.mjs

@@ -0,0 +1,73 @@
+// CONCATENATED MODULE: ./src/internal/core/asyncIterable/asyncIterableQueue.ts
+const createAsyncIterableQueue = () => {
+  let pendingResolveIdle = null;
+  const items = [];
+  let isDone = false;
+  const push = (value) => {
+    if (isDone) return;
+    if (pendingResolveIdle) {
+      const resolveIdle = pendingResolveIdle;
+      pendingResolveIdle = null;
+      resolveIdle({
+        value,
+        done: false,
+      });
+    } else {
+      items.push({
+        type: "value",
+        value,
+      });
+    }
+  };
+  const close = () => {
+    if (isDone) return;
+    isDone = true;
+    if (pendingResolveIdle) {
+      const resolveIdle = pendingResolveIdle;
+      pendingResolveIdle = null;
+      resolveIdle({
+        value: undefined,
+        done: true,
+      });
+    } else {
+      items.push({
+        type: "done",
+      });
+    }
+  };
+  const asyncIterator = {
+    next: () => {
+      if (items.length > 0) {
+        const item = items.shift();
+        if (item.type === "done") {
+          isDone = true;
+          return Promise.resolve({
+            value: undefined,
+            done: true,
+          });
+        }
+        return Promise.resolve({
+          value: item.value,
+          done: false,
+        });
+      }
+      if (isDone) {
+        return Promise.resolve({
+          value: undefined,
+          done: true,
+        });
+      }
+      return new Promise((resolve) => {
+        pendingResolveIdle = resolve;
+      });
+    },
+  };
+  const iterator = {
+    [Symbol.asyncIterator]: () => asyncIterator,
+    push,
+    close,
+  };
+  return iterator;
+};
+
+export { createAsyncIterableQueue };

package/src/internal/core/asyncIterable/mergeAsyncIterables.d.ts

@@ -0,0 +1,5 @@
+import type { SimpleAsyncIterable } from "../types";
+/** Run multiple async iterables in parallel and yield the results in the order they are completed. */
+export declare const mergeAsyncIterables: <T>(
+  iterables: SimpleAsyncIterable<T>[],
+) => SimpleAsyncIterable<T>;

package/src/internal/core/asyncIterable/mergeAsyncIterables.mjs

@@ -0,0 +1,27 @@
+// CONCATENATED MODULE: ./src/internal/core/asyncIterable/mergeAsyncIterables.ts
+/** Run multiple async iterables in parallel and yield the results in the order they are completed. */ const mergeAsyncIterables =
+  (iterables) => ({
+    async *[Symbol.asyncIterator]() {
+      const iterators = iterables.map((it) => it[Symbol.asyncIterator]());
+      const callNext = (index) =>
+        iterators[index].next().then((result) => ({
+          index,
+          result,
+        }));
+      const nextCalls = iterators.map((_, i) => callNext(i));
+      let activeCount = iterators.length;
+      while (activeCount > 0) {
+        const { index, result } = await Promise.race(nextCalls);
+        if (result.done) {
+          activeCount--;
+          // eslint-disable-next-line @typescript-eslint/no-empty-function
+          nextCalls[index] = new Promise(() => {});
+          continue;
+        }
+        nextCalls[index] = callNext(index);
+        yield result.value;
+      }
+    },
+  });
+
+export { mergeAsyncIterables };

package/src/internal/core/error.d.ts

@@ -0,0 +1,9 @@
+export declare class BunWorkspacesError extends Error {
+  name: string;
+}
+export type DefinedErrors<ErrorName extends string> = {
+  [name in ErrorName]: typeof BunWorkspacesError;
+};
+export declare const defineErrors: <ErrorName extends string>(
+  ...errors: ErrorName[]
+) => DefinedErrors<ErrorName>;

package/src/internal/{error.ts → core/error.mjs}

@@ -1,38 +1,29 @@
-export class BunWorkspacesError extends Error {
+// CONCATENATED MODULE: ./src/internal/core/error.ts
+class BunWorkspacesError extends Error {
   name = "BunWorkspacesError";
 }
-
-export type DefinedErrors<ErrorName extends string> = {
-  [name in ErrorName]: typeof BunWorkspacesError;
-};
-
-export const defineErrors = <ErrorName extends string>(
-  ...errors: ErrorName[]
-): DefinedErrors<ErrorName> =>
+const defineErrors = (...errors) =>
   errors.reduce((acc, error) => {
     acc[error] = class extends BunWorkspacesError {
-      constructor(message?: string) {
+      constructor(message) {
         super(message);
         this.name = error;
       }
       name = error;
     };
-
     Object.defineProperty(acc[error].prototype.constructor, "name", {
       value: error,
     });
-
     Object.defineProperty(acc[error].constructor, "name", {
       value: error,
     });
-
     Object.defineProperty(acc[error].prototype, "name", {
       value: error,
     });
-
     Object.defineProperty(acc[error], "name", {
       value: error,
     });
-
     return acc;
-  }, {} as DefinedErrors<ErrorName>);
+  }, {});
+
+export { BunWorkspacesError, defineErrors };

package/src/internal/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./asyncIterable/asyncIterableQueue";
+export type * from "./types";
+export * from "./error";
+export * from "./json/json";
+export * from "./asyncIterable/mergeAsyncIterables";
+export * from "./optionalArray";
+export * from "./regex";

package/src/internal/core/index.mjs

@@ -0,0 +1,6 @@
+export * from "./asyncIterable/asyncIterableQueue.mjs";
+export * from "./error.mjs";
+export * from "./json/json.mjs";
+export * from "./asyncIterable/mergeAsyncIterables.mjs";
+export * from "./optionalArray.mjs";
+export * from "./regex.mjs"; // CONCATENATED MODULE: ./src/internal/core/index.ts

package/src/internal/core/json/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./json";
+export * from "./jsonc";

package/src/internal/core/json/index.mjs

@@ -0,0 +1,2 @@
+export * from "./json.mjs";
+export * from "./jsonc.mjs"; // CONCATENATED MODULE: ./src/internal/core/json/index.ts

package/src/internal/core/json/json.d.ts

@@ -0,0 +1,9 @@
+export type JSONData = JSONPrimitive | JSONObject | JSONArray;
+export type JSONPrimitive = string | number | boolean | null;
+export interface JSONObject {
+  [key: string]: JSONData;
+}
+export type JSONArray = JSONData[];
+export declare const isJsonObject: <T extends JSONObject = JSONObject>(
+  value: unknown,
+) => value is T;

package/src/internal/core/json/json.mjs

@@ -0,0 +1,6 @@
+// CONCATENATED MODULE: ./src/internal/core/json/json.ts
+const isJsonObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+
+export { isJsonObject };

package/src/internal/core/json/jsonc.d.ts

@@ -0,0 +1,9 @@
+export declare const convertJsoncToJson: (
+  jsonString: string,
+  {
+    whitespace,
+  }?: {
+    whitespace?: boolean | undefined;
+  },
+) => string;
+export declare const parseJsonc: (jsonString: string) => any;

package/src/internal/core/json/jsonc.mjs

@@ -0,0 +1,117 @@
+// CONCATENATED MODULE: ./src/internal/core/json/jsonc.ts
+// Code based on package strip-json-comments
+const stripWithoutWhitespace = () => "";
+// Replace all characters except ASCII spaces, tabs and line endings with regular spaces to ensure valid JSON output.
+const stripWithWhitespace = (string, start, end) =>
+  string.slice(start, end).replace(/[^ \t\r\n]/g, " ");
+const isEscaped = (jsonString, quotePosition) => {
+  let index = quotePosition - 1;
+  let backslashCount = 0;
+  while (jsonString[index] === "\\") {
+    index -= 1;
+    backslashCount += 1;
+  }
+  return Boolean(backslashCount % 2);
+};
+const convertJsoncToJson = (jsonString, { whitespace = true } = {}) => {
+  if (typeof jsonString !== "string") {
+    throw new TypeError(
+      `Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``,
+    );
+  }
+  const strip = whitespace ? stripWithWhitespace : stripWithoutWhitespace;
+  let isInsideString = false;
+  let inComment = null;
+  let offset = 0;
+  let buffer = "";
+  let result = "";
+  let commaIndex = -1;
+  for (let index = 0; index < jsonString.length; index++) {
+    const currentCharacter = jsonString[index];
+    const nextCharacter = jsonString[index + 1];
+    if (!inComment && currentCharacter === '"') {
+      // Enter or exit string
+      const escaped = isEscaped(jsonString, index);
+      if (!escaped) {
+        isInsideString = !isInsideString;
+      }
+    }
+    if (isInsideString) {
+      continue;
+    }
+    if (!inComment && currentCharacter + nextCharacter === "//") {
+      // Enter single-line comment
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      inComment = "single";
+      index++;
+    } else if (
+      inComment === "single" &&
+      currentCharacter + nextCharacter === "\r\n"
+    ) {
+      // Exit single-line comment via \r\n
+      index++;
+      inComment = null;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+      continue;
+    } else if (inComment === "single" && currentCharacter === "\n") {
+      // Exit single-line comment via \n
+      inComment = null;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+    } else if (!inComment && currentCharacter + nextCharacter === "/*") {
+      // Enter multiline comment
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      inComment = "multi";
+      index++;
+      continue;
+    } else if (
+      inComment === "multi" &&
+      currentCharacter + nextCharacter === "*/"
+    ) {
+      // Exit multiline comment
+      index++;
+      inComment = null;
+      buffer += strip(jsonString, offset, index + 1);
+      offset = index + 1;
+      continue;
+    } else if (!inComment) {
+      if (commaIndex !== -1) {
+        if (currentCharacter === "}" || currentCharacter === "]") {
+          // Strip trailing comma
+          buffer += jsonString.slice(offset, index);
+          result += strip(buffer, 0, 1) + buffer.slice(1);
+          buffer = "";
+          offset = index;
+          commaIndex = -1;
+        } else if (
+          currentCharacter !== " " &&
+          currentCharacter !== "\t" &&
+          currentCharacter !== "\r" &&
+          currentCharacter !== "\n"
+        ) {
+          // Hit non-whitespace following a comma; comma is not trailing
+          buffer += jsonString.slice(offset, index);
+          offset = index;
+          commaIndex = -1;
+        }
+      } else if (currentCharacter === ",") {
+        // Flush buffer prior to this point, and save new comma index
+        result += buffer + jsonString.slice(offset, index);
+        buffer = "";
+        offset = index;
+        commaIndex = index;
+      }
+    }
+  }
+  const remaining =
+    inComment === "single"
+      ? strip(jsonString, offset)
+      : jsonString.slice(offset);
+  return result + buffer + remaining;
+};
+const parseJsonc = (jsonString) => JSON.parse(convertJsoncToJson(jsonString));
+
+export { convertJsoncToJson, parseJsonc };

package/src/internal/core/optionalArray.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A value that may be its type T or an array of T.
+ */
+export type OptionalArray<
+  T = unknown,
+  IncludeReadonly extends boolean = false,
+> = IncludeReadonly extends true ? T | T[] | readonly T[] : T | T[];
+export type ResolvedOptionalArray<T extends OptionalArray> =
+  T extends (infer Item)[] ? Item[] : T[];
+export type ResolvedOptionalArrayItem<T extends OptionalArray> =
+  T extends (infer Item)[] ? Item : T;
+/** Resolve `OptionalArray<T>` to `T[]` */
+export declare const resolveOptionalArray: <T extends OptionalArray>(
+  value: T,
+) => ResolvedOptionalArray<T>;

package/src/internal/core/optionalArray.mjs

@@ -0,0 +1,8 @@
+// CONCATENATED MODULE: ./src/internal/core/optionalArray.ts
+/**
+ * A value that may be its type T or an array of T.
+ */ /** Resolve `OptionalArray<T>` to `T[]` */ const resolveOptionalArray = (
+  value,
+) => (value === undefined ? [] : Array.isArray(value) ? value : [value]);
+
+export { resolveOptionalArray };

package/src/internal/core/regex.d.ts

@@ -0,0 +1,3 @@
+export declare const createRawPattern: (pattern: string) => string;
+export declare const createWildcardRegex: (pattern: string) => RegExp;
+export declare const sanitizeAnsi: (text: string) => string;

package/src/internal/core/regex.mjs

@@ -0,0 +1,10 @@
+// CONCATENATED MODULE: ./src/internal/core/regex.ts
+const createRawPattern = (pattern) =>
+  pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const createWildcardRegex = (pattern) =>
+  new RegExp(`^${pattern.split("*").map(createRawPattern).join(".*")}$`);
+const sanitizeAnsi = (
+  text, // eslint-disable-next-line no-control-regex
+) => text.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+
+export { createRawPattern, createWildcardRegex, sanitizeAnsi };

package/src/internal/core/types.d.ts

@@ -0,0 +1,6 @@
+/** Does not change an object type, but remaps it for cleaner Intellisense only */
+export type Simplify<T extends object> = {
+  [K in keyof T]: T[K];
+};
+/** A normal `AsyncIterable` that is only intended for `for await` style iteration */
+export type SimpleAsyncIterable<T> = AsyncIterable<T, void, undefined>;

package/src/internal/core/types.mjs

@@ -0,0 +1,3 @@
+// CONCATENATED MODULE: ./src/internal/core/types.ts
+/** Does not change an object type, but remaps it for cleaner Intellisense only */
+/** A normal `AsyncIterable` that is only intended for `for await` style iteration */

package/src/internal/logger/index.d.ts

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

package/src/internal/logger/index.mjs

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

package/src/internal/logger/logger.d.ts

@@ -0,0 +1,44 @@
+export declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
+export type LogLevel = (typeof LOG_LEVELS)[number];
+export type LogLevelSetting = LogLevel | "silent";
+export declare const validateLogLevel: (level: LogLevelSetting) => void;
+export type LogMetadata = Record<string, unknown>;
+export interface Log<
+  Message extends string | Error = string,
+  Metadata extends LogMetadata = LogMetadata,
+> {
+  message: Message;
+  level: LogLevel;
+  metadata: Metadata;
+  time: Date;
+}
+export type Logger = {
+  name: string;
+  log<
+    Message extends string | Error = string,
+    Metadata extends LogMetadata = LogMetadata,
+  >(
+    message: Message,
+    level: LogLevel,
+    metadata?: Metadata,
+  ): Log<Message, Metadata>;
+  logOutput(
+    chunk: Uint8Array | string,
+    level: LogLevel,
+    stream: NodeJS.WriteStream,
+    prefix: string,
+  ): Log<string, Record<string, unknown>>;
+  printLevel: LogLevelSetting;
+} & {
+  [Level in LogLevel]: <
+    Message extends string | Error = string,
+    Metadata extends LogMetadata = LogMetadata,
+  >(
+    message: Message,
+    metadata?: Metadata,
+  ) => Log<Message, Metadata>;
+};
+export declare const createLogger: (name: string) => Logger;
+export declare const logger: Logger;
+/** Set the global logging level. Defaults to "info" or "error" when `NODE_ENV` is "test" */
+export declare const setLogLevel: (level: LogLevelSetting) => void;

package/src/internal/logger/logger.mjs

@@ -0,0 +1,110 @@
+import { defineErrors } from "../core/index.mjs";
+import { IS_TEST } from "../runtime/index.mjs"; // CONCATENATED MODULE: external "../core/index.mjs"
+// CONCATENATED MODULE: external "../runtime/index.mjs"
+// CONCATENATED MODULE: ./src/internal/logger/logger.ts
+
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+const getLevelNumber = (level) => LOG_LEVELS.indexOf(level);
+const ERRORS = defineErrors("InvalidLogLevel");
+const validateLogLevel = (level) => {
+  if (level === "silent") return;
+  if (!LOG_LEVELS.includes(level)) {
+    throw new ERRORS.InvalidLogLevel(
+      `Invalid log level: "${level}". Accepted values: ${LOG_LEVELS.join(", ")}`,
+    );
+  }
+};
+const createLogger = (name) => new _Logger(name);
+class _Logger {
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  log(message, level, metadata) {
+    const log = {
+      message,
+      level,
+      metadata: metadata ?? {},
+      time: new Date(),
+    };
+    if (this.shouldPrint(level)) {
+      const formattedMessage = this.formatLogMessage(message, level);
+      if (message instanceof Error) {
+        message.message = formattedMessage;
+      }
+      // eslint-disable-next-line no-console
+      console[level](
+        message instanceof Error ? message : formattedMessage,
+        ...(metadata
+          ? [
+              {
+                metadata,
+              },
+            ]
+          : []),
+      );
+    }
+    return log;
+  }
+  logOutput(chunk, level, stream, prefix) {
+    const message =
+      typeof chunk === "string"
+        ? chunk.trim()
+        : new TextDecoder().decode(chunk).trim();
+    const log = {
+      message,
+      level,
+      metadata: {
+        stream,
+        isLogOutput: true,
+      },
+      time: new Date(),
+    };
+    if (!this.shouldPrint(level)) {
+      return log;
+    }
+    const linePrefix = `${prefix}\x1b[0m`;
+    const lines = message.split(/\r?\n/);
+    lines.forEach((line) => {
+      if (line) stream.write(linePrefix + line + "\n");
+    });
+    return log;
+  }
+  debug(message, metadata) {
+    return this.log(message, "debug", metadata);
+  }
+  info(message, metadata) {
+    return this.log(message, "info", metadata);
+  }
+  warn(message, metadata) {
+    return this.log(message, "warn", metadata);
+  }
+  error(message, metadata) {
+    return this.log(message, "error", metadata);
+  }
+  get printLevel() {
+    return this._printLevel;
+  }
+  set printLevel(level) {
+    this._printLevel = level;
+  }
+  // Info prints normally for standard user-facing logs. Debug and Warn are highlighted with a prefix. Errors print as Error instances
+  formatLogMessage(message, level) {
+    const content = message instanceof Error ? message.message : message;
+    return level === "debug" || level === "warn"
+      ? `[${this.name} ${level.toUpperCase()}]: ${content}`
+      : content;
+  }
+  _printLevel = IS_TEST ? "error" : "info";
+  shouldPrint(level) {
+    if (this.printLevel === "silent") return false;
+    return getLevelNumber(level) >= getLevelNumber(this.printLevel);
+  }
+}
+const logger = createLogger("bun-workspaces");
+/** Set the global logging level. Defaults to "info" or "error" when `NODE_ENV` is "test" */ const setLogLevel =
+  (level) => {
+    logger.printLevel = level;
+  };
+
+export { LOG_LEVELS, createLogger, logger, setLogLevel, validateLogLevel };

package/src/internal/runtime/env.d.ts

@@ -0,0 +1,5 @@
+export type RuntimeMode = "development" | "production" | "test";
+export declare const RUNTIME_MODE: RuntimeMode;
+export declare const IS_TEST: boolean;
+export declare const IS_PRODUCTION: boolean;
+export declare const IS_DEVELOPMENT: boolean;

package/src/internal/runtime/env.mjs

@@ -0,0 +1,29 @@
+// CONCATENATED MODULE: ./src/internal/runtime/env.ts
+/* eslint-disable no-console */ const _process =
+  typeof process === "undefined"
+    ? {
+        env: {},
+      }
+    : process;
+const RUNTIME_MODE_VALUES = ["development", "production", "test"];
+const _RUNTIME_MODE =
+  _process.env._BW_RUNTIME_MODE ||
+  (process.env.NODE_ENV?.match(/test(ing | s)?/)
+    ? "test"
+    : process.env.NODE_ENV === "development"
+      ? "development"
+      : "production");
+const RUNTIME_MODE = RUNTIME_MODE_VALUES.includes(_RUNTIME_MODE)
+  ? _RUNTIME_MODE
+  : "production";
+if (RUNTIME_MODE !== _RUNTIME_MODE) {
+  // eslint-disable-next-line no-console
+  console.error(
+    `Env var _BW_RUNTIME_MODE has an invalid value: "${_RUNTIME_MODE}". Defaulting to "${RUNTIME_MODE}". Accepted values: ${RUNTIME_MODE_VALUES.join(", ")}.`,
+  );
+}
+const IS_TEST = RUNTIME_MODE === "test";
+const IS_PRODUCTION = RUNTIME_MODE === "production";
+const IS_DEVELOPMENT = RUNTIME_MODE === "development";
+
+export { IS_DEVELOPMENT, IS_PRODUCTION, IS_TEST, RUNTIME_MODE };

package/src/internal/runtime/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./env";
+export * from "./os";

package/src/internal/runtime/index.mjs

@@ -0,0 +1,2 @@
+export * from "./env.mjs";
+export * from "./os.mjs"; // CONCATENATED MODULE: ./src/internal/runtime/index.ts

package/src/internal/runtime/onExit.d.ts

@@ -0,0 +1,6 @@
+import type { ProcessEventMap } from "node:process";
+export declare const runOnExit: <
+  F extends (exit?: keyof ProcessEventMap | number) => unknown,
+>(
+  fn: F,
+) => void;

package/src/internal/runtime/onExit.mjs

@@ -0,0 +1,24 @@
+// CONCATENATED MODULE: ./src/internal/runtime/onExit.ts
+const runOnExit = (fn) => {
+  let ran = false;
+  const run = (exit) => {
+    if (ran) return;
+    ran = true;
+    fn(exit);
+  };
+  const onExit = (exit) => {
+    run(exit);
+    process.removeListener("exit", onExit);
+  };
+  process.on("exit", onExit);
+  for (const signal of [`SIGINT`, `SIGUSR1`, `SIGUSR2`, `SIGTERM`]) {
+    const onSignal = (signal) => {
+      run(signal);
+      process.removeListener(signal, onSignal);
+      process.kill(process.pid, signal);
+    };
+    process.on(signal, onSignal);
+  }
+};
+
+export { runOnExit };

package/src/internal/runtime/os.d.ts

@@ -0,0 +1,4 @@
+export declare const IS_WINDOWS: boolean;
+export declare const IS_MACOS: boolean;
+export declare const IS_LINUX: boolean;
+export declare const IS_UNIX: boolean;

package/src/internal/runtime/os.mjs

@@ -0,0 +1,7 @@
+// CONCATENATED MODULE: ./src/internal/runtime/os.ts
+const IS_WINDOWS = process.platform === "win32";
+const IS_MACOS = process.platform === "darwin";
+const IS_LINUX = process.platform === "linux";
+const IS_UNIX = IS_MACOS || IS_LINUX;
+
+export { IS_LINUX, IS_MACOS, IS_UNIX, IS_WINDOWS };

package/src/internal/runtime/tempFile.d.ts

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+export declare const createTempDir: (clean?: boolean) => void;
+export declare const createTempFilePath: (fileName: string) => string;
+export type CreateTempFileOptions = {
+  fileName: string;
+  fileContent: string;
+  mode?: fs.Mode;
+};
+export declare const createTempFile: ({
+  fileName,
+  fileContent,
+  mode,
+}: CreateTempFileOptions) => {
+  filePath: string;
+  cleanup: () => void;
+};