hein 1.4.2 → 2.0.0-alpha.0

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file. Dates are d
 
 Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 
+#### [hein@1.5.0](https://github.com/KristjanTammekivi/hein/compare/hein@1.4.2...hein@1.5.0)
+
+> 1 October 2024
+
+- feat: add .every [`#348`](https://github.com/KristjanTammekivi/hein/issues/348)
+- style: run lint fix [`9391e27`](https://github.com/KristjanTammekivi/hein/commit/9391e2712592341fc003a5cec1953559e4d0bf34)
+- fix: adapt to typescript-eslint 8 changes [`dd9e1b2`](https://github.com/KristjanTammekivi/hein/commit/dd9e1b2e98bbd138946005621a504de4e506d1db)
+
 #### [hein@1.4.2](https://github.com/KristjanTammekivi/hein/compare/hein@1.4.1...hein@1.4.2)
 
 > 11 December 2023

package/ESM_MIGRATION_NOTES.md

@@ -0,0 +1,6 @@
+# Notes about ESM migration
+
+1. Imports have to end with .js
+2. package.json type: module
+3. tsconfig module: esnext, allowSyntheticDefaultImports true
+4. 

package/README.md

@@ -40,13 +40,52 @@ expect(1).to.equal(1);
 
 #### Chainable properties
 
--   a
--   an
--   and - used to chain multiple assertions, clears the state (so .not will be reset)
--   be
--   have
--   not - inverts the expectation (ie `expect(5).to.not.equal(5)` will throw)
--   to
+##### Language chains
+
+There are multiple side-effect free tokens to chain assertions together. These include:
+- to
+- be
+- a
+- an
+- have
+- in
+- of
+
+```typescript
+expect(5).to.be.a.number(); // same as expect(5).number();
+```
+
+##### not
+
+Not inverts the conditions inside the expectation.
+
+```typescript
+expect(5).to.not.equal(4);
+```
+
+##### every
+
+Run the assertion for each member of an array
+
+```typescript
+expect([1, 2, 3]).every.to.be.a.number();
+```
+
+##### length
+
+Run the assertion on the length of an array
+
+```typescript
+expect([1, 2, 3]).length.to.be.greaterThan(2);
+```
+
+##### and
+
+Clears most of the state in the chain (with the exception of the effects of .every);
+
+```typescript
+expect(1).to.not.be.greaterThan(5).and.be.greaterThan(0);
+```
 
 #### Assertions
 

package/dist/assert-9EsvfQwn.d.cts

@@ -0,0 +1,483 @@
+import { Constructor, ErrorPredicate, notThrows, throws } from "./throws-D7JsW4NM.cjs";
+
+//#region rolldown:runtime
+//#endregion
+//#region src/assert/deep-equal.d.ts
+declare const deepEqual: <T>(actual: T, expected: T, partialOrMessage?: string | boolean, message?: string) => true | void, notDeepEqual: <T>(actual: T, expected: T, partialOrMessage?: string | boolean, message?: string) => true | void;
+//#endregion
+//#region src/assert/equal.d.ts
+interface Equal {
+  /**
+   * check for === equality except here NaN is equal to NaN
+   */
+  <T>(actual: T, expected: T, message?: string): void;
+}
+declare const equal: Equal, notEqual: Equal;
+//#endregion
+//#region src/assert/greater-than.d.ts
+interface GreaterThan {
+  /**
+   * check for >
+   */
+  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
+}
+declare const greaterThan: GreaterThan, notGreaterThan: GreaterThan;
+//#endregion
+//#region src/assert/greater-than-equal.d.ts
+interface GreaterThanEqual {
+  /**
+   * check for >=
+   */
+  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
+}
+declare const greaterThanEqual: GreaterThanEqual, notGreaterThanEqual: GreaterThanEqual;
+//#endregion
+//#region src/assert/has-property.d.ts
+interface HasProperty {
+  /**
+   * check if object has a property
+   * @param object
+   * @param property a property in the object.
+   * @example hasProperty({a: 1}, 'a');
+   */
+  <T, K extends keyof T>(object: T, property: K): void;
+  /**
+   * check if object has a property with a specific value
+   * @param object
+   * @param property a property in the object.
+   * @param value
+   * @example hasProperty({a: 1}, 'a', 1);
+   */
+  <T, K extends keyof T>(object: T, property: K, value: T[K]): void;
+}
+declare const hasProperty: HasProperty, notHasProperty: HasProperty;
+//#endregion
+//#region src/assert/has-size.d.ts
+interface HasSize {
+  /**
+   * check if array has a specific length
+   * @param array
+   * @param length
+   * @example hasSize([1, 2, 3], 3);
+   */
+  (array: any[], length: number, message?: string): void;
+  /**
+   * check if object has a specific amount of keys
+   * @param object
+   * @param length
+   * @example hasSize({a: 1, b: 2}, 2);
+   */
+  (object: Record<string, unknown>, length: number, message?: string): void;
+  /**
+   * check if Map has a specific amount of keys
+   * @param map
+   * @param length
+   * @example hasSize(new Map([['a', 1], ['b', 2]]), 2);
+   */
+  (map: Map<unknown, unknown>, length: number, message?: string): void;
+  /**
+   * check if Set has a specific amount of members
+   * @param set
+   * @param length
+   * @example hasSize(new Set([1, 2, 3]), 3);
+   */
+  (set: Set<unknown>, length: number, message?: string): void;
+  /**
+   * check if string has a specific length
+   * @param string
+   * @param length
+   * @example hasSize('abc', 3);
+   */
+  (string: string, length: number, message?: string): void;
+}
+declare const hasSize: HasSize, notHasSize: HasSize;
+//#endregion
+//#region src/assert/includes.d.ts
+interface Includes {
+  /**
+   * check if array includes a specific element
+   * @param array
+   * @param element
+   * @example includes([1, 2, 3], 2);
+   * @example includes([1, 2, 3], 2, 3);
+   */
+  <T>(array: T[], ...elements: T[]): void;
+  /**
+   * check if string includes a specific string
+   * @param string
+   * @param element
+   * @example includes('abc', 'b');
+   * @example includes('abc', 'b', 'c');
+   * @example includes('abc', 'bc');
+   */
+  (string: string, ...elements: string[]): void;
+}
+declare const includes: Includes, notIncludes: Includes;
+//#endregion
+//#region src/assert/instance-of.d.ts
+interface InstanceOf {
+  /**
+   * check if value is an instance of a constructor
+   * @param value
+   * @param constructor
+   * @example instanceOf(new Error(), Error);
+   */
+  <T extends Constructor>(value: InstanceType<T>, constructor: T): void;
+}
+declare const instanceOf: InstanceOf, notInstanceOf: InstanceOf;
+//#endregion
+//#region src/assert/is-empty.d.ts
+interface IsEmpty {
+  /**
+   * check if array is empty
+   * @param array
+   * @example isEmpty([]);
+   */
+  <T>(array: T[], message?: string): void;
+  /**
+   * check if object is empty
+   * @param object
+   * @example isEmpty({});
+   */
+  (object: Record<string, unknown>, message?: string): void;
+  /**
+   * check if Map is empty
+   * @param map
+   * @example isEmpty(new Map());
+   */
+  <K, V>(map: Map<K, V>, message?: string): void;
+  /**
+   * check if Set is empty
+   * @param set
+   * @example isEmpty(new Set());
+   */
+  <T>(set: Set<T>, message?: string): void;
+}
+declare const isEmpty: IsEmpty, notIsEmpty: IsEmpty;
+//#endregion
+//#region src/utils/get-type.d.ts
+type ValueType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | 'null' | 'NaN' | 'array';
+//#endregion
+//#region src/assert/is-type.d.ts
+interface IsType {
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType('foo', 'string');
+   * @example isType(1, 'number');
+   * @example isType(1n, 'bigint');
+   * @example isType(true, 'boolean');
+   * @example isType(Symbol('foo'), 'symbol');
+   * @example isType(undefined, 'undefined');
+   * @example isType({}, 'object');
+   * @example isType(() => {}, 'function');
+   * @example isType(null, 'null');
+   * @example isType(NaN, 'NaN');
+   * @example isType([], 'array');
+   */
+  (value: unknown, expectedType: ValueType): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType('foo', 'string');
+   */
+  (value: string, expectedType: 'string'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(1, 'number');
+   * @example isType(NaN, 'NaN');
+   */
+  (value: number, expectedType: 'number' | 'NaN'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(1n, 'bigint');
+   */
+  (value: bigint, expectedType: 'bigint'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(true, 'boolean');
+   */
+  (value: boolean, expectedType: 'boolean'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(Symbol('foo'), 'symbol');
+   */
+  (value: symbol, expectedType: 'symbol'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(Symbol('foo'), 'symbol');
+   */
+  (value: undefined, expectedType: 'undefined'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType({}, 'object');
+   */
+  (value: object, expectedType: 'object'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(() => {}, 'function');
+   */
+  (value: Function, expectedType: 'function'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(null, 'null');
+   */
+  (value: null, expectedType: 'null'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType([], 'array');
+   */
+  (value: any[], expectedType: 'array'): void;
+}
+declare const isType: IsType, notIsType: IsType;
+//#endregion
+//#region src/assert/less-than.d.ts
+interface LesserThan {
+  /**
+   * check for <
+   */
+  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
+}
+declare const lessThan: LesserThan, notLessThan: LesserThan;
+//#endregion
+//#region src/assert/less-than-equal.d.ts
+interface LessThanEqual {
+  /**
+   * check for <=
+   */
+  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
+}
+declare const lessThanEqual: LessThanEqual, notLessThanEqual: LessThanEqual;
+//#endregion
+//#region src/assert/match.d.ts
+interface IsMatch {
+  /**
+   * check if string matches regex
+   * @param actual
+   * @param regex
+   * @example match('foo', /foo/);
+   * @example notMatch('foo', /bar/);
+   */
+  (actual: string, regex: RegExp): void;
+}
+declare const match: IsMatch, notMatch: IsMatch;
+//#endregion
+//#region src/assert/rejects.d.ts
+interface Rejects {
+  /**
+   * check if promise rejects
+   * @param promise
+   * @example rejects(Promise.reject());
+   */
+  (promise: Promise<any>, message?: string): Promise<void>;
+  /**
+   * check if promise rejects with an instance of constructor
+   * @param promise
+   * @param constructor - expected error constructor
+   * @example rejects(Promise.reject(new Error()), Error);
+   */
+  (promise: Promise<any>, constructor: Constructor, message?: string): Promise<void>;
+  /**
+   * check if promise rejects with a specific error message
+   * @param promise
+   * @param regex - expected error message regex
+   * @example rejects(Promise.reject(new Error('This is worrying)), /worrying/);
+   */
+  (promise: Promise<any>, constructor: RegExp, message?: string): Promise<void>;
+  /**
+   * check if promise rejects with and matches the predicate function
+   * @param promise
+   * @param predicate - predicate function that receives the error and returns boolean
+   * @example rejects(Promise.reject(new Error('This is worrying')), (error) => error.message === 'This is worrying');));
+   */
+  (promise: Promise<any>, constructor: ErrorPredicate, message?: string): Promise<void>;
+}
+declare const rejects: Rejects, notRejects: Rejects;
+//#endregion
+//#region src/assert/deep-has-property.d.ts
+interface DeepHasProperty {
+  /**
+   * check if object has a property
+   * @param object
+   * @param property a property in the object. Can be a path like 'a.b.c'
+   * @example deepHasProperty([{a: {b: {c: 1}}}], '[0].a.b.c');
+   */
+  (object: any, property: string): void;
+  /**
+   * check if object has a property with a specific value
+   * @param object
+   * @param property a property in the object. Can be a path like 'a.b.c'
+   * @param value
+   * @example deepHasProperty([{a: {b: {c: 1}}}], '[0].a.b.c', 1);
+   */
+  (object: any, property: string, value: any): void;
+}
+declare const deepHasProperty: DeepHasProperty, deepNotHasProperty: DeepHasProperty;
+//#endregion
+//#region src/assert/starts-with.d.ts
+interface StartsWith {
+  /**
+   * check if string starts with start
+   * @param string
+   * @param start
+   * @example startsWith('foo', 'f');
+   */
+  (string: string, start: string): void;
+}
+declare const startsWith: StartsWith, notStartsWith: StartsWith;
+//#endregion
+//#region src/assert/ends-with.d.ts
+interface EndsWith {
+  /**
+   * check if string ends with a specific string
+   * @param string
+   * @param end
+   */
+  (string: string, end: string): void;
+}
+declare const endsWith: EndsWith, notEndsWith: EndsWith;
+//#endregion
+//#region src/assert/is-before.d.ts
+interface IsBefore {
+  /**
+   * check that date is before another date
+   */
+  <T extends Date>(actual: T, expected: T, message?: string): void;
+}
+declare const isBefore: IsBefore, notBefore: IsBefore;
+//#endregion
+//#region src/assert/is-after.d.ts
+interface IsAfter {
+  /**
+   * check that date is after another date
+   */
+  <T extends Date>(actual: T, expected: T): void;
+}
+declare const isAfter: IsAfter, notAfter: IsAfter;
+//#endregion
+//#region src/assert/is-between.d.ts
+interface IsBetweenOptions {
+  inclusive?: boolean;
+}
+interface IsBetween {
+  /**
+   * check that date is Between another date
+   */
+  <T extends Date>(actual: T, start: T, end: T, options?: IsBetweenOptions): void;
+  <T extends number>(actual: T, start: T, end: T, options?: IsBetweenOptions): void;
+}
+declare const isBetween: IsBetween, notBetween: IsBetween;
+//#endregion
+//#region src/assert/in-ballpark.d.ts
+interface InBallpark {
+  /**
+   * check if a number is in ballpark of another number. See also roundTo
+   * @param actual
+   * @param expected
+   * @param [allowedDifferenceMultiplier=0.1] - a number between 0 and 1 (exclusive). 0.1 (default) means 10% difference is allowed.
+   * @example inBallpark(1, 1.1);
+   * @example inBallpark(1, 1.1, 0.1);
+   */
+  (actual: number, expected: number, allowedDifferenceMultiplier?: number): void;
+}
+declare const inBallpark: InBallpark, notInBallpark: InBallpark;
+//#endregion
+//#region src/assert/round-to.d.ts
+interface RoundTo {
+  /**
+   * check if value rounds to target
+   * @param actual
+   * @param expected
+   * @param [decimals=0] - number of decimals to round to, defaults to 0
+   * @example roundTo(1.234, 1.23, 2);
+   */
+  (actual: number, expected: number, decimals?: number): void;
+}
+declare const roundTo: RoundTo, notRoundTo: RoundTo;
+//#endregion
+//#region src/assert/has-members.d.ts
+interface HasMembersOptions {
+  /**
+   * check for deep equality (ie {a: 1} === {a: 1})
+   * @default false
+   * @example
+   * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });
+   */
+  deep?: boolean;
+  /**
+   * use partial matching (ie {a: 1, b: 2} === {a: 1})
+   * implies deep
+   * @default false
+   * @example
+   * hasMembers([{ a: 1, b: 2 }], [{ a: 1 }], { partial: true });
+   */
+  partial?: boolean;
+  /**
+   * check that all the members in the first array are present in the second one
+   * @default false
+   * @example
+   * hasMembers([1, 2], [2, 1], { same: true });
+   * notHasMembers([1, 2], [1], { same: true});
+   */
+  same?: boolean;
+  /**
+   * check that the members in the first array are in the same order as the second one
+   * @default false
+   * @example
+   * hasMembers([1, 2], [1, 2], { ordered: true });
+   * notHasMembers([1, 2], [2, 1], { ordered: true });
+   */
+  ordered?: boolean;
+}
+interface HasMembers {
+  /**
+   * check that the members in second array are present in the first one
+   * @example
+   * hasMembers([1], [1]);
+   * hasMembers([1, 2], [2, 1]);
+   * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });
+   */
+  <T>(actual: T[], expected: T[], options?: HasMembersOptions, message?: string): void;
+}
+declare const hasMembers: HasMembers, notHasMembers: HasMembers;
+//#endregion
+//#region src/assert/has-keys.d.ts
+interface HasKeys {
+  /**
+   * check if object has keys
+   * @param object
+   * @param keys a key or array of keys in the object.
+   * @example hasKeys({a: 1}, 'a');
+   * @example hasKeys({a: 1, b: 2}, ['a', 'b']);
+   */
+  <T extends Record<string, any>, K extends keyof T>(object: T, keys: K[] | K, message?: string): void;
+  <K, T extends Map<K, any>>(object: T, keys: K[] | K, message?: string): void;
+}
+declare const hasKeys: HasKeys, notHasKeys: HasKeys;
+declare namespace assert_d_exports {
+  export { assert, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, notThrows, rejects, roundTo, startsWith, throws };
+}
+declare const assert: () => never;
+//#endregion
+export { ValueType, assert, assert_d_exports, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, rejects, roundTo, startsWith };
+//# sourceMappingURL=assert-9EsvfQwn.d.cts.map

package/dist/assert-9EsvfQwn.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-9EsvfQwn.d.cts","names":[],"sources":["../src/assert/deep-equal.ts","../src/assert/equal.ts","../src/assert/greater-than.ts","../src/assert/greater-than-equal.ts","../src/assert/has-property.ts","../src/assert/has-size.ts","../src/assert/includes.ts","../src/assert/instance-of.ts","../src/assert/is-empty.ts","../src/utils/get-type.ts","../src/assert/is-type.ts","../src/assert/less-than.ts","../src/assert/less-than-equal.ts","../src/assert/match.ts","../src/assert/rejects.ts","../src/assert/deep-has-property.ts","../src/assert/starts-with.ts","../src/assert/ends-with.ts","../src/assert/is-before.ts","../src/assert/is-after.ts","../src/assert/is-between.ts","../src/assert/in-ballpark.ts","../src/assert/round-to.ts","../src/assert/has-members.ts","../src/assert/has-keys.ts","../src/assert.ts"],"sourcesContent":[],"mappings":"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"}