@plugjs/expect5 0.4.0

package/dist/expectation/expect.cjs

@@ -0,0 +1,211 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// expectation/expect.ts
+var expect_exports = {};
+__export(expect_exports, {
+  expect: () => expect
+});
+module.exports = __toCommonJS(expect_exports);
+var import_types = require("./types.cjs");
+var import_basic = require("./basic.cjs");
+var import_include = require("./include.cjs");
+var import_throwing = require("./throwing.cjs");
+var import_void = require("./void.cjs");
+var expectations = {
+  // basic expectations
+  toBeA: new import_basic.ToBeA(),
+  toBeCloseTo: new import_basic.ToBeCloseTo(),
+  toBeError: new import_basic.ToBeError(),
+  toBeGreaterThan: new import_basic.ToBeGreaterThan(),
+  toBeGreaterThanOrEqual: new import_basic.ToBeGreaterThanOrEqual(),
+  toBeInstanceOf: new import_basic.ToBeInstanceOf(),
+  toBeLessThan: new import_basic.ToBeLessThan(),
+  toBeLessThanOrEqual: new import_basic.ToBeLessThanOrEqual(),
+  toBeWithinRange: new import_basic.ToBeWithinRange(),
+  toEqual: new import_basic.ToEqual(),
+  toHaveLength: new import_basic.ToHaveLength(),
+  toHaveProperty: new import_basic.ToHaveProperty(),
+  toHaveSize: new import_basic.ToHaveSize(),
+  toMatch: new import_basic.ToMatch(),
+  toStrictlyEqual: new import_basic.ToStrictlyEqual(),
+  // include
+  toInclude: new import_include.ToInclude(),
+  toMatchContents: new import_include.ToMatchContents(),
+  // throwing
+  toThrow: new import_throwing.ToThrow(),
+  toThrowError: new import_throwing.ToThrowError(),
+  // void expectations
+  toBeDefined: new import_void.ToBeDefined(),
+  toBeFalse: new import_void.ToBeFalse(),
+  toBeFalsy: new import_void.ToBeFalsy(),
+  toBeNaN: new import_void.ToBeNaN(),
+  toBeNegativeInfinity: new import_void.ToBeNegativeInfinity(),
+  toBeNull: new import_void.ToBeNull(),
+  toBePositiveInfinity: new import_void.ToBePositiveInfinity(),
+  toBeTrue: new import_void.ToBeTrue(),
+  toBeTruthy: new import_void.ToBeTruthy(),
+  toBeUndefined: new import_void.ToBeUndefined()
+};
+var ExpectationsImpl = class {
+  constructor(value, _positiveExpectations) {
+    this.value = value;
+    if (_positiveExpectations) {
+      this._negative = true;
+      this._positiveExpectations = _positiveExpectations;
+      this._negativeExpectations = this;
+    } else {
+      this._negative = false;
+      this._positiveExpectations = this;
+      this._negativeExpectations = new ExpectationsImpl(value, this);
+    }
+  }
+  _positiveExpectations;
+  _negativeExpectations;
+  _negative;
+  /* == NEW EXPECTATIONS ==================================================== */
+  forProperty(prop) {
+    this.toBeDefined();
+    const child = new ExpectationsImpl(this.value[prop]);
+    child.parent = { context: this, prop };
+    return child;
+  }
+  forValue(value) {
+    return new ExpectationsImpl(value);
+  }
+  /* == NEGATION ============================================================ */
+  negated(negative) {
+    return negative ? this._negativeExpectations : this._positiveExpectations;
+  }
+  get not() {
+    return this._negative ? this._positiveExpectations : this._negativeExpectations;
+  }
+  /* == ASYNCHRONOUS EXPECTATIONS =========================================== */
+  toBeResolved(assert) {
+    return Promise.resolve().then(() => {
+      this._positiveExpectations.toHaveProperty("then", (a) => a.toBeA("function"));
+      return Promise.allSettled([Promise.resolve(this.value)]);
+    }).then(([settlement]) => {
+      if (settlement.status === "fulfilled") {
+        if (this._negative)
+          throw new import_types.ExpectationError(this, true, "to be resolved");
+        if (assert)
+          assert(new ExpectationsImpl(settlement.value));
+      } else if (!this._negative) {
+        throw new import_types.ExpectationError(this, false, "to be resolved");
+      }
+      return this._positiveExpectations;
+    });
+  }
+  toBeRejected(assert) {
+    return Promise.resolve().then(() => {
+      this._positiveExpectations.toHaveProperty("then", (a) => a.toBeA("function"));
+      return Promise.allSettled([Promise.resolve(this.value)]);
+    }).then(([settlement]) => {
+      if (settlement.status === "rejected") {
+        if (this._negative)
+          throw new import_types.ExpectationError(this, true, "to be rejected");
+        if (assert)
+          assert(new ExpectationsImpl(settlement.reason));
+      } else if (!this._negative) {
+        throw new import_types.ExpectationError(this, false, "to be rejected");
+      }
+      return this._positiveExpectations;
+    });
+  }
+  toBeRejectedWithError(...args) {
+    return this.toBeRejected((assert) => assert.toBeError(...args));
+  }
+  static {
+    for (const [key, value] of Object.entries(expectations)) {
+      const expectation = value;
+      const fn = function(...args) {
+        try {
+          expectation.expect(this._positiveExpectations, this._negative, ...args);
+          return this._positiveExpectations;
+        } catch (error) {
+          if (error instanceof import_types.ExpectationError)
+            Error.captureStackTrace(error, fn);
+          throw error;
+        }
+      };
+      Object.defineProperty(fn, "name", { value: key });
+      Object.defineProperty(this.prototype, key, { value: fn });
+    }
+  }
+};
+var ExpectationsMatcherImpl = class {
+  _matchers;
+  _positiveBuilder;
+  _negativeBuilder;
+  _negative;
+  constructor(_matchers, _positiveBuilder) {
+    this._matchers = _matchers;
+    if (_positiveBuilder) {
+      this._negative = true;
+      this._positiveBuilder = _positiveBuilder;
+      this._negativeBuilder = this;
+    } else {
+      this._negative = false;
+      this._positiveBuilder = this;
+      this._negativeBuilder = new ExpectationsMatcherImpl(this._matchers, this);
+    }
+  }
+  get not() {
+    return this._negative ? this._positiveBuilder : this._negativeBuilder;
+  }
+  expect(value) {
+    const expectations2 = new ExpectationsImpl(value);
+    for (const [expectation, negative, args] of this._matchers) {
+      expectations2.negated(negative)[expectation](...args);
+    }
+  }
+  static {
+    Object.defineProperty(this.prototype, import_types.matcherMarker, { value: import_types.matcherMarker });
+    for (const key in expectations) {
+      Object.defineProperty(this.prototype, key, {
+        value: function(...args) {
+          return new ExpectationsMatcherImpl([
+            ...this._matchers,
+            [key, this._negative, args]
+          ]);
+        }
+      });
+    }
+  }
+};
+var expect = (value) => {
+  return new ExpectationsImpl(value);
+};
+Object.defineProperty(expect, "not", {
+  get: () => new ExpectationsMatcherImpl([]).not
+});
+for (const name in expectations) {
+  Object.defineProperty(expect, name, {
+    value: function(...args) {
+      const builder = new ExpectationsMatcherImpl([]);
+      return builder[name](...args);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expect
+});
+//# sourceMappingURL=expect.cjs.map

package/dist/expectation/expect.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/expectation/expect.ts"],
+  "mappings": "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",
+  "names": ["expectations"]
+}

package/dist/expectation/expect.d.ts

@@ -0,0 +1,140 @@
+import { ToBeA, ToBeCloseTo, ToBeError, ToBeGreaterThan, ToBeGreaterThanOrEqual, ToBeInstanceOf, ToBeLessThan, ToBeLessThanOrEqual, ToBeWithinRange, ToEqual, ToHaveLength, ToHaveProperty, ToHaveSize, ToMatch, ToStrictlyEqual } from './basic';
+import { ToInclude, ToMatchContents } from './include';
+import { ToThrow, ToThrowError } from './throwing';
+import { ToBeDefined, ToBeFalse, ToBeFalsy, ToBeNaN, ToBeNegativeInfinity, ToBeNull, ToBePositiveInfinity, ToBeTrue, ToBeTruthy, ToBeUndefined } from './void';
+import type { Constructor, StringMatcher } from './types';
+/** Singleton with all imported (known) expectations */
+declare const expectations: {
+    readonly toBeA: ToBeA;
+    readonly toBeCloseTo: ToBeCloseTo;
+    readonly toBeError: ToBeError;
+    readonly toBeGreaterThan: ToBeGreaterThan;
+    readonly toBeGreaterThanOrEqual: ToBeGreaterThanOrEqual;
+    readonly toBeInstanceOf: ToBeInstanceOf;
+    readonly toBeLessThan: ToBeLessThan;
+    readonly toBeLessThanOrEqual: ToBeLessThanOrEqual;
+    readonly toBeWithinRange: ToBeWithinRange;
+    readonly toEqual: ToEqual;
+    readonly toHaveLength: ToHaveLength;
+    readonly toHaveProperty: ToHaveProperty;
+    readonly toHaveSize: ToHaveSize;
+    readonly toMatch: ToMatch;
+    readonly toStrictlyEqual: ToStrictlyEqual;
+    readonly toInclude: ToInclude;
+    readonly toMatchContents: ToMatchContents;
+    readonly toThrow: ToThrow;
+    readonly toThrowError: ToThrowError;
+    readonly toBeDefined: ToBeDefined;
+    readonly toBeFalse: ToBeFalse;
+    readonly toBeFalsy: ToBeFalsy;
+    readonly toBeNaN: ToBeNaN;
+    readonly toBeNegativeInfinity: ToBeNegativeInfinity;
+    readonly toBeNull: ToBeNull;
+    readonly toBePositiveInfinity: ToBePositiveInfinity;
+    readonly toBeTrue: ToBeTrue;
+    readonly toBeTruthy: ToBeTruthy;
+    readonly toBeUndefined: ToBeUndefined;
+};
+/** The type of our imported expectations */
+type ExpectationsByName = typeof expectations;
+/** Infer expectations parameter from {@link Expectation} type */
+type ExpectationParameters<E> = E extends Expectation ? Parameters<E['expect']> extends [any, any, ...infer P] ? P : never : never;
+/** Infer return parameter from {@link Expectation} type */
+type ExpectationReturn<E, T> = E extends Expectation ? Expectations<T> : never;
+/** Infer expectation functions from imported {@link Expectation} instances */
+type ImportedExpectations<T = unknown> = {
+    [k in keyof ExpectationsByName]: (...args: ExpectationParameters<ExpectationsByName[k]>) => ExpectationReturn<ExpectationsByName[k], T>;
+};
+/** An interface describing all expectations returned by `expect(...)` */
+export interface Expectations<T = unknown> extends ImportedExpectations<T> {
+    /**
+     * The parent of this instance, if and only if this is a child derived from
+     * a property of the parent instance's value.
+     */
+    parent?: ExpectationsParent;
+    /** The value this {@link Expectations} instance operates on */
+    value: T;
+    /** The _negated_ expectations of _this_ {@link Expectations} instance. */
+    not: Expectations<T>;
+    /**
+     * Programmatically return _positive_ or _negative_ {@link Expectations}
+     * for the value wrapped by this instance.
+     */
+    negated(negative: boolean): Expectations<T>;
+    /** Create an {@link Expectations} associated with a property of this value */
+    forProperty(prop: string | number | symbol): Expectations;
+    /** Create a new {@link Expectations} instance for the specified value */
+    forValue<T = unknown>(value: T): Expectations<T>;
+    /** Expect the value to be a _resolved_ {@link Promise} */
+    toBeResolved(): Promise<ExpectationsImpl<T>>;
+    /**
+     * Expect the value to be a _resolved_ {@link Promise}, and assert the
+     * resolved result with the specified callback
+     */
+    toBeResolved(assert: (resultExpectations: Expectations) => void): Promise<ExpectationsImpl<T>>;
+    /** Expect the value to be a _rejected_ {@link Promise} */
+    toBeRejected(): Promise<ExpectationsImpl<T>>;
+    /**
+     * Expect the value to be a _rejected_ {@link Promise}, and assert the
+     * rejected reason with the specified callback
+     */
+    toBeRejected(assert?: (rejectionExpectations: Expectations) => void): Promise<ExpectationsImpl<T>>;
+    /** Expect the value to be a {@link Promise} _rejected_ by an {@link Error} */
+    toBeRejectedWithError(): Promise<Expectations<T>>;
+    /**
+     * Expect the value to be a {@link Promise} _rejected_ by an {@link Error}
+     * with the specified _message_
+     */
+    toBeRejectedWithError(message: StringMatcher): Promise<Expectations<T>>;
+    /**
+     * Expect the value to be a {@link Promise} _rejected_ by an {@link Error}
+     * of the specified _type_
+     */
+    toBeRejectedWithError(constructor: Constructor<Error>): Promise<Expectations<T>>;
+    /**
+     * Expect the value to be a {@link Promise} _rejected_ by an {@link Error}
+     * of the specified _type_ and with the specified _message_
+     */
+    toBeRejectedWithError(constructor: Constructor<Error>, message: StringMatcher): Promise<Expectations<T>>;
+}
+/** Parent expectations */
+export interface ExpectationsParent {
+    context: Expectations;
+    prop: string | number | symbol;
+}
+/** Basic definition of an {@link Expectation} as an object */
+export interface Expectation {
+    expect(context: Expectations, negative: boolean, ...args: any[]): void;
+}
+/** Empty interface: the `class` below won't complain about missing stuff */
+interface ExpectationsImpl<T = unknown> extends Expectations<T> {
+}
+/** Implementation of our {@link Expectations} interface */
+declare class ExpectationsImpl<T = unknown> implements Expectations<T> {
+    readonly value: T;
+    private readonly _positiveExpectations;
+    private readonly _negativeExpectations;
+    private readonly _negative;
+    constructor(value: T, _positiveExpectations?: ExpectationsImpl<T>);
+    forProperty(prop: string | number | symbol): ExpectationsImpl;
+    forValue<T = unknown>(value: T): ExpectationsImpl<T>;
+    negated(negative: boolean): ExpectationsImpl<T>;
+    get not(): ExpectationsImpl<T>;
+    toBeResolved(assert?: (resultExpectations: Expectations) => void): Promise<ExpectationsImpl<T>>;
+    toBeRejected(assert?: (reasonExpectations: Expectations) => void): Promise<ExpectationsImpl<T>>;
+    toBeRejectedWithError(...args: [] | [message: StringMatcher] | [constructor: Constructor<Error>] | [constructor: Constructor<Error>, message: StringMatcher]): Promise<ExpectationsImpl<T>>;
+}
+/** Infer return parameter from {@link Expectation} type */
+type MatcherReturn<E> = E extends Expectation ? ExpectationsMatcher : never;
+/** Infer expectation functions from imported {@link Expectation} instances */
+type ImportedMatchers = {
+    [k in keyof ExpectationsByName]: (...args: ExpectationParameters<ExpectationsByName[k]>) => MatcherReturn<ExpectationsByName[k]>;
+};
+/** An interface describing all expectations returned by `expect(...)` */
+export interface ExpectationsMatcher extends ImportedMatchers {
+    not: ExpectationsMatcher;
+    expect(value: unknown): void;
+}
+/** The `expect` function exposing expectations and matchers */
+export declare const expect: ExpectationsMatcher & (<T = unknown>(value: T) => Expectations<T>);
+export {};

package/dist/expectation/expect.mjs

@@ -0,0 +1,219 @@
+// expectation/expect.ts
+import { ExpectationError, matcherMarker } from "./types.mjs";
+import {
+  ToBeA,
+  ToBeCloseTo,
+  ToBeError,
+  ToBeGreaterThan,
+  ToBeGreaterThanOrEqual,
+  ToBeInstanceOf,
+  ToBeLessThan,
+  ToBeLessThanOrEqual,
+  ToBeWithinRange,
+  ToEqual,
+  ToHaveLength,
+  ToHaveProperty,
+  ToHaveSize,
+  ToMatch,
+  ToStrictlyEqual
+} from "./basic.mjs";
+import {
+  ToInclude,
+  ToMatchContents
+} from "./include.mjs";
+import {
+  ToThrow,
+  ToThrowError
+} from "./throwing.mjs";
+import {
+  ToBeDefined,
+  ToBeFalse,
+  ToBeFalsy,
+  ToBeNaN,
+  ToBeNegativeInfinity,
+  ToBeNull,
+  ToBePositiveInfinity,
+  ToBeTrue,
+  ToBeTruthy,
+  ToBeUndefined
+} from "./void.mjs";
+var expectations = {
+  // basic expectations
+  toBeA: new ToBeA(),
+  toBeCloseTo: new ToBeCloseTo(),
+  toBeError: new ToBeError(),
+  toBeGreaterThan: new ToBeGreaterThan(),
+  toBeGreaterThanOrEqual: new ToBeGreaterThanOrEqual(),
+  toBeInstanceOf: new ToBeInstanceOf(),
+  toBeLessThan: new ToBeLessThan(),
+  toBeLessThanOrEqual: new ToBeLessThanOrEqual(),
+  toBeWithinRange: new ToBeWithinRange(),
+  toEqual: new ToEqual(),
+  toHaveLength: new ToHaveLength(),
+  toHaveProperty: new ToHaveProperty(),
+  toHaveSize: new ToHaveSize(),
+  toMatch: new ToMatch(),
+  toStrictlyEqual: new ToStrictlyEqual(),
+  // include
+  toInclude: new ToInclude(),
+  toMatchContents: new ToMatchContents(),
+  // throwing
+  toThrow: new ToThrow(),
+  toThrowError: new ToThrowError(),
+  // void expectations
+  toBeDefined: new ToBeDefined(),
+  toBeFalse: new ToBeFalse(),
+  toBeFalsy: new ToBeFalsy(),
+  toBeNaN: new ToBeNaN(),
+  toBeNegativeInfinity: new ToBeNegativeInfinity(),
+  toBeNull: new ToBeNull(),
+  toBePositiveInfinity: new ToBePositiveInfinity(),
+  toBeTrue: new ToBeTrue(),
+  toBeTruthy: new ToBeTruthy(),
+  toBeUndefined: new ToBeUndefined()
+};
+var ExpectationsImpl = class {
+  constructor(value, _positiveExpectations) {
+    this.value = value;
+    if (_positiveExpectations) {
+      this._negative = true;
+      this._positiveExpectations = _positiveExpectations;
+      this._negativeExpectations = this;
+    } else {
+      this._negative = false;
+      this._positiveExpectations = this;
+      this._negativeExpectations = new ExpectationsImpl(value, this);
+    }
+  }
+  _positiveExpectations;
+  _negativeExpectations;
+  _negative;
+  /* == NEW EXPECTATIONS ==================================================== */
+  forProperty(prop) {
+    this.toBeDefined();
+    const child = new ExpectationsImpl(this.value[prop]);
+    child.parent = { context: this, prop };
+    return child;
+  }
+  forValue(value) {
+    return new ExpectationsImpl(value);
+  }
+  /* == NEGATION ============================================================ */
+  negated(negative) {
+    return negative ? this._negativeExpectations : this._positiveExpectations;
+  }
+  get not() {
+    return this._negative ? this._positiveExpectations : this._negativeExpectations;
+  }
+  /* == ASYNCHRONOUS EXPECTATIONS =========================================== */
+  toBeResolved(assert) {
+    return Promise.resolve().then(() => {
+      this._positiveExpectations.toHaveProperty("then", (a) => a.toBeA("function"));
+      return Promise.allSettled([Promise.resolve(this.value)]);
+    }).then(([settlement]) => {
+      if (settlement.status === "fulfilled") {
+        if (this._negative)
+          throw new ExpectationError(this, true, "to be resolved");
+        if (assert)
+          assert(new ExpectationsImpl(settlement.value));
+      } else if (!this._negative) {
+        throw new ExpectationError(this, false, "to be resolved");
+      }
+      return this._positiveExpectations;
+    });
+  }
+  toBeRejected(assert) {
+    return Promise.resolve().then(() => {
+      this._positiveExpectations.toHaveProperty("then", (a) => a.toBeA("function"));
+      return Promise.allSettled([Promise.resolve(this.value)]);
+    }).then(([settlement]) => {
+      if (settlement.status === "rejected") {
+        if (this._negative)
+          throw new ExpectationError(this, true, "to be rejected");
+        if (assert)
+          assert(new ExpectationsImpl(settlement.reason));
+      } else if (!this._negative) {
+        throw new ExpectationError(this, false, "to be rejected");
+      }
+      return this._positiveExpectations;
+    });
+  }
+  toBeRejectedWithError(...args) {
+    return this.toBeRejected((assert) => assert.toBeError(...args));
+  }
+  static {
+    for (const [key, value] of Object.entries(expectations)) {
+      const expectation = value;
+      const fn = function(...args) {
+        try {
+          expectation.expect(this._positiveExpectations, this._negative, ...args);
+          return this._positiveExpectations;
+        } catch (error) {
+          if (error instanceof ExpectationError)
+            Error.captureStackTrace(error, fn);
+          throw error;
+        }
+      };
+      Object.defineProperty(fn, "name", { value: key });
+      Object.defineProperty(this.prototype, key, { value: fn });
+    }
+  }
+};
+var ExpectationsMatcherImpl = class {
+  _matchers;
+  _positiveBuilder;
+  _negativeBuilder;
+  _negative;
+  constructor(_matchers, _positiveBuilder) {
+    this._matchers = _matchers;
+    if (_positiveBuilder) {
+      this._negative = true;
+      this._positiveBuilder = _positiveBuilder;
+      this._negativeBuilder = this;
+    } else {
+      this._negative = false;
+      this._positiveBuilder = this;
+      this._negativeBuilder = new ExpectationsMatcherImpl(this._matchers, this);
+    }
+  }
+  get not() {
+    return this._negative ? this._positiveBuilder : this._negativeBuilder;
+  }
+  expect(value) {
+    const expectations2 = new ExpectationsImpl(value);
+    for (const [expectation, negative, args] of this._matchers) {
+      expectations2.negated(negative)[expectation](...args);
+    }
+  }
+  static {
+    Object.defineProperty(this.prototype, matcherMarker, { value: matcherMarker });
+    for (const key in expectations) {
+      Object.defineProperty(this.prototype, key, {
+        value: function(...args) {
+          return new ExpectationsMatcherImpl([
+            ...this._matchers,
+            [key, this._negative, args]
+          ]);
+        }
+      });
+    }
+  }
+};
+var expect = (value) => {
+  return new ExpectationsImpl(value);
+};
+Object.defineProperty(expect, "not", {
+  get: () => new ExpectationsMatcherImpl([]).not
+});
+for (const name in expectations) {
+  Object.defineProperty(expect, name, {
+    value: function(...args) {
+      const builder = new ExpectationsMatcherImpl([]);
+      return builder[name](...args);
+    }
+  });
+}
+export {
+  expect
+};
+//# sourceMappingURL=expect.mjs.map

package/dist/expectation/expect.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/expectation/expect.ts"],
+  "mappings": "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",
+  "names": ["expectations"]
+}