@gjsify/assert 0.0.4 → 0.1.0

package/lib/esm/index.js

@@ -1,6 +1,464 @@
-export * from "@gjsify/deno_std/node/assert";
-import assert from "@gjsify/deno_std/node/assert";
-var src_default = assert;
+import { AssertionError } from "./assertion-error.js";
+import { isDeepEqual, isDeepStrictEqual } from "./deep-equal.js";
+function innerFail(obj) {
+  if (obj.message instanceof Error) throw obj.message;
+  throw new AssertionError({
+    actual: obj.actual,
+    expected: obj.expected,
+    message: obj.message,
+    operator: obj.operator,
+    stackStartFn: obj.stackStartFn
+  });
+}
+function isPromiseLike(val) {
+  return val !== null && typeof val === "object" && typeof val.then === "function";
+}
+function ok(value, message) {
+  if (!value) {
+    innerFail({
+      actual: value,
+      expected: true,
+      message,
+      operator: "==",
+      stackStartFn: ok
+    });
+  }
+}
+function equal(actual, expected, message) {
+  if (actual != expected) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: "==",
+      stackStartFn: equal
+    });
+  }
+}
+function notEqual(actual, expected, message) {
+  if (actual == expected) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: "!=",
+      stackStartFn: notEqual
+    });
+  }
+}
+function strictEqual(actual, expected, message) {
+  if (!Object.is(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: "strictEqual",
+      stackStartFn: strictEqual
+    });
+  }
+}
+function notStrictEqual(actual, expected, message) {
+  if (Object.is(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: "notStrictEqual",
+      stackStartFn: notStrictEqual
+    });
+  }
+}
+function deepEqual(actual, expected, message) {
+  if (!isDeepEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: "deepEqual",
+      stackStartFn: deepEqual
+    });
+  }
+}
+function notDeepEqual(actual, expected, message) {
+  if (isDeepEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: "notDeepEqual",
+      stackStartFn: notDeepEqual
+    });
+  }
+}
+function deepStrictEqual(actual, expected, message) {
+  if (!isDeepStrictEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: "deepStrictEqual",
+      stackStartFn: deepStrictEqual
+    });
+  }
+}
+function notDeepStrictEqual(actual, expected, message) {
+  if (isDeepStrictEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: "notDeepStrictEqual",
+      stackStartFn: notDeepStrictEqual
+    });
+  }
+}
+function getActual(fn) {
+  const NO_EXCEPTION = /* @__PURE__ */ Symbol("NO_EXCEPTION");
+  try {
+    fn();
+  } catch (e) {
+    return e;
+  }
+  return NO_EXCEPTION;
+}
+async function getActualAsync(fn) {
+  const NO_EXCEPTION = /* @__PURE__ */ Symbol("NO_EXCEPTION");
+  try {
+    if (typeof fn === "function") {
+      const result = fn();
+      if (isPromiseLike(result)) {
+        await result;
+      }
+    } else {
+      await fn;
+    }
+  } catch (e) {
+    return e;
+  }
+  return NO_EXCEPTION;
+}
+function expectedException(actual, expected, message, fn) {
+  if (expected === void 0) return true;
+  if (expected instanceof RegExp) {
+    const str = String(actual);
+    if (expected.test(str)) return true;
+    throw new AssertionError({
+      actual,
+      expected,
+      message,
+      operator: fn.name,
+      stackStartFn: fn
+    });
+  }
+  if (typeof expected === "function") {
+    if (expected.prototype !== void 0 && actual instanceof expected) {
+      return true;
+    }
+    if (Error.isPrototypeOf(expected)) {
+      return false;
+    }
+    const result = expected.call({}, actual);
+    if (result !== true) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message,
+        operator: fn.name,
+        stackStartFn: fn
+      });
+    }
+    return true;
+  }
+  if (typeof expected === "object" && expected !== null) {
+    const keys = Object.keys(expected);
+    for (const key of keys) {
+      const expectedObj = expected;
+      const actualObj = actual;
+      if (typeof actualObj[key] === "string" && expectedObj[key] instanceof RegExp) {
+        if (!expectedObj[key].test(actualObj[key])) {
+          throw new AssertionError({
+            actual,
+            expected,
+            message,
+            operator: fn.name,
+            stackStartFn: fn
+          });
+        }
+      } else if (!isDeepStrictEqual(actualObj[key], expectedObj[key])) {
+        throw new AssertionError({
+          actual,
+          expected,
+          message,
+          operator: fn.name,
+          stackStartFn: fn
+        });
+      }
+    }
+    return true;
+  }
+  return true;
+}
+function throws(fn, errorOrMessage, message) {
+  if (typeof fn !== "function") {
+    throw new TypeError('The "fn" argument must be of type function.');
+  }
+  let expected;
+  if (typeof errorOrMessage === "string") {
+    message = errorOrMessage;
+    expected = void 0;
+  } else {
+    expected = errorOrMessage;
+  }
+  const actual = getActual(fn);
+  if (typeof actual === "symbol") {
+    innerFail({
+      actual: void 0,
+      expected,
+      message: message || "Missing expected exception.",
+      operator: "throws",
+      stackStartFn: throws
+    });
+  }
+  if (expected !== void 0) {
+    expectedException(actual, expected, message, throws);
+  }
+}
+function doesNotThrow(fn, errorOrMessage, message) {
+  if (typeof fn !== "function") {
+    throw new TypeError('The "fn" argument must be of type function.');
+  }
+  let expected;
+  if (typeof errorOrMessage === "string") {
+    message = errorOrMessage;
+    expected = void 0;
+  } else {
+    expected = errorOrMessage;
+  }
+  const actual = getActual(fn);
+  if (typeof actual === "symbol") {
+    return;
+  }
+  if (expected !== void 0 && typeof expected === "function" && expected.prototype !== void 0 && actual instanceof expected) {
+    innerFail({
+      actual,
+      expected,
+      message: message || `Got unwanted exception.
+${actual && actual.message ? actual.message : ""}`,
+      operator: "doesNotThrow",
+      stackStartFn: doesNotThrow
+    });
+  }
+  if (expected === void 0 || typeof expected === "function" && expected.prototype !== void 0 && actual instanceof expected) {
+    innerFail({
+      actual,
+      expected,
+      message: message || `Got unwanted exception.
+${actual && actual.message ? actual.message : ""}`,
+      operator: "doesNotThrow",
+      stackStartFn: doesNotThrow
+    });
+  }
+  throw actual;
+}
+async function rejects(asyncFn, errorOrMessage, message) {
+  let expected;
+  if (typeof errorOrMessage === "string") {
+    message = errorOrMessage;
+    expected = void 0;
+  } else {
+    expected = errorOrMessage;
+  }
+  const actual = await getActualAsync(asyncFn);
+  if (typeof actual === "symbol") {
+    innerFail({
+      actual: void 0,
+      expected,
+      message: message || "Missing expected rejection.",
+      operator: "rejects",
+      stackStartFn: rejects
+    });
+  }
+  if (expected !== void 0) {
+    expectedException(actual, expected, message, rejects);
+  }
+}
+async function doesNotReject(asyncFn, errorOrMessage, message) {
+  let expected;
+  if (typeof errorOrMessage === "string") {
+    message = errorOrMessage;
+    expected = void 0;
+  } else {
+    expected = errorOrMessage;
+  }
+  const actual = await getActualAsync(asyncFn);
+  if (typeof actual !== "symbol") {
+    innerFail({
+      actual,
+      expected,
+      message: message || `Got unwanted rejection.
+${actual && actual.message ? actual.message : ""}`,
+      operator: "doesNotReject",
+      stackStartFn: doesNotReject
+    });
+  }
+}
+function fail(actualOrMessage, expected, message, operator, stackStartFn) {
+  if (arguments.length === 0 || arguments.length === 1) {
+    const msg = arguments.length === 0 ? "Failed" : typeof actualOrMessage === "string" ? actualOrMessage : void 0;
+    if (actualOrMessage instanceof Error) throw actualOrMessage;
+    throw new AssertionError({
+      message: msg || "Failed",
+      operator: "fail",
+      stackStartFn: fail
+    });
+  }
+  throw new AssertionError({
+    actual: actualOrMessage,
+    expected,
+    message,
+    operator: operator || "fail",
+    stackStartFn: stackStartFn || fail
+  });
+}
+function ifError(value) {
+  if (value !== null && value !== void 0) {
+    let message = "ifError got unwanted exception: ";
+    if (typeof value === "object" && typeof value.message === "string") {
+      if (value.message.length === 0 && value.constructor) {
+        message += value.constructor.name;
+      } else {
+        message += value.message;
+      }
+    } else {
+      message += String(value);
+    }
+    const err = new AssertionError({
+      actual: value,
+      expected: null,
+      message,
+      operator: "ifError",
+      stackStartFn: ifError
+    });
+    const origStack = value instanceof Error ? value.stack : void 0;
+    if (origStack) {
+      err.origStack = origStack;
+    }
+    throw err;
+  }
+}
+function match(actual, expected, message) {
+  if (typeof actual !== "string") {
+    throw new TypeError('The "actual" argument must be of type string.');
+  }
+  if (!(expected instanceof RegExp)) {
+    throw new TypeError('The "expected" argument must be an instance of RegExp.');
+  }
+  if (!expected.test(actual)) {
+    innerFail({
+      actual,
+      expected,
+      message: message || `The input did not match the regular expression ${expected}. Input:
+
+'${actual}'
+`,
+      operator: "match",
+      stackStartFn: match
+    });
+  }
+}
+function doesNotMatch(actual, expected, message) {
+  if (typeof actual !== "string") {
+    throw new TypeError('The "actual" argument must be of type string.');
+  }
+  if (!(expected instanceof RegExp)) {
+    throw new TypeError('The "expected" argument must be an instance of RegExp.');
+  }
+  if (expected.test(actual)) {
+    innerFail({
+      actual,
+      expected,
+      message: message || `The input was expected to not match the regular expression ${expected}. Input:
+
+'${actual}'
+`,
+      operator: "doesNotMatch",
+      stackStartFn: doesNotMatch
+    });
+  }
+}
+const strict = Object.assign(
+  function strict2(value, message) {
+    ok(value, message);
+  },
+  {
+    AssertionError,
+    ok,
+    equal: strictEqual,
+    notEqual: notStrictEqual,
+    deepEqual: deepStrictEqual,
+    notDeepEqual: notDeepStrictEqual,
+    deepStrictEqual,
+    notDeepStrictEqual,
+    strictEqual,
+    notStrictEqual,
+    throws,
+    doesNotThrow,
+    rejects,
+    doesNotReject,
+    fail,
+    ifError,
+    match,
+    doesNotMatch,
+    strict: void 0
+  }
+);
+strict.strict = strict;
+const assert = Object.assign(
+  function assert2(value, message) {
+    ok(value, message);
+  },
+  {
+    AssertionError,
+    ok,
+    equal,
+    notEqual,
+    strictEqual,
+    notStrictEqual,
+    deepEqual,
+    notDeepEqual,
+    deepStrictEqual,
+    notDeepStrictEqual,
+    throws,
+    doesNotThrow,
+    rejects,
+    doesNotReject,
+    fail,
+    ifError,
+    match,
+    doesNotMatch,
+    strict
+  }
+);
+var index_default = assert;
 export {
-  src_default as default
+  AssertionError,
+  deepEqual,
+  deepStrictEqual,
+  index_default as default,
+  doesNotMatch,
+  doesNotReject,
+  doesNotThrow,
+  equal,
+  fail,
+  ifError,
+  match,
+  notDeepEqual,
+  notDeepStrictEqual,
+  notEqual,
+  notStrictEqual,
+  ok,
+  rejects,
+  strict,
+  strictEqual,
+  throws
 };

package/lib/esm/inspect-fallback.js

@@ -0,0 +1,75 @@
+const MAX_DEPTH = 3;
+const MAX_ARRAY_LENGTH = 10;
+const MAX_STRING_LENGTH = 128;
+function safeInspect(value, depth = MAX_DEPTH) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  switch (typeof value) {
+    case "string":
+      if (value.length > MAX_STRING_LENGTH) {
+        return `'${value.slice(0, MAX_STRING_LENGTH)}...'`;
+      }
+      return `'${value}'`;
+    case "number":
+    case "boolean":
+    case "bigint":
+      return String(value);
+    case "symbol":
+      return value.toString();
+    case "function":
+      return `[Function: ${value.name || "anonymous"}]`;
+    case "object":
+      return inspectObject(value, depth);
+  }
+  return String(value);
+}
+function inspectObject(obj, depth, seen = /* @__PURE__ */ new WeakSet()) {
+  if (seen.has(obj)) return "[Circular]";
+  seen.add(obj);
+  if (obj instanceof Date) return obj.toISOString();
+  if (obj instanceof RegExp) return obj.toString();
+  if (obj instanceof Error) return `[${obj.constructor.name}: ${obj.message}]`;
+  if (obj instanceof Map) {
+    if (depth <= 0) return `Map(${obj.size}) { ... }`;
+    const entries2 = [...obj.entries()].slice(0, MAX_ARRAY_LENGTH).map(([k, v]) => `${inspectInner(k, depth - 1, seen)} => ${inspectInner(v, depth - 1, seen)}`);
+    const suffix2 = obj.size > MAX_ARRAY_LENGTH ? ", ..." : "";
+    return `Map(${obj.size}) { ${entries2.join(", ")}${suffix2} }`;
+  }
+  if (obj instanceof Set) {
+    if (depth <= 0) return `Set(${obj.size}) { ... }`;
+    const entries2 = [...obj.values()].slice(0, MAX_ARRAY_LENGTH).map((v) => inspectInner(v, depth - 1, seen));
+    const suffix2 = obj.size > MAX_ARRAY_LENGTH ? ", ..." : "";
+    return `Set(${obj.size}) { ${entries2.join(", ")}${suffix2} }`;
+  }
+  if (ArrayBuffer.isView(obj)) {
+    const typedName = obj.constructor.name;
+    const arr = obj instanceof DataView ? new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength) : obj;
+    const len = "length" in arr ? arr.length : 0;
+    const shown = Math.min(len, MAX_ARRAY_LENGTH);
+    const items = [];
+    for (let i = 0; i < shown; i++) items.push(String(arr[i]));
+    const suffix2 = len > MAX_ARRAY_LENGTH ? ", ..." : "";
+    return `${typedName}(${len}) [ ${items.join(", ")}${suffix2} ]`;
+  }
+  if (Array.isArray(obj)) {
+    if (depth <= 0) return `[ ... ]`;
+    const shown = obj.slice(0, MAX_ARRAY_LENGTH).map((v) => inspectInner(v, depth - 1, seen));
+    const suffix2 = obj.length > MAX_ARRAY_LENGTH ? ", ..." : "";
+    return `[ ${shown.join(", ")}${suffix2} ]`;
+  }
+  if (depth <= 0) return "{ ... }";
+  const keys = Object.keys(obj);
+  const entries = keys.slice(0, MAX_ARRAY_LENGTH).map((k) => `${k}: ${inspectInner(obj[k], depth - 1, seen)}`);
+  const suffix = keys.length > MAX_ARRAY_LENGTH ? ", ..." : "";
+  const prefix = obj.constructor && obj.constructor.name !== "Object" ? `${obj.constructor.name} ` : "";
+  return `${prefix}{ ${entries.join(", ")}${suffix} }`;
+}
+function inspectInner(value, depth, seen) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "object") return inspectObject(value, depth, seen);
+  return safeInspect(value, depth);
+}
+export {
+  safeInspect
+};

package/lib/esm/strict/index.js

@@ -1,6 +1,43 @@
-export * from "@gjsify/deno_std/node/assert/strict";
-import assert from "@gjsify/deno_std/node/assert/strict";
-var strict_default = assert;
+import { strict, strict as strict2 } from "../index.js";
+import {
+  AssertionError,
+  ok,
+  fail,
+  ifError,
+  match,
+  doesNotMatch,
+  throws,
+  doesNotThrow,
+  rejects,
+  doesNotReject,
+  strictEqual,
+  notStrictEqual,
+  deepStrictEqual,
+  notDeepStrictEqual,
+  strictEqual as strictEqual2,
+  notStrictEqual as notStrictEqual2,
+  deepStrictEqual as deepStrictEqual2,
+  notDeepStrictEqual as notDeepStrictEqual2
+} from "../index.js";
 export {
-  strict_default as default
+  AssertionError,
+  deepStrictEqual2 as deepEqual,
+  deepStrictEqual,
+  strict as default,
+  doesNotMatch,
+  doesNotReject,
+  doesNotThrow,
+  strictEqual2 as equal,
+  fail,
+  ifError,
+  match,
+  notDeepStrictEqual2 as notDeepEqual,
+  notDeepStrictEqual,
+  notStrictEqual2 as notEqual,
+  notStrictEqual,
+  ok,
+  rejects,
+  strict2 as strict,
+  strictEqual,
+  throws
 };

package/lib/types/assertion-error.d.ts

@@ -0,0 +1,17 @@
+interface AssertionErrorOptions {
+    actual?: unknown;
+    expected?: unknown;
+    message?: string | Error;
+    operator?: string;
+    stackStartFn?: Function;
+}
+export declare class AssertionError extends Error {
+    actual: unknown;
+    expected: unknown;
+    operator: string;
+    code: string;
+    generatedMessage: boolean;
+    constructor(options: AssertionErrorOptions);
+    toString(): string;
+}
+export {};

package/lib/types/deep-equal.d.ts

@@ -0,0 +1,2 @@
+export declare function isDeepEqual(val1: unknown, val2: unknown): boolean;
+export declare function isDeepStrictEqual(val1: unknown, val2: unknown): boolean;

package/lib/types/index.d.ts

@@ -0,0 +1,45 @@
+import { AssertionError } from './assertion-error.js';
+export { AssertionError };
+declare function ok(value: unknown, message?: string | Error): void;
+declare function equal(actual: unknown, expected: unknown, message?: string | Error): void;
+declare function notEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+declare function strictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+declare function notStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+declare function deepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+declare function notDeepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+declare function deepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+declare function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+type ErrorPredicate = RegExp | Function | ((err: unknown) => boolean) | object | Error;
+declare function throws(fn: () => unknown, errorOrMessage?: ErrorPredicate | string, message?: string | Error): void;
+declare function doesNotThrow(fn: () => unknown, errorOrMessage?: ErrorPredicate | string, message?: string | Error): void;
+declare function rejects(asyncFn: (() => Promise<unknown>) | Promise<unknown>, errorOrMessage?: ErrorPredicate | string, message?: string | Error): Promise<void>;
+declare function doesNotReject(asyncFn: (() => Promise<unknown>) | Promise<unknown>, errorOrMessage?: ErrorPredicate | string, message?: string | Error): Promise<void>;
+declare function fail(message?: string | Error): never;
+declare function fail(actual: unknown, expected: unknown, message?: string | Error, operator?: string, stackStartFn?: Function): never;
+declare function ifError(value: unknown): void;
+declare function match(actual: string, expected: RegExp, message?: string | Error): void;
+declare function doesNotMatch(actual: string, expected: RegExp, message?: string | Error): void;
+declare const strict: any;
+declare const assert: ((value: unknown, message?: string | Error) => void) & {
+    AssertionError: typeof AssertionError;
+    ok: typeof ok;
+    equal: typeof equal;
+    notEqual: typeof notEqual;
+    strictEqual: typeof strictEqual;
+    notStrictEqual: typeof notStrictEqual;
+    deepEqual: typeof deepEqual;
+    notDeepEqual: typeof notDeepEqual;
+    deepStrictEqual: typeof deepStrictEqual;
+    notDeepStrictEqual: typeof notDeepStrictEqual;
+    throws: typeof throws;
+    doesNotThrow: typeof doesNotThrow;
+    rejects: typeof rejects;
+    doesNotReject: typeof doesNotReject;
+    fail: typeof fail;
+    ifError: typeof ifError;
+    match: typeof match;
+    doesNotMatch: typeof doesNotMatch;
+    strict: any;
+};
+export { ok, equal, notEqual, strictEqual, notStrictEqual, deepEqual, notDeepEqual, deepStrictEqual, notDeepStrictEqual, throws, doesNotThrow, rejects, doesNotReject, fail, ifError, match, doesNotMatch, strict, };
+export default assert;

package/lib/types/inspect-fallback.d.ts

@@ -0,0 +1 @@
+export declare function safeInspect(value: unknown, depth?: number): string;

package/lib/types/strict/index.d.ts

@@ -0,0 +1,2 @@
+export { strict as default, strict } from '../index.js';
+export { AssertionError, ok, fail, ifError, match, doesNotMatch, throws, doesNotThrow, rejects, doesNotReject, strictEqual, notStrictEqual, deepStrictEqual, notDeepStrictEqual, strictEqual as equal, notStrictEqual as notEqual, deepStrictEqual as deepEqual, notDeepStrictEqual as notDeepEqual, } from '../index.js';