@goast/core 0.4.0 → 0.4.1

package/src/deps/jsr.io/@std/expect/{1.0.5 → 1.0.12}/_mock_util.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2025 the Deno authors. MIT license.
 // deno-lint-ignore-file no-explicit-any
 
 export const MOCK_SYMBOL = Symbol.for("@MOCK");

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

@@ -0,0 +1,15 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+import type { SnapshotPlugin } from "./_types.js";
+
+const INTERNAL_PLUGINS: SnapshotPlugin[] = [
+  // TODO(eryue0220): support internal snapshot serializer plugins
+];
+
+export function addSerializer(plugin: SnapshotPlugin) {
+  INTERNAL_PLUGINS.unshift(plugin);
+}
+
+export function getSerializer() {
+  return INTERNAL_PLUGINS;
+}

package/src/deps/jsr.io/@std/expect/{1.0.5 → 1.0.12}/_types.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2025 the Deno authors. MIT license.
 // deno-lint-ignore-file no-explicit-any
 
 export interface MatcherContext {
@@ -177,7 +177,10 @@ export interface Expected<IsAsync = false> {
   toBeCalledWith(...expected: unknown[]): void;
 
   /**
-   * Asserts that the value is close to the specified number within a tolerance.
+   * Asserts that a given numerical value is approximately equal to an
+   * expected number within a certain margin of error
+   * (tolerance). Useful when comparing floating-point numbers, which
+   * may be represented internally with precision errors.
    *
    * @example Usage
    * ```ts
@@ -189,7 +192,8 @@ export interface Expected<IsAsync = false> {
    * ```
    *
    * @param candidate The candidate number.
-   * @param tolerance The tolerance value (optional).
+   * @param tolerance The number of significant decimal digits to
+   *   consider when comparing the values (optional, default 2).
    */
   toBeCloseTo(candidate: number, tolerance?: number): void;
 
@@ -915,3 +919,5 @@ export interface OldSnapshotPlugin {
   ) => string;
   test: Test;
 }
+
+export type SnapshotPlugin = NewSnapshotPlugin | OldSnapshotPlugin;

package/src/deps/jsr.io/@std/expect/{1.0.5 → 1.0.12}/_utils.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2025 the Deno authors. MIT license.
 // Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved. MIT license.
 
 import type { EqualOptions, EqualOptionUtil } from "./_types.js";
@@ -40,6 +40,40 @@ function isObject(a: unknown) {
   return a !== null && typeof a === "object";
 }
 
+function isObjectWithKeys(a: unknown) {
+  return (
+    isObject(a) &&
+    !(a instanceof Error) &&
+    !Array.isArray(a) &&
+    !(a instanceof Date) &&
+    !(a instanceof Set) &&
+    !(a instanceof Map)
+  );
+}
+
+function getObjectKeys(object: object): Array<string | symbol> {
+  return [
+    ...Object.keys(object),
+    ...Object.getOwnPropertySymbols(object).filter(
+      (s) => Object.getOwnPropertyDescriptor(object, s)?.enumerable,
+    ),
+  ];
+}
+
+function hasPropertyInObject(object: object, key: string | symbol): boolean {
+  const shouldTerminate = !object || typeof object !== "object" ||
+    object === Object.prototype;
+
+  if (shouldTerminate) {
+    return false;
+  }
+
+  return (
+    Object.prototype.hasOwnProperty.call(object, key) ||
+    hasPropertyInObject(Object.getPrototypeOf(object), key)
+  );
+}
+
 // deno-lint-ignore no-explicit-any
 function entries(obj: any) {
   if (!isObject(obj)) return [];
@@ -199,3 +233,51 @@ export function iterableEquality(
   bStack.pop();
   return true;
 }
+
+// Ported from https://github.com/jestjs/jest/blob/442c7f692e3a92f14a2fb56c1737b26fc663a0ef/packages/expect-utils/src/utils.ts#L341
+export function subsetEquality(
+  object: unknown,
+  subset: unknown,
+  customTesters: Tester[] = [],
+): boolean | undefined {
+  const filteredCustomTesters = customTesters.filter((t) =>
+    t !== subsetEquality
+  );
+
+  const subsetEqualityWithContext =
+    (seenReferences: WeakMap<object, boolean> = new WeakMap()) =>
+    // deno-lint-ignore no-explicit-any
+    (object: any, subset: any): boolean | undefined => {
+      if (!isObjectWithKeys(subset)) {
+        return undefined;
+      }
+
+      if (seenReferences.has(subset)) return undefined;
+      seenReferences.set(subset, true);
+
+      const matchResult = getObjectKeys(subset).every((key) => {
+        if (isObjectWithKeys(subset[key])) {
+          if (seenReferences.has(subset[key])) {
+            return equal(object[key], subset[key], {
+              customTesters: filteredCustomTesters,
+            });
+          }
+        }
+        const result = object != null &&
+          hasPropertyInObject(object, key) &&
+          equal(object[key], subset[key], {
+            customTesters: [
+              ...filteredCustomTesters,
+              subsetEqualityWithContext(seenReferences),
+            ],
+          });
+        seenReferences.delete(subset[key]);
+        return result;
+      });
+      seenReferences.delete(subset);
+
+      return matchResult;
+    };
+
+  return subsetEqualityWithContext()(object, subset);
+}

package/src/deps/jsr.io/@std/expect/{1.0.5 → 1.0.12}/expect.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2025 the Deno authors. MIT license.
 // This module is browser compatible.
 // Copyright 2019 Allain Lalonde. All rights reserved. ISC License.
 // Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -13,8 +13,12 @@ import type {
   MatcherKey,
   Matchers,
 } from "./_types.js";
-import { AssertionError } from "../../assert/1.0.6/assertion_error.js";
-import { emitAssertionTrigger, hasAssertions } from "./_assertion.js";
+import { AssertionError } from "../../assert/1.0.11/assertion_error.js";
+import {
+  assertions,
+  emitAssertionTrigger,
+  hasAssertions,
+} from "./_assertions.js";
 import {
   addCustomEqualityTesters,
   getCustomEqualityTesters,
@@ -55,9 +59,10 @@ import {
   toStrictEqual,
   toThrow,
 } from "./_matchers.js";
+import { addSerializer } from "./_serializer.js";
 import { isPromiseLike } from "./_utils.js";
 import * as asymmetricMatchers from "./_asymmetric_matchers.js";
-import type { Tester } from "./_types.js";
+import type { SnapshotPlugin, Tester } from "./_types.js";
 
 export type { AnyConstructor, Async, Expected } from "./_types.js";
 
@@ -491,6 +496,7 @@ expect.stringContaining = asymmetricMatchers.stringContaining as (
 expect.stringMatching = asymmetricMatchers.stringMatching as (
   pattern: string | RegExp,
 ) => ReturnType<typeof asymmetricMatchers.stringMatching>;
+
 /**
  * `expect.hasAssertions` verifies that at least one assertion is called during a test.
  *
@@ -509,3 +515,106 @@ expect.stringMatching = asymmetricMatchers.stringMatching as (
  * ```
  */
 expect.hasAssertions = hasAssertions as () => void;
+
+/**
+ * `expect.assertions` verifies that a certain number of assertions are called during a test.
+ *
+ * Note: expect.assertions only can use in bdd function test suite, such as `test` or `it`.
+ *
+ * @example
+ * ```ts
+ *
+ * import { test } from "@std/testing/bdd";
+ * import { expect } from "@std/expect";
+ *
+ * test("it works", () => {
+ *   expect.assertions(1);
+ *   expect("a").not.toBe("b");
+ * });
+ * ```
+ */
+expect.assertions = assertions as (num: number) => void;
+
+/**
+ * `expect.objectContaining(object)` matches any received object that recursively matches the expected properties.
+ * That is, the expected object is not a subset of the received object. Therefore, it matches a received object
+ * which contains properties that are not in the expected object.
+ *
+ * @example
+ * ```ts
+ * import { expect } from "@std/expect";
+ *
+ * Deno.test("example", () => {
+ *   expect({ bar: 'baz' }).toEqual(expect.objectContaining({ bar: 'baz'}));
+ *   expect({ bar: 'baz' }).not.toEqual(expect.objectContaining({ foo: 'bar'}));
+ * });
+ * ```
+ */
+expect.objectContaining = asymmetricMatchers.objectContaining as (
+  obj: Record<string, unknown>,
+) => ReturnType<typeof asymmetricMatchers.objectContaining>;
+/**
+ * `expect.not.arrayContaining` matches a received array which does not contain
+ * all of the elements in the expected array. That is, the expected array is not
+ * a subset of the received array.
+ *
+ * `expect.not.objectContaining` matches any received object that does not recursively
+ * match the expected properties. That is, the expected object is not a subset of the
+ * received object. Therefore, it matches a received object which contains properties
+ * that are not in the expected object.
+ *
+ * `expect.not.stringContaining` matches the received value if it is not a string
+ * or if it is a string that does not contain the exact expected string.
+ *
+ * `expect.not.stringMatching` matches the received value if it is not a string
+ * or if it is a string that does not match the expected string or regular expression.
+ *
+ * @example
+ * ```ts
+ * import { expect } from "@std/expect";
+ *
+ * Deno.test("expect.not.arrayContaining", () => {
+ *   const expected = ["Samantha"];
+ *   expect(["Alice", "Bob", "Eve"]).toEqual(expect.not.arrayContaining(expected));
+ * });
+ *
+ * Deno.test("expect.not.objectContaining", () => {
+ *   const expected = { foo: "bar" };
+ *   expect({ bar: "baz" }).toEqual(expect.not.objectContaining(expected));
+ * });
+ *
+ * Deno.test("expect.not.stringContaining", () => {
+ *   const expected = "Hello world!";
+ *   expect("How are you?").toEqual(expect.not.stringContaining(expected));
+ * });
+ *
+ * Deno.test("expect.not.stringMatching", () => {
+ *   const expected = /Hello world!/;
+ *   expect("How are you?").toEqual(expect.not.stringMatching(expected));
+ * });
+ * ```
+ */
+expect.not = {
+  arrayContaining: asymmetricMatchers.arrayNotContaining,
+  objectContaining: asymmetricMatchers.objectNotContaining,
+  stringContaining: asymmetricMatchers.stringNotContaining,
+  stringMatching: asymmetricMatchers.stringNotMatching,
+};
+/**
+ * `expect.addSnapshotSerializer` adds a module that formats application-specific data structures.
+ *
+ * For an individual test file, an added module precedes any modules from snapshotSerializers configuration,
+ * which precede the default snapshot serializers for built-in JavaScript types.
+ * The last module added is the first module tested.
+ *
+ * @example
+ * ```ts
+ * import { expect } from "@std/expect";
+ * import serializerAnsi from "npm:jest-snapshot-serializer-ansi";
+ *
+ * expect.addSnapshotSerializer(serializerAnsi);
+ * ```
+ */
+expect.addSnapshotSerializer = addSerializer as (
+  plugin: SnapshotPlugin,
+) => void;

package/src/deps/jsr.io/@std/expect/{1.0.5 → 1.0.12}/fn.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2025 the Deno authors. MIT license.
 // This module is browser compatible.
 // Copyright 2019 Allain Lalonde. All rights reserved. ISC License.
 // deno-lint-ignore-file no-explicit-any ban-types

package/src/deps/jsr.io/@std/expect/{1.0.5 → 1.0.12}/mod.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2025 the Deno authors. MIT license.
 // Copyright 2019 Allain Lalonde. All rights reserved. ISC License.
 // This module is browser compatible.
 
@@ -54,26 +54,27 @@
  *   - {@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`
+ *   - `toMatchSnapshot`
  *   - `toMatchInlineSnapshot`
  *   - `toThrowErrorMatchingSnapshot`
  *   - `toThrowErrorMatchingInlineSnapshot`
- * - Asymmetric matchers:
- *   - `expect.objectContaining`
- *   - `expect.not.objectContaining`
- * - Utilities:
- *   - `expect.assertions`
- *   - `expect.addSnapshotSerializer`
  *
  * The tracking issue to add support for unsupported parts of the API is
  * {@link https://github.com/denoland/std/issues/3964}.

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/testing/{1.0.3 → 1.0.9}/_test_suite.ts

@@ -1,7 +1,18 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-/** The options for creating a test suite with the describe function. */
+// Copyright 2018-2025 the Deno authors. MIT license.
 import * as dntShim from "../../../../../_dnt.test_shims.js";
 
+
+import { getAssertionState } from "../../internal/1.0.5/assertion_state.js";
+import { AssertionError } from "../../assert/1.0.11/assertion_error.js";
+
+export const globalSanitizersState = {
+  sanitizeExit: undefined as boolean | undefined,
+  sanitizeOps: undefined as boolean | undefined,
+  sanitizeResources: undefined as boolean | undefined,
+};
+const assertionState = getAssertionState();
+
+/** The options for creating a test suite with the describe function. */
 export interface DescribeDefinition<T> extends Omit<dntShim.Deno.TestDefinition, "fn"> {
   /** The body of the test suite */
   fn?: () => void | undefined;
@@ -78,7 +89,40 @@ export class TestSuiteInternal<T> implements TestSuite<T> {
     this.symbol = Symbol();
     TestSuiteInternal.suites.set(this.symbol, this);
 
-    const { fn } = describe;
+    const { fn, ignore } = describe;
+    if (ignore) {
+      const {
+        name,
+        only,
+        permissions,
+        sanitizeExit = globalSanitizersState.sanitizeExit,
+        sanitizeOps = globalSanitizersState.sanitizeOps,
+        sanitizeResources = globalSanitizersState.sanitizeResources,
+      } = describe;
+      const options: dntShim.Deno.TestDefinition = {
+        name,
+        fn: async () => {},
+        ignore: true,
+      };
+      if (only !== undefined) {
+        options.only = only;
+      }
+      if (permissions !== undefined) {
+        options.permissions = permissions;
+      }
+      if (sanitizeExit !== undefined) {
+        options.sanitizeExit = sanitizeExit;
+      }
+      if (sanitizeOps !== undefined) {
+        options.sanitizeOps = sanitizeOps;
+      }
+      if (sanitizeResources !== undefined) {
+        options.sanitizeResources = sanitizeResources;
+      }
+      TestSuiteInternal.registerTest(options);
+      return;
+    }
+
     if (fn) {
       const temp = TestSuiteInternal.current;
       TestSuiteInternal.current = this;
@@ -102,9 +146,9 @@ export class TestSuiteInternal<T> implements TestSuite<T> {
         name,
         ignore,
         permissions,
-        sanitizeExit,
-        sanitizeOps,
-        sanitizeResources,
+        sanitizeExit = globalSanitizersState.sanitizeExit,
+        sanitizeOps = globalSanitizersState.sanitizeOps,
+        sanitizeResources = globalSanitizersState.sanitizeResources,
       } = describe;
       let { only } = describe;
       if (!ignore && this.hasOnlyStep) {
@@ -294,9 +338,9 @@ export class TestSuiteInternal<T> implements TestSuite<T> {
         fn,
         ignore,
         permissions,
-        sanitizeExit,
-        sanitizeOps,
-        sanitizeResources,
+        sanitizeExit = globalSanitizersState.sanitizeExit,
+        sanitizeOps = globalSanitizersState.sanitizeOps,
+        sanitizeResources = globalSanitizersState.sanitizeResources,
       } = step instanceof TestSuiteInternal ? step.describe : step;
 
       const options: dntShim.Deno.TestStepDefinition = {
@@ -385,5 +429,20 @@ export class TestSuiteInternal<T> implements TestSuite<T> {
     } else {
       await fn.call(context, t);
     }
+
+    if (assertionState.checkAssertionErrorState()) {
+      throw new AssertionError(
+        "Expected at least one assertion to be called but received none",
+      );
+    }
+
+    if (assertionState.checkAssertionCountSatisfied()) {
+      throw new AssertionError(
+        `Expected at least ${assertionState.assertionCount} assertion to be called, ` +
+          `but received ${assertionState.assertionTriggeredCount}`,
+      );
+    }
+
+    assertionState.resetAssertionState();
   }
 }