@goast/typescript 0.4.3 → 0.5.0

package/src/deps/jsr.io/@std/expect/1.0.13/_asymmetric_matchers.ts

@@ -0,0 +1,198 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// deno-lint-ignore-file no-explicit-any
+
+import { getCustomEqualityTesters } from "./_custom_equality_tester.js";
+import { equal } from "./_equal.js";
+
+export abstract class AsymmetricMatcher<T> {
+  constructor(
+    protected value: T,
+    protected inverse: boolean = false,
+  ) {}
+  abstract equals(other: unknown): boolean;
+}
+
+export class Anything extends AsymmetricMatcher<void> {
+  equals(other: unknown): boolean {
+    return other !== null && other !== undefined;
+  }
+}
+
+export function anything(): Anything {
+  return new Anything();
+}
+
+export class Any extends AsymmetricMatcher<any> {
+  constructor(value: unknown) {
+    if (value === undefined) {
+      throw new TypeError("Expected a constructor function");
+    }
+    super(value);
+  }
+
+  equals(other: unknown): boolean {
+    if (typeof other === "object") {
+      return other instanceof this.value;
+    } else {
+      if (this.value === Number) {
+        return typeof other === "number";
+      }
+
+      if (this.value === String) {
+        return typeof other === "string";
+      }
+
+      if (this.value === Number) {
+        return typeof other === "number";
+      }
+
+      if (this.value === Function) {
+        return typeof other === "function";
+      }
+
+      if (this.value === Boolean) {
+        return typeof other === "boolean";
+      }
+
+      if (this.value === BigInt) {
+        return typeof other === "bigint";
+      }
+
+      if (this.value === Symbol) {
+        return typeof other === "symbol";
+      }
+    }
+    return false;
+  }
+}
+
+export function any(c: unknown): Any {
+  return new Any(c);
+}
+
+export class ArrayContaining extends AsymmetricMatcher<any[]> {
+  constructor(arr: any[], inverse = false) {
+    super(arr, inverse);
+  }
+
+  equals(other: any[]): boolean {
+    const res = Array.isArray(other) &&
+      this.value.every((e) =>
+        other.some((another) =>
+          equal(e, another, { customTesters: getCustomEqualityTesters() })
+        )
+      );
+    return this.inverse ? !res : res;
+  }
+}
+
+export function arrayContaining(c: any[]): ArrayContaining {
+  return new ArrayContaining(c);
+}
+
+export function arrayNotContaining(c: any[]): ArrayContaining {
+  return new ArrayContaining(c, true);
+}
+
+export class CloseTo extends AsymmetricMatcher<number> {
+  readonly #precision: number;
+
+  constructor(num: number, precision: number = 2) {
+    super(num);
+    this.#precision = precision;
+  }
+
+  equals(other: number): boolean {
+    if (typeof other !== "number") {
+      return false;
+    }
+
+    if (
+      (this.value === Number.POSITIVE_INFINITY &&
+        other === Number.POSITIVE_INFINITY) ||
+      (this.value === Number.NEGATIVE_INFINITY &&
+        other === Number.NEGATIVE_INFINITY)
+    ) {
+      return true;
+    }
+
+    return Math.abs(this.value - other) < Math.pow(10, -this.#precision) / 2;
+  }
+}
+
+export function closeTo(num: number, numDigits?: number): CloseTo {
+  return new CloseTo(num, numDigits);
+}
+
+export class StringContaining extends AsymmetricMatcher<string> {
+  constructor(str: string, inverse = false) {
+    super(str, inverse);
+  }
+
+  equals(other: string): boolean {
+    const res = typeof other !== "string" ? false : other.includes(this.value);
+    return this.inverse ? !res : res;
+  }
+}
+
+export function stringContaining(str: string): StringContaining {
+  return new StringContaining(str);
+}
+
+export function stringNotContaining(str: string): StringContaining {
+  return new StringContaining(str, true);
+}
+
+export class StringMatching extends AsymmetricMatcher<RegExp> {
+  constructor(pattern: string | RegExp, inverse = false) {
+    super(new RegExp(pattern), inverse);
+  }
+
+  equals(other: string): boolean {
+    const res = typeof other !== "string" ? false : this.value.test(other);
+    return this.inverse ? !res : res;
+  }
+}
+
+export function stringMatching(pattern: string | RegExp): StringMatching {
+  return new StringMatching(pattern);
+}
+
+export function stringNotMatching(pattern: string | RegExp): StringMatching {
+  return new StringMatching(pattern, true);
+}
+
+export class ObjectContaining
+  extends AsymmetricMatcher<Record<string, unknown>> {
+  constructor(obj: Record<string, unknown>, inverse = false) {
+    super(obj, inverse);
+  }
+
+  equals(other: Record<string, unknown>): boolean {
+    const keys = Object.keys(this.value);
+    let res = true;
+
+    for (const key of keys) {
+      if (
+        !Object.hasOwn(other, key) ||
+        !equal(this.value[key], other[key])
+      ) {
+        res = false;
+      }
+    }
+
+    return this.inverse ? !res : res;
+  }
+}
+
+export function objectContaining(
+  obj: Record<string, unknown>,
+): ObjectContaining {
+  return new ObjectContaining(obj);
+}
+
+export function objectNotContaining(
+  obj: Record<string, unknown>,
+): ObjectContaining {
+  return new ObjectContaining(obj, true);
+}

package/src/deps/jsr.io/@std/expect/1.0.13/_build_message.ts

@@ -0,0 +1,51 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+import { buildMessage } from "../../internal/1.0.5/build_message.js";
+import { diff } from "../../internal/1.0.5/diff.js";
+import { diffStr } from "../../internal/1.0.5/diff_str.js";
+import { format } from "../../internal/1.0.5/format.js";
+import type { EqualOptions } from "./_types.js";
+
+type EqualErrorMessageOptions = Pick<
+  EqualOptions,
+  "formatter" | "msg"
+>;
+
+function isString(value: unknown): value is string {
+  return typeof value === "string";
+}
+
+export function buildEqualErrorMessage<T>(
+  actual: T,
+  expected: T,
+  options: EqualErrorMessageOptions,
+): string {
+  const { formatter = format, msg } = options ?? {};
+  const msgPrefix = msg ? `${msg}: ` : "";
+  const actualString = formatter(actual);
+  const expectedString = formatter(expected);
+
+  let message = `${msgPrefix}Values are not equal.`;
+
+  const stringDiff = isString(actual) && isString(expected);
+  const diffResult = stringDiff
+    ? diffStr(actual, expected)
+    : diff(actualString.split("\n"), expectedString.split("\n"));
+  const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
+  message = `${message}\n${diffMsg}`;
+
+  return message;
+}
+
+export function buildNotEqualErrorMessage<T>(
+  actual: T,
+  expected: T,
+  options: EqualErrorMessageOptions,
+): string {
+  const { msg } = options ?? {};
+  const actualString = String(actual);
+  const expectedString = String(expected);
+
+  const msgPrefix = msg ? `${msg}: ` : "";
+  return `${msgPrefix}Expected actual: ${actualString} not to be: ${expectedString}.`;
+}

package/src/deps/jsr.io/@std/expect/1.0.13/_custom_equality_tester.ts

@@ -0,0 +1,19 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+import type { Tester } from "./_types.js";
+
+const customEqualityTesters: Tester[] = [];
+
+export function addCustomEqualityTesters(newTesters: Tester[]) {
+  if (!Array.isArray(newTesters)) {
+    throw new TypeError(
+      `customEqualityTester expects an array of Testers. But got ${typeof newTesters}`,
+    );
+  }
+
+  customEqualityTesters.push(...newTesters);
+}
+
+export function getCustomEqualityTesters() {
+  return customEqualityTesters;
+}

package/src/deps/jsr.io/@std/expect/1.0.13/_equal.ts

@@ -0,0 +1,230 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+// This file is copied from `std/assert`.
+
+import type { EqualOptions } from "./_types.js";
+import { AsymmetricMatcher } from "./_asymmetric_matchers.js";
+
+type KeyedCollection = Set<unknown> | Map<unknown, unknown>;
+function isKeyedCollection(x: unknown): x is KeyedCollection {
+  return x instanceof Set || x instanceof Map;
+}
+
+function constructorsEqual(a: object, b: object) {
+  return a.constructor === b.constructor ||
+    a.constructor === Object && !b.constructor ||
+    !a.constructor && b.constructor === Object;
+}
+
+function asymmetricEqual(a: unknown, b: unknown) {
+  const asymmetricA = a instanceof AsymmetricMatcher;
+  const asymmetricB = b instanceof AsymmetricMatcher;
+
+  if (asymmetricA && asymmetricB) {
+    return undefined;
+  }
+
+  if (asymmetricA) {
+    return a.equals(b);
+  }
+
+  if (asymmetricB) {
+    return b.equals(a);
+  }
+}
+
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ * @param options for the equality check
+ */
+export function equal(c: unknown, d: unknown, options?: EqualOptions): boolean {
+  const { customTesters = [], strictCheck } = options ?? {};
+  const seen = new Map();
+
+  return (function compare(a: unknown, b: unknown): boolean {
+    const asymmetric = asymmetricEqual(a, b);
+    if (asymmetric !== undefined) {
+      return asymmetric;
+    }
+
+    if (customTesters?.length) {
+      for (const customTester of customTesters) {
+        const testContext = {
+          equal,
+        };
+        const pass = customTester.call(testContext, a, b, customTesters);
+        if (pass !== undefined) {
+          return pass;
+        }
+      }
+    }
+
+    // Have to render RegExp & Date for string comparison
+    // unless it's mistreated as object
+    if (
+      a &&
+      b &&
+      ((a instanceof RegExp && b instanceof RegExp) ||
+        (a instanceof URL && b instanceof URL))
+    ) {
+      return String(a) === String(b);
+    }
+
+    if (a instanceof Date && b instanceof Date) {
+      const aTime = a.getTime();
+      const bTime = b.getTime();
+      // Check for NaN equality manually since NaN is not
+      // equal to itself.
+      if (Number.isNaN(aTime) && Number.isNaN(bTime)) {
+        return true;
+      }
+      return aTime === bTime;
+    }
+    if (a instanceof Error && b instanceof Error) {
+      return a.message === b.message;
+    }
+    if (typeof a === "number" && typeof b === "number") {
+      return Number.isNaN(a) && Number.isNaN(b) || a === b;
+    }
+    if (a === null || b === null) {
+      return a === b;
+    }
+    const className = Object.prototype.toString.call(a);
+    if (className !== Object.prototype.toString.call(b)) {
+      return false;
+    }
+    if (Object.is(a, b)) {
+      return true;
+    }
+    if (a && typeof a === "object" && b && typeof b === "object") {
+      if (strictCheck && a && b && !constructorsEqual(a, b)) {
+        return false;
+      }
+      if (a instanceof WeakMap || b instanceof WeakMap) {
+        if (!(a instanceof WeakMap && b instanceof WeakMap)) return false;
+        throw new TypeError("Cannot compare WeakMap instances");
+      }
+      if (a instanceof WeakSet || b instanceof WeakSet) {
+        if (!(a instanceof WeakSet && b instanceof WeakSet)) return false;
+        throw new TypeError("Cannot compare WeakSet instances");
+      }
+      if (seen.get(a) === b) {
+        return true;
+      }
+
+      const aKeys = Object.keys(a ?? {});
+      const bKeys = Object.keys(b ?? {});
+      let aLen = aKeys.length;
+      let bLen = bKeys.length;
+
+      if (strictCheck && aLen !== bLen) {
+        return false;
+      }
+
+      if (!strictCheck) {
+        if (aLen > 0) {
+          for (let i = 0; i < aKeys.length; i += 1) {
+            const key = aKeys[i]!;
+            if (
+              (key in a) && (a[key as keyof typeof a] === undefined) &&
+              !(key in b)
+            ) {
+              aLen -= 1;
+            }
+          }
+        }
+
+        if (bLen > 0) {
+          for (let i = 0; i < bKeys.length; i += 1) {
+            const key = bKeys[i]!;
+            if (
+              (key in b) && (b[key as keyof typeof b] === undefined) &&
+              !(key in a)
+            ) {
+              bLen -= 1;
+            }
+          }
+        }
+      }
+
+      seen.set(a, b);
+      if (isKeyedCollection(a) && isKeyedCollection(b)) {
+        if (a.size !== b.size) {
+          return false;
+        }
+
+        const aKeys = [...a.keys()];
+        const primitiveKeysFastPath = aKeys.every((k) => {
+          return typeof k === "string" ||
+            typeof k === "number" ||
+            typeof k === "boolean" ||
+            typeof k === "bigint" ||
+            typeof k === "symbol" ||
+            k == null;
+        });
+        if (primitiveKeysFastPath) {
+          if (a instanceof Set) {
+            return a.symmetricDifference(b).size === 0;
+          }
+
+          for (const key of aKeys) {
+            if (
+              !b.has(key) ||
+              !compare(a.get(key), (b as Map<unknown, unknown>).get(key))
+            ) {
+              return false;
+            }
+          }
+          return true;
+        }
+
+        let unmatchedEntries = a.size;
+
+        for (const [aKey, aValue] of a.entries()) {
+          for (const [bKey, bValue] of b.entries()) {
+            /* Given that Map keys can be references, we need
+             * to ensure that they are also deeply equal */
+
+            if (!compare(aKey, bKey)) continue;
+
+            if (
+              (aKey === aValue && bKey === bValue) ||
+              (compare(aValue, bValue))
+            ) {
+              unmatchedEntries--;
+              break;
+            }
+          }
+        }
+
+        return unmatchedEntries === 0;
+      }
+      const merged = { ...a, ...b };
+      for (
+        const key of [
+          ...Object.getOwnPropertyNames(merged),
+          ...Object.getOwnPropertySymbols(merged),
+        ]
+      ) {
+        type Key = keyof typeof merged;
+        if (!compare(a && a[key as Key], b && b[key as Key])) {
+          return false;
+        }
+        if (
+          ((key in a) && (a[key as Key] !== undefined) && (!(key in b))) ||
+          ((key in b) && (b[key as Key] !== undefined) && (!(key in a)))
+        ) {
+          return false;
+        }
+      }
+      if (a instanceof WeakRef || b instanceof WeakRef) {
+        if (!(a instanceof WeakRef && b instanceof WeakRef)) return false;
+        return compare(a.deref(), b.deref());
+      }
+      return true;
+    }
+    return false;
+  })(c, d);
+}

package/src/deps/jsr.io/@std/expect/1.0.13/_extend.ts

@@ -0,0 +1,16 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+import type { Matchers } from "./_types.js";
+
+let extendMatchers = {};
+
+export function getExtendMatchers() {
+  return extendMatchers;
+}
+
+export function setExtendMatchers(newExtendMatchers: Matchers) {
+  extendMatchers = {
+    ...extendMatchers,
+    ...newExtendMatchers,
+  };
+}

package/src/deps/jsr.io/@std/expect/1.0.13/_inspect_args.ts

@@ -0,0 +1,15 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// deno-lint-ignore-file
+import * as dntShim from "../../../../../_dnt.test_shims.js";
+
+
+export function inspectArgs(args: unknown[]): string {
+  return args.map(inspectArg).join(", ");
+}
+
+export function inspectArg(arg: unknown): string {
+  const { Deno } = dntShim.dntGlobalThis as any;
+  return typeof Deno !== "undefined" && Deno.inspect
+    ? Deno.inspect(arg)
+    : String(arg);
+}