@goast/kotlin 0.4.5 → 0.4.7-beta1

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

@@ -1,214 +0,0 @@
-// 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: {
-    assertionCount: number | undefined;
-    assertionCheck: boolean;
-    assertionTriggered: boolean;
-    assertionTriggeredCount: number;
-  };
-
-  constructor() {
-    this.#state = {
-      assertionCount: undefined,
-      assertionCheck: false,
-      assertionTriggered: false,
-      assertionTriggeredCount: 0,
-    };
-  }
-
-  /**
-   * Get the number that through `expect.assertions` api set.
-   *
-   * @returns the number that through `expect.assertions` api set.
-   *
-   * @example Usage
-   * ```ts ignore
-   * import { AssertionState } from "@std/internal";
-   *
-   * const assertionState = new AssertionState();
-   * assertionState.assertionCount;
-   * ```
-   */
-  get assertionCount(): number | undefined {
-    return this.#state.assertionCount;
-  }
-
-  /**
-   * Get a certain number that assertions were called before.
-   *
-   * @returns return a certain number that assertions were called before.
-   *
-   * @example Usage
-   * ```ts ignore
-   * import { AssertionState } from "@std/internal";
-   *
-   * const assertionState = new AssertionState();
-   * assertionState.assertionTriggeredCount;
-   * ```
-   */
-  get assertionTriggeredCount(): number {
-    return this.#state.assertionTriggeredCount;
-  }
-
-  /**
-   * 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;
-  }
-
-  /**
-   * If `expect.assertions` called, then through this method to update #state.assertionCheck value.
-   *
-   * @param num Set #state.assertionCount's value, for example if the value is set 2, that means
-   * you must have two assertion matchers call in your test suite.
-   *
-   * @example Usage
-   * ```ts ignore
-   * import { AssertionState } from "@std/internal";
-   *
-   * const assertionState = new AssertionState();
-   * assertionState.setAssertionCount(2);
-   * ```
-   */
-  setAssertionCount(num: number) {
-    this.#state.assertionCount = num;
-  }
-
-  /**
-   * If any matchers was called, `#state.assertionTriggeredCount` value will plus one internally.
-   *
-   * @example Usage
-   * ```ts ignore
-   * import { AssertionState } from "@std/internal";
-   *
-   * const assertionState = new AssertionState();
-   * assertionState.updateAssertionTriggerCount();
-   * ```
-   */
-  updateAssertionTriggerCount() {
-    if (this.#state.assertionCount !== undefined) {
-      this.#state.assertionTriggeredCount += 1;
-    }
-  }
-
-  /**
-   * 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.checkAssertionErrorState()) {
-   *   // throw AssertionError("");
-   * }
-   * ```
-   */
-  checkAssertionErrorState(): boolean {
-    return this.#state.assertionCheck && !this.#state.assertionTriggered;
-  }
-
-  /**
-   * Reset all assertion state when every test suite function ran completely.
-   *
-   * @example Usage
-   * ```ts ignore
-   * import { AssertionState } from "@std/internal";
-   *
-   * const assertionState = new AssertionState();
-   * assertionState.resetAssertionState();
-   * ```
-   */
-  resetAssertionState(): void {
-    this.#state = {
-      assertionCount: undefined,
-      assertionCheck: false,
-      assertionTriggered: false,
-      assertionTriggeredCount: 0,
-    };
-  }
-
-  /**
-   * Check Assertion called state, if `#state.assertionCount` is set to a number value, but
-   * `#state.assertionTriggeredCount` is less then it, 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.checkAssertionCountSatisfied()) {
-   *   // throw AssertionError("");
-   * }
-   * ```
-   */
-  checkAssertionCountSatisfied(): boolean {
-    return this.#state.assertionCount !== undefined &&
-      this.#state.assertionCount !== this.#state.assertionTriggeredCount;
-  }
-}
-
-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.5/build_message.ts

@@ -1,134 +0,0 @@
-// 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.5/diff.ts

@@ -1,317 +0,0 @@
-// 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>[];
-}