@oscarpalmer/atoms 0.184.1 → 0.185.0

package/dist/array/index.d.mts

@@ -11,7 +11,7 @@ import { shuffle } from "../internal/array/shuffle.mjs";
 import { insert } from "./insert.mjs";
 import { intersection } from "./intersection.mjs";
 import { partition } from "./partition.mjs";
-import { ArrayPosition, endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray } from "./position.mjs";
+import { ArrayComparison, endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray } from "./match.mjs";
 import { push } from "./push.mjs";
 import { reverse } from "./reverse.mjs";
 import { select } from "./select.mjs";
@@ -23,4 +23,4 @@ import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { ArrayPosition, chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };
+export { ArrayComparison, chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayComparison, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/index.mjs

@@ -11,7 +11,7 @@ import { getArray } from "./get.mjs";
 import { insert } from "./insert.mjs";
 import { intersection } from "./intersection.mjs";
 import { partition } from "./partition.mjs";
-import { endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray } from "./position.mjs";
+import { endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray } from "./match.mjs";
 import { push } from "./push.mjs";
 import { reverse } from "./reverse.mjs";
 import { select } from "./select.mjs";
@@ -23,4 +23,4 @@ import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };
+export { chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayComparison, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/{position.d.mts → match.d.mts}

@@ -1,7 +1,10 @@
 import { PlainObject } from "../models.mjs";
 
-//#region src/array/position.d.ts
-type ArrayPosition = 'end' | 'inside' | 'invalid' | 'outside' | 'same' | 'start';
+//#region src/array/match.d.ts
+/**
+ * Comparison of an array within another array
+ */
+type ArrayComparison = 'end' | 'inside' | 'invalid' | 'outside' | 'same' | 'start';
 /**
  * Does the needle array end the haystack array?
  * @param haystack Haystack array
@@ -32,7 +35,7 @@ declare function endsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
  * @param key Key to get an item's value for matching
  * @returns Position of the needle within the haystack
  */
-declare function getArrayPosition<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): ArrayPosition;
+declare function getArrayComparison<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): ArrayComparison;
 /**
  * Get the position of an array within another array
  * @param haystack Haystack array
@@ -40,14 +43,14 @@ declare function getArrayPosition<Item extends PlainObject>(haystack: Item[], ne
  * @param callback Callback to get an item's value for matching
  * @returns Position of the needle within the haystack
  */
-declare function getArrayPosition<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): ArrayPosition;
+declare function getArrayComparison<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): ArrayComparison;
 /**
  * Get the position of an array within another array
  * @param haystack Haystack array
  * @param needle Needle array
  * @returns Position of the needle within the haystack
  */
-declare function getArrayPosition<Item>(haystack: Item[], needle: Item[]): ArrayPosition;
+declare function getArrayComparison<Item>(haystack: Item[], needle: Item[]): ArrayComparison;
 /**
  * Does the needle array exist within the haystack array?
  * @param haystack Haystack array
@@ -118,4 +121,4 @@ declare function startsWithArray<Item>(haystack: Item[], needle: Item[], callbac
  */
 declare function startsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
 //#endregion
-export { ArrayPosition, endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray };
+export { ArrayComparison, endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray };

package/dist/array/{position.mjs → match.mjs}

@@ -1,14 +1,14 @@
 import { getArrayCallback } from "../internal/array/callbacks.mjs";
-//#region src/array/position.ts
+//#region src/array/match.ts
 function endsWithArray(haystack, needle, key) {
 	return endings.has(getPosition(haystack, needle, key)[1]);
 }
-function getArrayPosition(haystack, needle, key) {
+function getArrayComparison(haystack, needle, key) {
 	return getPosition(haystack, needle, key)[1];
 }
 function getName(start, haystack, needle) {
-	if (start === 0) return haystack === needle ? POSITION_SAME : POSITION_START;
-	return start + needle === haystack ? POSITION_END : POSITION_INSIDE;
+	if (start === 0) return haystack === needle ? COMPARISON_SAME : COMPARISON_START;
+	return start + needle === haystack ? COMPARISON_END : COMPARISON_INSIDE;
 }
 function getPosition(haystack, needle, key) {
 	if (!Array.isArray(haystack) || !Array.isArray(needle)) return invalid;
@@ -43,16 +43,16 @@ function indexOfArray(haystack, needle, key) {
 function startsWithArray(haystack, needle, key) {
 	return starts.has(getPosition(haystack, needle, key)[1]);
 }
-const POSITION_END = "end";
-const POSITION_INSIDE = "inside";
-const POSITION_INVALID = "invalid";
-const POSITION_OUTSIDE = "outside";
-const POSITION_SAME = "same";
-const POSITION_START = "start";
-const endings = new Set([POSITION_END, POSITION_SAME]);
-const invalid = [-1, POSITION_INVALID];
-const outside = [-1, POSITION_OUTSIDE];
-const outsides = new Set([POSITION_INVALID, POSITION_OUTSIDE]);
-const starts = new Set([POSITION_START, POSITION_SAME]);
+const COMPARISON_END = "end";
+const COMPARISON_INSIDE = "inside";
+const COMPARISON_INVALID = "invalid";
+const COMPARISON_OUTSIDE = "outside";
+const COMPARISON_SAME = "same";
+const COMPARISON_START = "start";
+const endings = new Set([COMPARISON_END, COMPARISON_SAME]);
+const invalid = [-1, COMPARISON_INVALID];
+const outside = [-1, COMPARISON_OUTSIDE];
+const outsides = new Set([COMPARISON_INVALID, COMPARISON_OUTSIDE]);
+const starts = new Set([COMPARISON_START, COMPARISON_SAME]);
 //#endregion
-export { endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray };
+export { endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray };

package/dist/array/move.mjs

@@ -1,4 +1,4 @@
-import { indexOfArray } from "./position.mjs";
+import { indexOfArray } from "./match.mjs";
 import { arraysOverlap } from "../internal/array/overlap.mjs";
 //#region src/array/move.ts
 function move(array, from, to, key) {

package/dist/array/single.mjs

@@ -2,9 +2,9 @@ import { findValues } from "../internal/array/find.mjs";
 //#region src/array/single.ts
 function single(array, ...parameters) {
 	const { matched } = findValues("all", array, parameters);
-	if (matched.length > 1) throw new Error(MESSAGE);
+	if (matched.length > 1) throw new Error(SINGLE_MESSAGE);
 	return matched[0];
 }
-const MESSAGE = "Multiple items were found";
+const SINGLE_MESSAGE = "Multiple items were found";
 //#endregion
 export { single };

package/dist/array/sort.d.mts

@@ -65,6 +65,11 @@ type ComparisonSorter<Item> = (first: Item, second: Item) => number;
  * Direction to sort by
  */
 type SortDirection = 'ascending' | 'descending';
+/**
+ * Sorter for an array with predefined sorters
+ *
+ * Can be used to sort an array, get the predicted index for an item, and check if an array is sorted
+ */
 type Sorter<Item> = {
   /**
    * Sort an array of items
@@ -93,7 +98,7 @@ type Sorter<Item> = {
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
  *
- * Available as `getSortedIndex` and `sort.index`
+ * Available as `getSortedIndex` and `sort.getIndex`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorters Sorters to use to determine sorting
@@ -106,7 +111,7 @@ declare function getSortedIndex<Item>(array: Item[], item: Item, sorters: Array<
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
  *
- * Available as `getSortedIndex` and `sort.index`
+ * Available as `getSortedIndex` and `sort.getIndex`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorter Sorter to use to determine sorting
@@ -119,7 +124,7 @@ declare function getSortedIndex<Item>(array: Item[], item: Item, sorter: ArraySo
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
  *
- * Available as `getSortedIndex` and `sort.index`
+ * Available as `getSortedIndex` and `sort.getIndex`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param descending Sorted in descending order? _(defaults to `false`)_
@@ -209,7 +214,7 @@ declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending
  */
 declare function sort<Item>(array: Item[], descending?: boolean): Item[];
 declare namespace sort {
-  var index: typeof getSortedIndex;
+  var getIndex: typeof getSortedIndex;
   var initialize: typeof initializeSorter;
   var is: typeof isSorted;
 }

package/dist/array/sort.mjs

@@ -98,9 +98,9 @@ function isSortedArray(array, sorters) {
 	if (length < 2) return true;
 	const sortersLength = sorters.length;
 	let offset = 0;
-	if (length >= ARRAY_THRESHOLD) {
-		offset = Math.round(length / ARRAY_PEEK_PERCENTAGE);
-		offset = offset > ARRAY_THRESHOLD ? ARRAY_THRESHOLD : offset;
+	if (length >= SORT_THRESHOLD) {
+		offset = Math.round(length / SORT_PEEK_PERCENTAGE);
+		offset = offset > SORT_THRESHOLD ? SORT_THRESHOLD : offset;
 		for (let index = 0; index < offset; index += 1) {
 			const [firstItem, firstOffset] = [array[index], array[index + 1]];
 			const [secondItem, secondOffset] = [array[length - index - 2], array[length - index - 1]];
@@ -124,11 +124,11 @@ function sortArray(array, sorters) {
 	const { length } = sorters;
 	return array.length > 1 ? array.sort((first, second) => getComparisonValue(first, second, sorters, length)) : array;
 }
-sort.index = getSortedIndex;
+sort.getIndex = getSortedIndex;
 sort.initialize = initializeSorter;
 sort.is = isSorted;
-const ARRAY_PEEK_PERCENTAGE = 10;
-const ARRAY_THRESHOLD = 100;
+const SORT_PEEK_PERCENTAGE = 10;
+const SORT_THRESHOLD = 100;
 const SORT_DIRECTION_ASCENDING = "ascending";
 const SORT_DIRECTION_DESCENDING = "descending";
 const modifiers = {

package/dist/array/swap.mjs

@@ -1,6 +1,6 @@
 import { getArrayCallback } from "../internal/array/callbacks.mjs";
 import { indexOf } from "../internal/array/index-of.mjs";
-import { indexOfArray } from "./position.mjs";
+import { indexOfArray } from "./match.mjs";
 import { arraysOverlap } from "../internal/array/overlap.mjs";
 //#region src/array/swap.ts
 function swap(array, first, second, third) {

package/dist/beacon.d.mts

@@ -1,4 +1,7 @@
 //#region src/beacon.d.ts
+/**
+ * A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
+ */
 declare class Beacon<Value> {
   #private;
   /**
@@ -48,6 +51,9 @@ type BeaconOptions<Value> = {
    */
   equal?: (first: Value, second: Value) => boolean;
 };
+/**
+ * An observable holds a value and allows observers to subscribe to changes in that value
+ */
 declare class Observable<Value> {
   #private;
   constructor(instance: Beacon<Value>, observers: Map<Subscription<Value>, Observer<Value>>);
@@ -75,6 +81,9 @@ type ObservableState<Value> = {
   closed: boolean;
   observers: Map<Subscription<Value>, Observer<Value>>;
 };
+/**
+ * An observer receives notifications from an observable
+ */
 type Observer<Value> = {
   /**
    * Callback for when the observable is completed
@@ -89,6 +98,9 @@ type Observer<Value> = {
    */
   next?: (value: Value) => void;
 };
+/**
+ * A subscription represents an active subscription to an observable, holding its state and allowing it to be destroyed or unsubscribed from
+ */
 declare class Subscription<Value> {
   #private;
   constructor(state: ObservableState<Value>);

package/dist/beacon.mjs

@@ -1,6 +1,9 @@
 import { noop } from "./internal/function/misc.mjs";
 import { isPlainObject } from "./internal/is.mjs";
 //#region src/beacon.ts
+/**
+* A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
+*/
 var Beacon = class {
 	#options;
 	#state;
@@ -71,6 +74,9 @@ var Beacon = class {
 		if (finish === true) finishBeacon(this.#state, true);
 	}
 };
+/**
+* An observable holds a value and allows observers to subscribe to changes in that value
+*/
 var Observable = class {
 	#state;
 	constructor(instance, observers) {
@@ -95,6 +101,9 @@ var Observable = class {
 		return instance;
 	}
 };
+/**
+* A subscription represents an active subscription to an observable, holding its state and allowing it to be destroyed or unsubscribed from
+*/
 var Subscription = class {
 	#state;
 	constructor(state) {

package/dist/color/instance.d.mts

@@ -1,8 +1,16 @@
 import { HSLAColor, HSLColor, RGBAColor, RGBColor } from "./models.mjs";
 
 //#region src/color/instance.d.ts
+/**
+ * A color that is represented in multiple color formats
+ */
 declare class Color {
   #private;
+  /**
+   * A property to identify this as a Color instance, used for type checking
+   *
+   * @internal
+   */
   private readonly $color;
   /**
    * Get the alpha channel

package/dist/color/instance.mjs

@@ -1,8 +1,11 @@
 import "./constants.mjs";
 import { formatColor } from "./misc/index.mjs";
 import { getAlpha } from "./misc/alpha.mjs";
-import { getState, setHSLColor, setHexColor, setRGBColor } from "./misc/state.mjs";
+import { getColorState, setHSLColor, setHexColor, setRGBColor } from "./misc/state.mjs";
 //#region src/color/instance.ts
+/**
+* A color that is represented in multiple color formats
+*/
 var Color = class {
 	#state;
 	/**
@@ -96,7 +99,7 @@ var Color = class {
 		setRGBColor(this.#state, value, true);
 	}
 	constructor(value) {
-		this.#state = getState(value);
+		this.#state = getColorState(value);
 		Object.defineProperty(this, "$color", { value: true });
 	}
 	toHexString(alpha) {

package/dist/color/misc/get.mjs

@@ -1,6 +1,6 @@
 import { clamp } from "../../internal/number.mjs";
 import { HEX_BLACK, HEX_WHITE, SRGB_LUMINANCE_EXPONENT, SRGB_LUMINANCE_MODIFIER, SRGB_LUMINANCE_MULTIPLIER, SRGB_LUMINANCE_OFFSET } from "../constants.mjs";
-import { getState } from "./state.mjs";
+import { getColorState } from "./state.mjs";
 import { Color } from "../instance.mjs";
 //#region src/color/misc/get.ts
 function getClampedValue(value, minimum, maximum) {
@@ -12,7 +12,7 @@ function getClampedValue(value, minimum, maximum) {
 * @returns Foreground color
 */
 function getForegroundColor(value) {
-	const { blue, green, red } = getState(value).rgb;
+	const { blue, green, red } = getColorState(value).rgb;
 	const values = [
 		blue / 255,
 		green / 255,
@@ -32,7 +32,7 @@ function getForegroundColor(value) {
 * @returns Hex color
 */
 function getHexaColor(value) {
-	const { alpha, hex } = getState(value);
+	const { alpha, hex } = getColorState(value);
 	return `${hex}${alpha.hex}`;
 }
 /**
@@ -41,7 +41,7 @@ function getHexaColor(value) {
 * @returns Hex color
 */
 function getHexColor(value) {
-	return getState(value).hex;
+	return getColorState(value).hex;
 }
 function getHexValue(value) {
 	return getClampedValue(value, 0, 255);
@@ -55,7 +55,7 @@ function getDegrees(value) {
 * @returns HSLA color
 */
 function getHslaColor(value) {
-	const { alpha, hsl } = getState(value);
+	const { alpha, hsl } = getColorState(value);
 	return {
 		...hsl,
 		alpha: alpha.value
@@ -67,7 +67,7 @@ function getHslaColor(value) {
 * @returns HSL color
 */
 function getHslColor(value) {
-	return getState(value).hsl;
+	return getColorState(value).hsl;
 }
 function getPercentage(value) {
 	return getClampedValue(value, 0, 100);
@@ -78,7 +78,7 @@ function getPercentage(value) {
 * @returns RGBA color
 */
 function getRgbaColor(value) {
-	const { alpha, rgb } = getState(value);
+	const { alpha, rgb } = getColorState(value);
 	return {
 		...rgb,
 		alpha: alpha.value
@@ -90,7 +90,7 @@ function getRgbaColor(value) {
 * @returns RGB color
 */
 function getRgbColor(value) {
-	return getState(value).rgb;
+	return getColorState(value).rgb;
 }
 //#endregion
 export { getDegrees, getForegroundColor, getHexColor, getHexValue, getHexaColor, getHslColor, getHslaColor, getPercentage, getRgbColor, getRgbaColor };

package/dist/color/misc/state.d.mts

@@ -1,9 +1,9 @@
 import { ColorState } from "../models.mjs";
 
 //#region src/color/misc/state.d.ts
-declare function getState(value: unknown): ColorState;
+declare function getColorState(value: unknown): ColorState;
 declare function setHexColor(state: ColorState, value: string, alpha: boolean): void;
 declare function setHSLColor(state: ColorState, value: unknown, alpha: boolean): void;
 declare function setRGBColor(state: ColorState, value: unknown, alpha: boolean): void;
 //#endregion
-export { getState, setHSLColor, setHexColor, setRGBColor };
+export { getColorState, setHSLColor, setHexColor, setRGBColor };

package/dist/color/misc/state.mjs

@@ -6,7 +6,7 @@ import { getRgbValue, rgbToHex, rgbToHsl } from "../space/rgb.mjs";
 import { getNormalizedHex, hexToRgb } from "../space/hex.mjs";
 import { getHslValue, hslToRgb } from "../space/hsl.mjs";
 //#region src/color/misc/state.ts
-function getState(value) {
+function getColorState(value) {
 	if (typeof value === "string") {
 		const normalized = getNormalizedHex(value, true);
 		const hex = normalized.slice(0, 6);
@@ -82,4 +82,4 @@ function setRGBColor(state, value, alpha) {
 	if (alpha) state.alpha = getAlpha(value.alpha);
 }
 //#endregion
-export { getState, setHSLColor, setHexColor, setRGBColor };
+export { getColorState, setHSLColor, setHexColor, setRGBColor };

package/dist/color/models.d.mts

@@ -6,16 +6,46 @@ type Alpha = {
 type ColorWithAlpha = {
   alpha: number;
 };
+/**
+ * An _HSL_-color with an alpha channel
+ */
 type HSLAColor = HSLColor & ColorWithAlpha;
+/**
+ * An _HSL_-color
+ */
 type HSLColor = {
+  /**
+   * Hue of the color _(in degrees; 0-360)_
+   */
   hue: number;
+  /**
+   * Lightness of the color _(in percentage; 0-100)_
+   */
   lightness: number;
+  /**
+   * Saturation of the color _(in percentage; 0-100)_
+   */
   saturation: number;
 };
+/**
+ * An _RGB_-color with an alpha channel
+ */
 type RGBAColor = RGBColor & ColorWithAlpha;
+/**
+ * An _RGB_-color
+ */
 type RGBColor = {
+  /**
+   * Blue channel of the color _(in hexadecimal; 0-255)_
+   */
   blue: number;
+  /**
+   * Green channel of the color _(in hexadecimal; 0-255)_
+   */
   green: number;
+  /**
+   * Red channel of the color _(in hexadecimal; 0-255)_
+   */
   red: number;
 };
 type ColorProperty = 'alpha' | 'blue' | 'green' | 'hue' | 'lightness' | 'red' | 'saturation';

package/dist/function/assert.d.mts

@@ -1,12 +1,20 @@
-import { Constructor } from "../models.mjs";
+import { Constructor, NestedKeys, NestedValue, PlainObject } from "../models.mjs";
 
 //#region src/function/assert.d.ts
+/**
+ * Asserter for a nested property of a value
+ */
+type AssertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted extends NestedPick<Value, Path> = NestedPick<Value, Path>> = Asserter<Asserted>;
+/**
+ * A function that asserts a value is of a specific type, throwing an error if it is not
+ */
 type Asserter<Value> = (value: unknown) => asserts value is Value;
+type NestedPick<Value, Path extends string> = Value extends PlainObject ? Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Value ? { [Key in Head]: NestedPick<Value[Key], Rest> } : never : Path extends keyof Value ? { [Key in Path]: Value[Key] } : never : never;
 /**
  * Asserts that a condition is true, throwing an error if it is not
  * @param condition Condition to assert
  * @param message Error message
- * @param error Error constructor
+ * @param error Error constructor _(defaults to `Error`)_
  */
 declare function assert<Condition extends () => boolean>(condition: Condition, message: string, error?: ErrorConstructor): asserts condition;
 declare namespace assert {
@@ -14,6 +22,7 @@ declare namespace assert {
   var defined: typeof assertDefined;
   var instanceOf: typeof assertInstanceOf;
   var is: typeof assertIs;
+  var property: typeof assertProperty;
 }
 /**
  * Creates an asserter that asserts a condition is true, throwing an error if it is not
@@ -21,25 +30,26 @@ declare namespace assert {
  * Available as `assertCondition` and `assert.condition`
  * @param condition Condition to assert
  * @param message Error message
- * @param error Error constructor
+ * @param error Error constructor _(defaults to `Error`)_
  * @returns Asserter
  */
 declare function assertCondition<Value>(condition: (value: unknown) => boolean, message: string, error?: ErrorConstructor): Asserter<Value>;
 /**
- * Asserts that a value is defined throwing an error if it is not
+ * Asserts that a value is defined, throwing an error if it is not
  *
  * Available as `assertDefined` and `assert.defined`
  * @param value Value to assert
  * @param message Error message
+ * @param error Error constructor _(defaults to `Error`)_
  */
-declare function assertDefined<Value>(value: unknown, message?: string): asserts value is Exclude<Value, null | undefined>;
+declare function assertDefined<Value>(value: unknown, message?: string, error?: ErrorConstructor): asserts value is Exclude<Value, null | undefined>;
 /**
  * Creates an asserter that asserts a value is an instance of a constructor, throwing an error if it is not
  *
  * Available as `assertInstanceOf` and `assert.instanceOf`
  * @param constructor Constructor to check against
  * @param message Error message
- * @param error Error constructor
+ * @param error Error constructor _(defaults to `Error`)_
  * @returns Asserter
  */
 declare function assertInstanceOf<Value>(constructor: Constructor<Value>, message: string, error?: ErrorConstructor): Asserter<Value>;
@@ -49,9 +59,20 @@ declare function assertInstanceOf<Value>(constructor: Constructor<Value>, messag
  * Available as `assertIs` and `assert.is`
  * @param condition Type guard function to check the value
  * @param message Error message
- * @param error Error constructor
+ * @param error Error constructor _(defaults to `Error`)_
  * @returns Asserter
  */
 declare function assertIs<Value>(condition: (value: unknown) => value is Value, message: string, error?: ErrorConstructor): Asserter<Value>;
+/**
+ * Creates an asserter that asserts a property of a value exists and satisfies a condition, throwing an error if it does not
+ *
+ * Available as `assertProperty` and `assert.property`
+ * @param path Path to the property to check, e.g., `foo.bar.baz` for a nested property
+ * @param condition Condition to assert for the property
+ * @param message Error message
+ * @param error Error constructor _(defaults to `Error`)_
+ * @returns Asserter
+ */
+declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted = NestedPick<Value, Path>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<Asserted>;
 //#endregion
-export { Asserter, assert, assertCondition, assertDefined, assertInstanceOf, assertIs };
+export { AssertProperty, Asserter, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty };

package/dist/function/assert.mjs

@@ -1,9 +1,10 @@
+import { hasValueResult } from "../internal/value/has.mjs";
 //#region src/function/assert.ts
 /**
 * Asserts that a condition is true, throwing an error if it is not
 * @param condition Condition to assert
 * @param message Error message
-* @param error Error constructor
+* @param error Error constructor _(defaults to `Error`)_
 */
 function assert(condition, message, error) {
 	if (!condition()) throw new (error ?? Error)(message);
@@ -12,13 +13,14 @@ assert.condition = assertCondition;
 assert.defined = assertDefined;
 assert.instanceOf = assertInstanceOf;
 assert.is = assertIs;
+assert.property = assertProperty;
 /**
 * Creates an asserter that asserts a condition is true, throwing an error if it is not
 *
 * Available as `assertCondition` and `assert.condition`
 * @param condition Condition to assert
 * @param message Error message
-* @param error Error constructor
+* @param error Error constructor _(defaults to `Error`)_
 * @returns Asserter
 */
 function assertCondition(condition, message, error) {
@@ -27,14 +29,15 @@ function assertCondition(condition, message, error) {
 	};
 }
 /**
-* Asserts that a value is defined throwing an error if it is not
+* Asserts that a value is defined, throwing an error if it is not
 *
 * Available as `assertDefined` and `assert.defined`
 * @param value Value to assert
 * @param message Error message
+* @param error Error constructor _(defaults to `Error`)_
 */
-function assertDefined(value, message) {
-	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED);
+function assertDefined(value, message, error) {
+	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED, error);
 }
 /**
 * Creates an asserter that asserts a value is an instance of a constructor, throwing an error if it is not
@@ -42,7 +45,7 @@ function assertDefined(value, message) {
 * Available as `assertInstanceOf` and `assert.instanceOf`
 * @param constructor Constructor to check against
 * @param message Error message
-* @param error Error constructor
+* @param error Error constructor _(defaults to `Error`)_
 * @returns Asserter
 */
 function assertInstanceOf(constructor, message, error) {
@@ -56,7 +59,7 @@ function assertInstanceOf(constructor, message, error) {
 * Available as `assertIs` and `assert.is`
 * @param condition Type guard function to check the value
 * @param message Error message
-* @param error Error constructor
+* @param error Error constructor _(defaults to `Error`)_
 * @returns Asserter
 */
 function assertIs(condition, message, error) {
@@ -64,6 +67,24 @@ function assertIs(condition, message, error) {
 		assert(() => condition(value), message, error);
 	};
 }
+/**
+* Creates an asserter that asserts a property of a value exists and satisfies a condition, throwing an error if it does not
+*
+* Available as `assertProperty` and `assert.property`
+* @param path Path to the property to check, e.g., `foo.bar.baz` for a nested property
+* @param condition Condition to assert for the property
+* @param message Error message
+* @param error Error constructor _(defaults to `Error`)_
+* @returns Asserter
+*/
+function assertProperty(path, condition, message, error) {
+	return (value) => {
+		assert(() => {
+			const result = hasValueResult(value, path, false);
+			return result.ok && condition(result.value);
+		}, message, error);
+	};
+}
 const MESSAGE_VALUE_DEFINED = "Expected value to be defined";
 //#endregion
-export { assert, assertCondition, assertDefined, assertInstanceOf, assertIs };
+export { assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty };