@goast/typescript 0.4.1-beta1 → 0.4.1

package/src/deps/jsr.io/@std/internal/1.0.4/assertion_state.ts

@@ -0,0 +1,111 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+/**
+ * Check the test suite internal state
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionState } from "@std/internal";
+ *
+ * const assertionState = new AssertionState();
+ * ```
+ */
+export class AssertionState {
+  #state: {
+    assertionCheck: boolean;
+    assertionTriggered: boolean;
+  };
+
+  constructor() {
+    this.#state = {
+      assertionCheck: false,
+      assertionTriggered: false,
+    };
+  }
+
+  /**
+   * If `expect.hasAssertions` called, then through this method to update #state.assertionCheck value.
+   *
+   * @param val Set #state.assertionCheck's value
+   *
+   * @example Usage
+   * ```ts ignore
+   * import { AssertionState } from "@std/internal";
+   *
+   * const assertionState = new AssertionState();
+   * assertionState.setAssertionCheck(true);
+   * ```
+   */
+  setAssertionCheck(val: boolean) {
+    this.#state.assertionCheck = val;
+  }
+
+  /**
+   * If any matchers was called, `#state.assertionTriggered` will be set through this method.
+   *
+   * @param val Set #state.assertionTriggered's value
+   *
+   * @example Usage
+   * ```ts ignore
+   * import { AssertionState } from "@std/internal";
+   *
+   * const assertionState = new AssertionState();
+   * assertionState.setAssertionTriggered(true);
+   * ```
+   */
+  setAssertionTriggered(val: boolean) {
+    this.#state.assertionTriggered = val;
+  }
+
+  /**
+   * Check Assertion internal state, if `#state.assertionCheck` is set true, but
+   * `#state.assertionTriggered` is still false, then should throw an Assertion Error.
+   *
+   * @returns a boolean value, that the test suite is satisfied with the check. If not,
+   * it should throw an AssertionError.
+   *
+   * @example Usage
+   * ```ts ignore
+   * import { AssertionState } from "@std/internal";
+   *
+   * const assertionState = new AssertionState();
+   * if (assertionState.checkAssertionErrorStateAndReset()) {
+   *   // throw AssertionError("");
+   * }
+   * ```
+   */
+  checkAssertionErrorStateAndReset(): boolean {
+    const result = this.#state.assertionCheck &&
+      !this.#state.assertionTriggered;
+
+    this.#resetAssertionState();
+
+    return result;
+  }
+
+  #resetAssertionState(): void {
+    this.#state = {
+      assertionCheck: false,
+      assertionTriggered: false,
+    };
+  }
+}
+
+const assertionState = new AssertionState();
+
+/**
+ * return an instance of AssertionState
+ *
+ * @returns AssertionState
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { getAssertionState } from "@std/internal";
+ *
+ * const assertionState = getAssertionState();
+ * assertionState.setAssertionTriggered(true);
+ * ```
+ */
+export function getAssertionState(): AssertionState {
+  return assertionState;
+}

package/src/deps/jsr.io/@std/internal/1.0.4/build_message.ts

@@ -0,0 +1,134 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { bgGreen, bgRed, bold, gray, green, red, white } from "./styles.js";
+import type { DiffResult, DiffType } from "./types.js";
+
+/**
+ * Colors the output of assertion diffs.
+ *
+ * @param diffType Difference type, either added or removed.
+ * @param background If true, colors the background instead of the text.
+ *
+ * @returns A function that colors the input string.
+ *
+ * @example Usage
+ * ```ts
+ * import { createColor } from "@std/internal";
+ * import { assertEquals } from "@std/assert";
+ * import { bold, green, red, white } from "@std/fmt/colors";
+ *
+ * assertEquals(createColor("added")("foo"), green(bold("foo")));
+ * assertEquals(createColor("removed")("foo"), red(bold("foo")));
+ * assertEquals(createColor("common")("foo"), white("foo"));
+ * ```
+ */
+export function createColor(
+  diffType: DiffType,
+  /**
+   * TODO(@littledivy): Remove this when we can detect true color terminals. See
+   * https://github.com/denoland/deno_std/issues/2575.
+   */
+  background = false,
+): (s: string) => string {
+  switch (diffType) {
+    case "added":
+      return (s) => background ? bgGreen(white(s)) : green(bold(s));
+    case "removed":
+      return (s) => background ? bgRed(white(s)) : red(bold(s));
+    default:
+      return white;
+  }
+}
+
+/**
+ * Prefixes `+` or `-` in diff output.
+ *
+ * @param diffType Difference type, either added or removed
+ *
+ * @returns A string representing the sign.
+ *
+ * @example Usage
+ * ```ts
+ * import { createSign } from "@std/internal";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(createSign("added"), "+   ");
+ * assertEquals(createSign("removed"), "-   ");
+ * assertEquals(createSign("common"), "    ");
+ * ```
+ */
+export function createSign(diffType: DiffType): string {
+  switch (diffType) {
+    case "added":
+      return "+   ";
+    case "removed":
+      return "-   ";
+    default:
+      return "    ";
+  }
+}
+
+/** Options for {@linkcode buildMessage}. */
+export interface BuildMessageOptions {
+  /**
+   * Whether to output the diff as a single string.
+   *
+   * @default {false}
+   */
+  stringDiff?: boolean;
+}
+
+/**
+ * Builds a message based on the provided diff result.
+ *
+ * @param diffResult The diff result array.
+ * @param options Optional parameters for customizing the message.
+ *
+ * @returns An array of strings representing the built message.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { diffStr, buildMessage } from "@std/internal";
+ *
+ * const diffResult = diffStr("Hello, world!", "Hello, world");
+ *
+ * console.log(buildMessage(diffResult));
+ * // [
+ * //   "",
+ * //   "",
+ * //   "    [Diff] Actual / Expected",
+ * //   "",
+ * //   "",
+ * //   "-   Hello, world!",
+ * //   "+   Hello, world",
+ * //   "",
+ * // ]
+ * ```
+ */
+export function buildMessage(
+  diffResult: ReadonlyArray<DiffResult<string>>,
+  options: BuildMessageOptions = {},
+): string[] {
+  const { stringDiff = false } = options;
+  const messages = [
+    "",
+    "",
+    `    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${
+      green(bold("Expected"))
+    }`,
+    "",
+    "",
+  ];
+  const diffMessages = diffResult.map((result) => {
+    const color = createColor(result.type);
+    const line = result.details?.map((detail) =>
+      detail.type !== "common"
+        ? createColor(detail.type, true)(detail.value)
+        : detail.value
+    ).join("") ?? result.value;
+    return color(`${createSign(result.type)}${line}`);
+  });
+  messages.push(...(stringDiff ? [diffMessages.join("")] : diffMessages), "");
+  return messages;
+}

package/src/deps/jsr.io/@std/internal/1.0.4/diff.ts

@@ -0,0 +1,317 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import type { DiffResult, DiffType } from "./types.js";
+
+/** Represents the farthest point in the diff algorithm. */
+export interface FarthestPoint {
+  /** The y-coordinate of the point. */
+  y: number;
+  /** The id of the point. */
+  id: number;
+}
+
+const REMOVED = 1;
+const COMMON = 2;
+const ADDED = 3;
+
+/**
+ * Creates an array of common elements between two arrays.
+ *
+ * @typeParam T The type of elements in the arrays.
+ *
+ * @param A The first array.
+ * @param B The second array.
+ *
+ * @returns An array containing the common elements between the two arrays.
+ *
+ * @example Usage
+ * ```ts
+ * import { createCommon } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = [1, 2, 3];
+ * const b = [1, 2, 4];
+ *
+ * assertEquals(createCommon(a, b), [1, 2]);
+ * ```
+ */
+export function createCommon<T>(A: T[], B: T[]): T[] {
+  const common: T[] = [];
+  if (A.length === 0 || B.length === 0) return [];
+  for (let i = 0; i < Math.min(A.length, B.length); i += 1) {
+    const a = A[i];
+    const b = B[i];
+    if (a !== undefined && a === b) {
+      common.push(a);
+    } else {
+      return common;
+    }
+  }
+  return common;
+}
+
+/**
+ * Asserts that the value is a {@linkcode FarthestPoint}.
+ * If not, an error is thrown.
+ *
+ * @param value The value to check.
+ *
+ * @returns A void value that returns once the assertion completes.
+ *
+ * @example Usage
+ * ```ts
+ * import { assertFp } from "@std/internal/diff";
+ * import { assertThrows } from "@std/assert";
+ *
+ * assertFp({ y: 0, id: 0 });
+ * assertThrows(() => assertFp({ id: 0 }));
+ * assertThrows(() => assertFp({ y: 0 }));
+ * assertThrows(() => assertFp(undefined));
+ * ```
+ */
+export function assertFp(value: unknown): asserts value is FarthestPoint {
+  if (
+    value == null ||
+    typeof value !== "object" ||
+    typeof (value as FarthestPoint)?.y !== "number" ||
+    typeof (value as FarthestPoint)?.id !== "number"
+  ) {
+    throw new Error(
+      `Unexpected value, expected 'FarthestPoint': received ${typeof value}`,
+    );
+  }
+}
+
+/**
+ * Creates an array of backtraced differences.
+ *
+ * @typeParam T The type of elements in the arrays.
+ *
+ * @param A The first array.
+ * @param B The second array.
+ * @param current The current {@linkcode FarthestPoint}.
+ * @param swapped Boolean indicating if the arrays are swapped.
+ * @param routes The routes array.
+ * @param diffTypesPtrOffset The offset of the diff types in the routes array.
+ *
+ * @returns An array of backtraced differences.
+ *
+ * @example Usage
+ * ```ts
+ * import { backTrace } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   backTrace([], [], { y: 0, id: 0 }, false, new Uint32Array(0), 0),
+ *   [],
+ * );
+ * ```
+ */
+export function backTrace<T>(
+  A: T[],
+  B: T[],
+  current: FarthestPoint,
+  swapped: boolean,
+  routes: Uint32Array,
+  diffTypesPtrOffset: number,
+): Array<{
+  type: DiffType;
+  value: T;
+}> {
+  const M = A.length;
+  const N = B.length;
+  const result: { type: DiffType; value: T }[] = [];
+  let a = M - 1;
+  let b = N - 1;
+  let j = routes[current.id];
+  let type = routes[current.id + diffTypesPtrOffset];
+  while (true) {
+    if (!j && !type) break;
+    const prev = j!;
+    if (type === REMOVED) {
+      result.unshift({
+        type: swapped ? "removed" : "added",
+        value: B[b]!,
+      });
+      b -= 1;
+    } else if (type === ADDED) {
+      result.unshift({
+        type: swapped ? "added" : "removed",
+        value: A[a]!,
+      });
+      a -= 1;
+    } else {
+      result.unshift({ type: "common", value: A[a]! });
+      a -= 1;
+      b -= 1;
+    }
+    j = routes[prev];
+    type = routes[prev + diffTypesPtrOffset];
+  }
+  return result;
+}
+
+/**
+ * Creates a {@linkcode FarthestPoint}.
+ *
+ * @param k The current index.
+ * @param M The length of the first array.
+ * @param routes The routes array.
+ * @param diffTypesPtrOffset The offset of the diff types in the routes array.
+ * @param ptr The current pointer.
+ * @param slide The slide {@linkcode FarthestPoint}.
+ * @param down The down {@linkcode FarthestPoint}.
+ *
+ * @returns A {@linkcode FarthestPoint}.
+ *
+ * @example Usage
+ * ```ts
+ * import { createFp } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   createFp(
+ *     0,
+ *     0,
+ *     new Uint32Array(0),
+ *     0,
+ *     0,
+ *     { y: -1, id: 0 },
+ *     { y: 0, id: 0 },
+ *   ),
+ *   { y: -1, id: 1 },
+ * );
+ * ```
+ */
+export function createFp(
+  k: number,
+  M: number,
+  routes: Uint32Array,
+  diffTypesPtrOffset: number,
+  ptr: number,
+  slide?: FarthestPoint,
+  down?: FarthestPoint,
+): FarthestPoint {
+  if (slide && slide.y === -1 && down && down.y === -1) {
+    return { y: 0, id: 0 };
+  }
+  const isAdding = (down?.y === -1) ||
+    k === M ||
+    (slide?.y ?? 0) > (down?.y ?? 0) + 1;
+  if (slide && isAdding) {
+    const prev = slide.id;
+    ptr++;
+    routes[ptr] = prev;
+    routes[ptr + diffTypesPtrOffset] = ADDED;
+    return { y: slide.y, id: ptr };
+  }
+  if (down && !isAdding) {
+    const prev = down.id;
+    ptr++;
+    routes[ptr] = prev;
+    routes[ptr + diffTypesPtrOffset] = REMOVED;
+    return { y: down.y + 1, id: ptr };
+  }
+  throw new Error("Unexpected missing FarthestPoint");
+}
+
+/**
+ * Renders the differences between the actual and expected values.
+ *
+ * @typeParam T The type of elements in the arrays.
+ *
+ * @param A Actual value
+ * @param B Expected value
+ *
+ * @returns An array of differences between the actual and expected values.
+ *
+ * @example Usage
+ * ```ts
+ * import { diff } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = [1, 2, 3];
+ * const b = [1, 2, 4];
+ *
+ * assertEquals(diff(a, b), [
+ *   { type: "common", value: 1 },
+ *   { type: "common", value: 2 },
+ *   { type: "removed", value: 3 },
+ *   { type: "added", value: 4 },
+ * ]);
+ * ```
+ */
+export function diff<T>(A: T[], B: T[]): DiffResult<T>[] {
+  const prefixCommon = createCommon(A, B);
+  A = A.slice(prefixCommon.length);
+  B = B.slice(prefixCommon.length);
+  const swapped = B.length > A.length;
+  [A, B] = swapped ? [B, A] : [A, B];
+  const M = A.length;
+  const N = B.length;
+  if (!M && !N && !prefixCommon.length) return [];
+  if (!N) {
+    return [
+      ...prefixCommon.map((value) => ({ type: "common", value })),
+      ...A.map((value) => ({ type: swapped ? "added" : "removed", value })),
+    ] as DiffResult<T>[];
+  }
+  const offset = N;
+  const delta = M - N;
+  const length = M + N + 1;
+  const fp: FarthestPoint[] = Array.from({ length }, () => ({ y: -1, id: -1 }));
+
+  /**
+   * Note: this buffer is used to save memory and improve performance. The first
+   * half is used to save route and the last half is used to save diff type.
+   */
+  const routes = new Uint32Array((M * N + length + 1) * 2);
+  const diffTypesPtrOffset = routes.length / 2;
+  let ptr = 0;
+
+  function snake<T>(
+    k: number,
+    A: T[],
+    B: T[],
+    slide?: FarthestPoint,
+    down?: FarthestPoint,
+  ): FarthestPoint {
+    const M = A.length;
+    const N = B.length;
+    const fp = createFp(k, M, routes, diffTypesPtrOffset, ptr, slide, down);
+    ptr = fp.id;
+    while (fp.y + k < M && fp.y < N && A[fp.y + k] === B[fp.y]) {
+      const prev = fp.id;
+      ptr++;
+      fp.id = ptr;
+      fp.y += 1;
+      routes[ptr] = prev;
+      routes[ptr + diffTypesPtrOffset] = COMMON;
+    }
+    return fp;
+  }
+
+  let currentFp = fp[delta + offset];
+  assertFp(currentFp);
+  let p = -1;
+  while (currentFp.y < N) {
+    p = p + 1;
+    for (let k = -p; k < delta; ++k) {
+      const index = k + offset;
+      fp[index] = snake(k, A, B, fp[index - 1], fp[index + 1]);
+    }
+    for (let k = delta + p; k > delta; --k) {
+      const index = k + offset;
+      fp[index] = snake(k, A, B, fp[index - 1], fp[index + 1]);
+    }
+    const index = delta + offset;
+    fp[delta + offset] = snake(delta, A, B, fp[index - 1], fp[index + 1]);
+    currentFp = fp[delta + offset];
+    assertFp(currentFp);
+  }
+  return [
+    ...prefixCommon.map((value) => ({ type: "common", value })),
+    ...backTrace(A, B, currentFp, swapped, routes, diffTypesPtrOffset),
+  ] as DiffResult<T>[];
+}