bun-workspaces 1.0.1-alpha → 1.0.2

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

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

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

@@ -1,38 +1,36 @@
-export class BunWorkspacesError extends Error {
+// CONCATENATED MODULE: ./src/internal/core/error/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> =>
-  errors.reduce((acc, error) => {
-    acc[error] = class extends BunWorkspacesError {
-      constructor(message?: string) {
+function defineErrors(...[parentError, ...errorNames]) {
+  let Parent = BunWorkspacesError;
+  if (typeof parentError === "function") {
+    Parent = parentError;
+  } else {
+    errorNames.unshift(parentError);
+  }
+  return errorNames.reduce((acc, error) => {
+    acc[error] = class extends Parent {
+      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/error/index.d.ts

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

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

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

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

@@ -0,0 +1,4 @@
+export * from "./language";
+export * from "./error";
+export * from "./json";
+export * from "./runtime";

package/src/internal/core/index.mjs

@@ -0,0 +1,4 @@
+export * from "./language/index.mjs";
+export * from "./error/index.mjs";
+export * from "./json/index.mjs";
+export * from "./runtime/index.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,49 @@
+type JSONPrimitiveMap = {
+  string: string;
+  number: number;
+  boolean: boolean;
+  null: null;
+};
+export type JSONPrimitiveName = keyof JSONPrimitiveMap;
+export type JSONPrimitiveToName<P extends JSONPrimitive> = {
+  [key in keyof JSONPrimitiveMap]: P extends JSONPrimitiveMap[key]
+    ? key
+    : never;
+}[keyof JSONPrimitiveMap];
+export type NameToJSONPrimitive<Name extends JSONPrimitiveName> =
+  JSONPrimitiveMap[Name];
+export type JSONPrimitive<N extends JSONPrimitiveName = JSONPrimitiveName> =
+  NameToJSONPrimitive<N>;
+export interface JSONObject {
+  [key: string]: JSONData;
+}
+export type JSONItem = JSONPrimitive | JSONObject;
+export type JSONArrayItem =
+  | JSONItem
+  | JSONItem[]
+  | JSONItem[][]
+  | JSONItem[][][]
+  | JSONItem[][][][]
+  | JSONItem[][][][][]
+  | JSONItem[][][][][][]
+  | JSONItem[][][][][][][]
+  | JSONItem[][][][][][][][]
+  | JSONItem[][][][][][][][][]
+  | JSONItem[][][][][][][][][][]
+  | JSONItem[][][][][][][][][][][];
+export type JSONArray<Item extends JSONArrayItem = JSONArrayItem> = Item[];
+export type JSONArrayToItem<A extends JSONArray> = A extends (infer Item)[]
+  ? Item
+  : never;
+export type JSONData = JSONPrimitive | JSONObject | JSONArray;
+export declare const isJSONPrimitive: (
+  value: unknown,
+) => value is JSONPrimitive;
+export declare const isJSONArray: <T extends JSONArray = JSONArray>(
+  value: unknown,
+) => value is T;
+export declare const isJSONObject: <T extends JSONObject = JSONObject>(
+  value: unknown,
+) => value is T;
+export declare const isJSON: (value: unknown) => value is JSONData;
+export {};

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

@@ -0,0 +1,12 @@
+import { isTypeof } from "../language/index.mjs"; // CONCATENATED MODULE: external "../language/index.mjs"
+// CONCATENATED MODULE: ./src/internal/core/json/json.ts
+
+const isJSONPrimitive = (value) =>
+  isTypeof(value, "string", "number", "boolean") || value === null;
+const isJSONArray = (value) => Array.isArray(value) && value.every(isJSON);
+const isJSONObject = (value) =>
+  typeof value === "object" && value !== null && value?.constructor === Object;
+const isJSON = (value) =>
+  isJSONPrimitive(value) || isJSONArray(value) || isJSONObject(value);
+
+export { isJSON, isJSONArray, isJSONObject, isJSONPrimitive };

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/language/array/index.d.ts

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

package/src/internal/core/language/array/index.mjs

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

package/src/internal/core/language/array/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/language/array/optionalArray.mjs

@@ -0,0 +1,8 @@
+// CONCATENATED MODULE: ./src/internal/core/language/array/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/language/asyncIterable/asyncIterableQueue.d.ts

@@ -0,0 +1,16 @@
+import type { SimpleAsyncIterable } from "../types";
+export type AsyncQueueItem<T> =
+  | {
+      type: "value";
+      value: T;
+    }
+  | {
+      type: "done";
+    };
+export declare const createAsyncIterableQueue: <
+  T,
+>() => SimpleAsyncIterable<T> & {
+  push: (value: T) => void;
+  close: () => void;
+  closed: Promise<void>;
+};

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

@@ -0,0 +1,81 @@
+// CONCATENATED MODULE: ./src/internal/core/language/asyncIterable/asyncIterableQueue.ts
+const createAsyncIterableQueue = () => {
+  let resolveClose = () => {
+    void 0;
+  };
+  const closePromise = new Promise((resolve) => {
+    resolveClose = resolve;
+  });
+  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",
+      });
+    }
+    resolveClose();
+  };
+  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,
+    closed: closePromise,
+  };
+  return iterator;
+};
+
+export { createAsyncIterableQueue };

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

@@ -0,0 +1,2 @@
+export * from "./asyncIterableQueue";
+export * from "./mergeAsyncIterables";

package/src/internal/core/language/asyncIterable/index.mjs

@@ -0,0 +1,2 @@
+export * from "./asyncIterableQueue.mjs";
+export * from "./mergeAsyncIterables.mjs"; // CONCATENATED MODULE: ./src/internal/core/language/asyncIterable/index.ts

package/src/internal/core/language/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/language/asyncIterable/mergeAsyncIterables.mjs

@@ -0,0 +1,27 @@
+// CONCATENATED MODULE: ./src/internal/core/language/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/language/events/typedEventTarget.d.ts

@@ -0,0 +1,50 @@
+export type TypedEvent<
+  TypeName extends string = string,
+  ExtraProperties extends object = object,
+> = Event & {
+  type: TypeName;
+} & ExtraProperties;
+export declare const TypedEvent: {
+  prototype: TypedEvent;
+  new <TypeName extends string = string>(
+    type: TypeName,
+    options?: EventInit,
+  ): TypedEvent<TypeName>;
+};
+type ExtraProperties<E> =
+  E extends TypedEvent<string, infer ExtraProperties>
+    ? Omit<ExtraProperties, "type">
+    : undefined;
+export declare const createTypedEventFactory: <
+  E extends TypedEvent = TypedEvent,
+>(
+  type: E["type"],
+) => (properties: ExtraProperties<E>, options?: EventInit) => E;
+export type EventConfig = {
+  [key: string]: TypedEvent;
+};
+type EventFromName<
+  E extends keyof Config,
+  Config extends EventConfig,
+> = Config[E];
+export interface TypedEventTarget<Config extends EventConfig = EventConfig> {
+  addEventListener<EventName extends keyof Config>(
+    event: EventName,
+    listener: (event: EventFromName<EventName, Config>) => unknown,
+  ): void;
+  removeEventListener<EventName extends keyof Config>(
+    event: EventName,
+    listener: (event: EventFromName<EventName, Config>) => unknown,
+  ): void;
+  dispatchEvent<EventName extends keyof Config>(
+    event: EventFromName<EventName, Config>,
+  ): boolean;
+}
+/**
+ * An EventTarget with typing for specific events.
+ */
+export declare const TypedEventTarget: {
+  prototype: TypedEventTarget;
+  new <Config extends EventConfig = EventConfig>(): TypedEventTarget<Config>;
+};
+export {};

package/src/internal/core/language/events/typedEventTarget.mjs

@@ -0,0 +1,14 @@
+// CONCATENATED MODULE: ./src/internal/core/language/events/typedEventTarget.ts
+const TypedEvent = Event;
+const createTypedEventFactory = (type) => (properties, options) => {
+  const event = new TypedEvent(type, options);
+  for (const key in properties) {
+    event[key] = properties[key];
+  }
+  return event;
+};
+/**
+ * An EventTarget with typing for specific events.
+ */ const TypedEventTarget = EventTarget;
+
+export { TypedEvent, TypedEventTarget, createTypedEventFactory };

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

@@ -0,0 +1,5 @@
+export * from "./asyncIterable";
+export * from "./array";
+export * from "./types";
+export * from "./regex";
+export * from "./string";

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

@@ -0,0 +1,5 @@
+export * from "./asyncIterable/index.mjs";
+export * from "./array/index.mjs";
+export * from "./types/index.mjs";
+export * from "./regex/index.mjs";
+export * from "./string/index.mjs"; // CONCATENATED MODULE: ./src/internal/core/language/index.ts

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

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

package/src/internal/core/language/regex/index.mjs

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

package/src/internal/core/language/regex/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/language/regex/regex.mjs

@@ -0,0 +1,10 @@
+// CONCATENATED MODULE: ./src/internal/core/language/regex/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/language/string/id.d.ts

@@ -0,0 +1 @@
+export declare const createShortId: (bytes?: number) => string;

package/src/internal/core/language/string/id.mjs

@@ -0,0 +1,10 @@
+// CONCATENATED MODULE: ./src/internal/core/language/string/id.ts
+const createShortId = (bytes = 12) => {
+  const buf = new Uint8Array(bytes);
+  crypto.getRandomValues(buf);
+  return Buffer.from(buf)
+    .toString("base64url")
+    .slice(0, Math.ceil((bytes * 4) / 3));
+};
+
+export { createShortId };

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

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

package/src/internal/core/language/string/index.mjs

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

package/src/internal/core/language/string/utf/eastAsianWidth.d.ts

@@ -0,0 +1,16 @@
+/** A port of the package eastasianwidth */
+export declare const eaw: {
+  /**
+   * F: Full width
+   * H: Half width
+   * W: Wide
+   * Na: Narrow
+   * A: Ambiguous
+   * N: Neutral
+   */
+  eastAsianWidth: (character: string) => "F" | "H" | "W" | "Na" | "A" | "N";
+  characterLength: (character: string) => 1 | 2;
+  stringToArray: (s: string) => [] | RegExpMatchArray;
+  length: (string: string) => number;
+  slice: (text: string, start: number, end: number) => string;
+};