@goast/core 0.4.0-beta4 → 0.4.1

package/src/deps/jsr.io/@std/expect/1.0.12/mod.ts

@@ -0,0 +1,89 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2019 Allain Lalonde. All rights reserved. ISC License.
+// This module is browser compatible.
+
+/**
+ * This module provides Jest compatible expect assertion functionality.
+ *
+ * ```ts no-assert
+ * import { expect } from "@std/expect";
+ *
+ * const x = 6 * 7;
+ * expect(x).toEqual(42);
+ * expect(x).not.toEqual(0);
+ *
+ * await expect(Promise.resolve(x)).resolves.toEqual(42);
+ * ```
+ *
+ * Currently this module supports the following functions:
+ * - Common matchers:
+ *   - {@linkcode Expected.toBe | toBe}
+ *   - {@linkcode Expected.toEqual | toEqual}
+ *   - {@linkcode Expected.toStrictEqual | toStrictEqual}
+ *   - {@linkcode Expected.toMatch | toMatch}
+ *   - {@linkcode Expected.toMatchObject | toMatchObject}
+ *   - {@linkcode Expected.toBeDefined | toBeDefined}
+ *   - {@linkcode Expected.toBeUndefined | toBeUndefined}
+ *   - {@linkcode Expected.toBeNull | toBeNull}
+ *   - {@linkcode Expected.toBeNaN | toBeNaN}
+ *   - {@linkcode Expected.toBeTruthy | toBeTruthy}
+ *   - {@linkcode Expected.toBeFalsy | toBeFalsy}
+ *   - {@linkcode Expected.toContain | toContain}
+ *   - {@linkcode Expected.toContainEqual | toContainEqual}
+ *   - {@linkcode Expected.toHaveLength | toHaveLength}
+ *   - {@linkcode Expected.toBeGreaterThan | toBeGreaterThan}
+ *   - {@linkcode Expected.toBeGreaterThanOrEqual | toBeGreaterThanOrEqual}
+ *   - {@linkcode Expected.toBeLessThan | toBeLessThan}
+ *   - {@linkcode Expected.toBeLessThanOrEqual | toBeLessThanOrEqual}
+ *   - {@linkcode Expected.toBeCloseTo | toBeCloseTo}
+ *   - {@linkcode Expected.toBeInstanceOf | toBeInstanceOf}
+ *   - {@linkcode Expected.toThrow | toThrow}
+ *   - {@linkcode Expected.toHaveProperty | toHaveProperty}
+ * - Mock related matchers:
+ *   - {@linkcode Expected.toHaveBeenCalled | toHaveBeenCalled}
+ *   - {@linkcode Expected.toHaveBeenCalledTimes | toHaveBeenCalledTimes}
+ *   - {@linkcode Expected.toHaveBeenCalledWith | toHaveBeenCalledWith}
+ *   - {@linkcode Expected.toHaveBeenLastCalledWith | toHaveBeenLastCalledWith}
+ *   - {@linkcode Expected.toHaveBeenNthCalledWith | toHaveBeenNthCalledWith}
+ *   - {@linkcode Expected.toHaveReturned | toHaveReturned}
+ *   - {@linkcode Expected.toHaveReturnedTimes | toHaveReturnedTimes}
+ *   - {@linkcode Expected.toHaveReturnedWith | toHaveReturnedWith}
+ *   - {@linkcode Expected.toHaveLastReturnedWith | toHaveLastReturnedWith}
+ *   - {@linkcode Expected.toHaveNthReturnedWith | toHaveNthReturnedWith}
+ * - Asymmetric matchers:
+ *   - {@linkcode expect.anything}
+ *   - {@linkcode expect.any}
+ *   - {@linkcode expect.arrayContaining}
+ *   - {@linkcode expect.not.arrayContaining}
+ *   - {@linkcode expect.objectContaining}
+ *   - {@linkcode expect.not.objectContaining}
+ *   - {@linkcode expect.closeTo}
+ *   - {@linkcode expect.stringContaining}
+ *   - {@linkcode expect.not.stringContaining}
+ *   - {@linkcode expect.stringMatching}
+ *   - {@linkcode expect.not.stringMatching}
+ * - Utilities:
+ *   - {@linkcode expect.addSnapshotSerializer}
+ *   - {@linkcode expect.assertions}
+ *   - {@linkcode expect.addEqualityTester}
+ *   - {@linkcode expect.extend}
+ *   - {@linkcode expect.hasAssertions}
+ *
+ * Only these functions are still not available:
+ * - Matchers:
+ *   - `toMatchSnapshot`
+ *   - `toMatchInlineSnapshot`
+ *   - `toThrowErrorMatchingSnapshot`
+ *   - `toThrowErrorMatchingInlineSnapshot`
+ *
+ * The tracking issue to add support for unsupported parts of the API is
+ * {@link https://github.com/denoland/std/issues/3964}.
+ *
+ * This module is largely inspired by
+ * {@link https://github.com/allain/expect | x/expect} module by
+ * {@link https://github.com/allain | Allain Lalonde}.
+ *
+ * @module
+ */
+export * from "./expect.js";
+export * from "./fn.js";

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

@@ -0,0 +1,214 @@
+// 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

@@ -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;
+}