@gjsify/assert 0.0.4 → 0.1.1

package/src/index.ts

@@ -1,3 +1,569 @@
-export * from '@gjsify/deno_std/node/assert';
-import assert from '@gjsify/deno_std/node/assert';
-export default assert;
+// Reference: Node.js lib/assert.js
+// Reimplemented for GJS
+
+import { AssertionError } from './assertion-error.js';
+import { isDeepEqual, isDeepStrictEqual } from './deep-equal.js';
+
+export { AssertionError };
+
+// ---- Helpers ----
+
+function innerFail(obj: {
+  actual?: unknown;
+  expected?: unknown;
+  message?: string | Error;
+  operator?: string;
+  stackStartFn?: Function;
+}): never {
+  if (obj.message instanceof Error) throw obj.message;
+  throw new AssertionError({
+    actual: obj.actual,
+    expected: obj.expected,
+    message: obj.message as string | undefined,
+    operator: obj.operator,
+    stackStartFn: obj.stackStartFn,
+  });
+}
+
+function isPromiseLike(val: unknown): val is PromiseLike<unknown> {
+  return val !== null && typeof val === 'object' && typeof (val as { then?: unknown }).then === 'function';
+}
+
+// ---- Core functions ----
+
+function ok(value: unknown, message?: string | Error): void {
+  if (!value) {
+    innerFail({
+      actual: value,
+      expected: true,
+      message,
+      operator: '==',
+      stackStartFn: ok,
+    });
+  }
+}
+
+function equal(actual: unknown, expected: unknown, message?: string | Error): void {
+  // eslint-disable-next-line eqeqeq
+  if (actual != expected) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: '==',
+      stackStartFn: equal,
+    });
+  }
+}
+
+function notEqual(actual: unknown, expected: unknown, message?: string | Error): void {
+  // eslint-disable-next-line eqeqeq
+  if (actual == expected) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: '!=',
+      stackStartFn: notEqual,
+    });
+  }
+}
+
+function strictEqual(actual: unknown, expected: unknown, message?: string | Error): void {
+  if (!Object.is(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'strictEqual',
+      stackStartFn: strictEqual,
+    });
+  }
+}
+
+function notStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void {
+  if (Object.is(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'notStrictEqual',
+      stackStartFn: notStrictEqual,
+    });
+  }
+}
+
+function deepEqual(actual: unknown, expected: unknown, message?: string | Error): void {
+  if (!isDeepEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'deepEqual',
+      stackStartFn: deepEqual,
+    });
+  }
+}
+
+function notDeepEqual(actual: unknown, expected: unknown, message?: string | Error): void {
+  if (isDeepEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'notDeepEqual',
+      stackStartFn: notDeepEqual,
+    });
+  }
+}
+
+function deepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void {
+  if (!isDeepStrictEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'deepStrictEqual',
+      stackStartFn: deepStrictEqual,
+    });
+  }
+}
+
+function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void {
+  if (isDeepStrictEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'notDeepStrictEqual',
+      stackStartFn: notDeepStrictEqual,
+    });
+  }
+}
+
+// ---- throws / doesNotThrow ----
+
+type ErrorPredicate = RegExp | Function | ((err: unknown) => boolean) | object | Error;
+
+function getActual(fn: () => unknown): unknown {
+  const NO_EXCEPTION = Symbol('NO_EXCEPTION');
+  try {
+    fn();
+  } catch (e) {
+    return e;
+  }
+  return NO_EXCEPTION;
+}
+
+async function getActualAsync(fn: (() => Promise<unknown>) | Promise<unknown>): Promise<unknown> {
+  const NO_EXCEPTION = 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: unknown,
+  expected: ErrorPredicate,
+  message: string | Error | undefined,
+  fn: Function,
+): boolean {
+  if (expected === undefined) return true;
+
+  // RegExp validation
+  if (expected instanceof RegExp) {
+    const str = String(actual);
+    if (expected.test(str)) return true;
+    throw new AssertionError({
+      actual,
+      expected,
+      message: message as string | undefined,
+      operator: fn.name,
+      stackStartFn: fn,
+    });
+  }
+
+  // Validation function
+  if (typeof expected === 'function') {
+    // Error class constructor
+    if (expected.prototype !== undefined && actual instanceof (expected as new (...args: unknown[]) => unknown)) {
+      return true;
+    }
+    // Error class but not instance
+    if (Error.isPrototypeOf(expected as Function)) {
+      return false;
+    }
+    // Validator function
+    const result = (expected as Function).call({}, actual);
+    if (result !== true) {
+      throw new AssertionError({
+        actual,
+        expected,
+        message: message as string | undefined,
+        operator: fn.name,
+        stackStartFn: fn,
+      });
+    }
+    return true;
+  }
+
+  // Object validation (check properties)
+  if (typeof expected === 'object' && expected !== null) {
+    const keys = Object.keys(expected);
+    for (const key of keys) {
+      const expectedObj = expected as Record<string, unknown>;
+      const actualObj = actual as Record<string, unknown>;
+      if (typeof actualObj[key] === 'string' && expectedObj[key] instanceof RegExp) {
+        if (!(expectedObj[key] as RegExp).test(actualObj[key] as string)) {
+          throw new AssertionError({
+            actual,
+            expected,
+            message: message as string | undefined,
+            operator: fn.name,
+            stackStartFn: fn,
+          });
+        }
+      } else if (!isDeepStrictEqual(actualObj[key], expectedObj[key])) {
+        throw new AssertionError({
+          actual,
+          expected,
+          message: message as string | undefined,
+          operator: fn.name,
+          stackStartFn: fn,
+        });
+      }
+    }
+    return true;
+  }
+
+  return true;
+}
+
+function throws(
+  fn: () => unknown,
+  errorOrMessage?: ErrorPredicate | string,
+  message?: string | Error,
+): void {
+  if (typeof fn !== 'function') {
+    throw new TypeError('The "fn" argument must be of type function.');
+  }
+
+  let expected: ErrorPredicate | undefined;
+  if (typeof errorOrMessage === 'string') {
+    message = errorOrMessage;
+    expected = undefined;
+  } else {
+    expected = errorOrMessage;
+  }
+
+  const actual = getActual(fn);
+  if (typeof actual === 'symbol') {
+    // NO_EXCEPTION sentinel
+    innerFail({
+      actual: undefined,
+      expected,
+      message: message || 'Missing expected exception.',
+      operator: 'throws',
+      stackStartFn: throws,
+    });
+  }
+
+  if (expected !== undefined) {
+    expectedException(actual, expected, message, throws);
+  }
+}
+
+function doesNotThrow(
+  fn: () => unknown,
+  errorOrMessage?: ErrorPredicate | string,
+  message?: string | Error,
+): void {
+  if (typeof fn !== 'function') {
+    throw new TypeError('The "fn" argument must be of type function.');
+  }
+
+  let expected: ErrorPredicate | undefined;
+  if (typeof errorOrMessage === 'string') {
+    message = errorOrMessage;
+    expected = undefined;
+  } else {
+    expected = errorOrMessage;
+  }
+
+  const actual = getActual(fn);
+  if (typeof actual === 'symbol') {
+    // NO_EXCEPTION — good
+    return;
+  }
+
+  // If an expected error type was given, only re-throw if it matches
+  if (expected !== undefined && typeof expected === 'function' && expected.prototype !== undefined && actual instanceof expected) {
+    innerFail({
+      actual,
+      expected,
+      message: message || `Got unwanted exception.\n${actual && (actual as Error).message ? (actual as Error).message : ''}`,
+      operator: 'doesNotThrow',
+      stackStartFn: doesNotThrow,
+    });
+  }
+
+  if (expected === undefined || (typeof expected === 'function' && expected.prototype !== undefined && actual instanceof expected)) {
+    innerFail({
+      actual,
+      expected,
+      message: message || `Got unwanted exception.\n${actual && (actual as Error).message ? (actual as Error).message : ''}`,
+      operator: 'doesNotThrow',
+      stackStartFn: doesNotThrow,
+    });
+  }
+
+  throw actual;
+}
+
+async function rejects(
+  asyncFn: (() => Promise<unknown>) | Promise<unknown>,
+  errorOrMessage?: ErrorPredicate | string,
+  message?: string | Error,
+): Promise<void> {
+  let expected: ErrorPredicate | undefined;
+  if (typeof errorOrMessage === 'string') {
+    message = errorOrMessage;
+    expected = undefined;
+  } else {
+    expected = errorOrMessage;
+  }
+
+  const actual = await getActualAsync(asyncFn);
+  if (typeof actual === 'symbol') {
+    innerFail({
+      actual: undefined,
+      expected,
+      message: message || 'Missing expected rejection.',
+      operator: 'rejects',
+      stackStartFn: rejects,
+    });
+  }
+
+  if (expected !== undefined) {
+    expectedException(actual, expected, message, rejects);
+  }
+}
+
+async function doesNotReject(
+  asyncFn: (() => Promise<unknown>) | Promise<unknown>,
+  errorOrMessage?: ErrorPredicate | string,
+  message?: string | Error,
+): Promise<void> {
+  let expected: ErrorPredicate | undefined;
+  if (typeof errorOrMessage === 'string') {
+    message = errorOrMessage;
+    expected = undefined;
+  } else {
+    expected = errorOrMessage;
+  }
+
+  const actual = await getActualAsync(asyncFn);
+  if (typeof actual !== 'symbol') {
+    innerFail({
+      actual,
+      expected,
+      message: message || `Got unwanted rejection.\n${actual && (actual as Error).message ? (actual as Error).message : ''}`,
+      operator: 'doesNotReject',
+      stackStartFn: doesNotReject,
+    });
+  }
+}
+
+// ---- fail ----
+
+function fail(message?: string | Error): never;
+function fail(actual: unknown, expected: unknown, message?: string | Error, operator?: string, stackStartFn?: Function): never;
+function fail(
+  actualOrMessage?: unknown,
+  expected?: unknown,
+  message?: string | Error,
+  operator?: string,
+  stackStartFn?: Function,
+): never {
+  // Single-argument form: fail(message)
+  if (arguments.length === 0 || arguments.length === 1) {
+    const msg = arguments.length === 0
+      ? 'Failed'
+      : (typeof actualOrMessage === 'string' ? actualOrMessage : undefined);
+    if (actualOrMessage instanceof Error) throw actualOrMessage;
+    throw new AssertionError({
+      message: msg || 'Failed',
+      operator: 'fail',
+      stackStartFn: fail,
+    });
+  }
+
+  // Legacy multi-argument form
+  throw new AssertionError({
+    actual: actualOrMessage,
+    expected,
+    message: message as string | undefined,
+    operator: operator || 'fail',
+    stackStartFn: stackStartFn || fail,
+  });
+}
+
+// ---- ifError ----
+
+function ifError(value: unknown): void {
+  if (value !== null && value !== undefined) {
+    let message = 'ifError got unwanted exception: ';
+    if (typeof value === 'object' && typeof (value as Error).message === 'string') {
+      if ((value as Error).message.length === 0 && (value as Error).constructor) {
+        message += (value as Error).constructor.name;
+      } else {
+        message += (value as Error).message;
+      }
+    } else {
+      message += String(value);
+    }
+
+    const err = new AssertionError({
+      actual: value,
+      expected: null,
+      message,
+      operator: 'ifError',
+      stackStartFn: ifError,
+    });
+
+    // Attach original error info
+    const origStack = value instanceof Error ? value.stack : undefined;
+    if (origStack) {
+      (err as Error & { origStack?: string }).origStack = origStack;
+    }
+
+    throw err;
+  }
+}
+
+// ---- match / doesNotMatch ----
+
+function match(actual: string, expected: RegExp, message?: string | Error): void {
+  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:\n\n'${actual}'\n`,
+      operator: 'match',
+      stackStartFn: match,
+    });
+  }
+}
+
+function doesNotMatch(actual: string, expected: RegExp, message?: string | Error): void {
+  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:\n\n'${actual}'\n`,
+      operator: 'doesNotMatch',
+      stackStartFn: doesNotMatch,
+    });
+  }
+}
+
+// ---- strict namespace ----
+
+const strict = Object.assign(
+  function strict(value: unknown, message?: string | Error) { 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: undefined as unknown as typeof strict,
+  },
+);
+strict.strict = strict;
+
+// ---- Default export: assert function with all methods ----
+
+const assert = Object.assign(
+  function assert(value: unknown, message?: string | Error) { ok(value, message); },
+  {
+    AssertionError,
+    ok,
+    equal,
+    notEqual,
+    strictEqual,
+    notStrictEqual,
+    deepEqual,
+    notDeepEqual,
+    deepStrictEqual,
+    notDeepStrictEqual,
+    throws,
+    doesNotThrow,
+    rejects,
+    doesNotReject,
+    fail,
+    ifError,
+    match,
+    doesNotMatch,
+    strict,
+  },
+);
+
+// Named exports
+export {
+  ok,
+  equal,
+  notEqual,
+  strictEqual,
+  notStrictEqual,
+  deepEqual,
+  notDeepEqual,
+  deepStrictEqual,
+  notDeepStrictEqual,
+  throws,
+  doesNotThrow,
+  rejects,
+  doesNotReject,
+  fail,
+  ifError,
+  match,
+  doesNotMatch,
+  strict,
+};
+
+export default assert;

package/src/inspect-fallback.ts

@@ -0,0 +1,101 @@
+// Minimal inspect fallback for GJS — original implementation
+
+/**
+ * Minimal value-to-string converter for assertion error messages.
+ * This avoids depending on util.inspect (which itself depends on @gjsify/deno_std).
+ * Can be replaced with util.inspect once @gjsify/util is migrated.
+ */
+
+const MAX_DEPTH = 3;
+const MAX_ARRAY_LENGTH = 10;
+const MAX_STRING_LENGTH = 128;
+
+export function safeInspect(value: unknown, depth: number = MAX_DEPTH): string {
+  if (value === null) return 'null';
+  if (value === undefined) 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: object, depth: number, seen: WeakSet<object> = new WeakSet()): string {
+  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 entries = [...obj.entries()]
+      .slice(0, MAX_ARRAY_LENGTH)
+      .map(([k, v]) => `${inspectInner(k, depth - 1, seen)} => ${inspectInner(v, depth - 1, seen)}`);
+    const suffix = obj.size > MAX_ARRAY_LENGTH ? ', ...' : '';
+    return `Map(${obj.size}) { ${entries.join(', ')}${suffix} }`;
+  }
+
+  if (obj instanceof Set) {
+    if (depth <= 0) return `Set(${obj.size}) { ... }`;
+    const entries = [...obj.values()]
+      .slice(0, MAX_ARRAY_LENGTH)
+      .map(v => inspectInner(v, depth - 1, seen));
+    const suffix = obj.size > MAX_ARRAY_LENGTH ? ', ...' : '';
+    return `Set(${obj.size}) { ${entries.join(', ')}${suffix} }`;
+  }
+
+  if (ArrayBuffer.isView(obj)) {
+    const typedName = obj.constructor.name;
+    const arr = obj instanceof DataView
+      ? new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength)
+      : obj as unknown as ArrayLike<number>;
+    const len = 'length' in arr ? (arr as ArrayLike<number>).length : 0;
+    const shown = Math.min(len, MAX_ARRAY_LENGTH);
+    const items: string[] = [];
+    for (let i = 0; i < shown; i++) items.push(String((arr as ArrayLike<number>)[i]));
+    const suffix = len > MAX_ARRAY_LENGTH ? ', ...' : '';
+    return `${typedName}(${len}) [ ${items.join(', ')}${suffix} ]`;
+  }
+
+  if (Array.isArray(obj)) {
+    if (depth <= 0) return `[ ... ]`;
+    const shown = obj.slice(0, MAX_ARRAY_LENGTH)
+      .map(v => inspectInner(v, depth - 1, seen));
+    const suffix = obj.length > MAX_ARRAY_LENGTH ? ', ...' : '';
+    return `[ ${shown.join(', ')}${suffix} ]`;
+  }
+
+  // Plain object
+  if (depth <= 0) return '{ ... }';
+  const keys = Object.keys(obj);
+  const entries = keys.slice(0, MAX_ARRAY_LENGTH)
+    .map(k => `${k}: ${inspectInner((obj as Record<string, unknown>)[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: unknown, depth: number, seen: WeakSet<object>): string {
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+  if (typeof value === 'object') return inspectObject(value, depth, seen);
+  return safeInspect(value, depth);
+}

package/src/strict/index.ts

@@ -1,3 +1,21 @@
-export * from '@gjsify/deno_std/node/assert/strict';
-import assert from '@gjsify/deno_std/node/assert/strict';
-export default assert;
+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';