@oscarpalmer/atoms 0.213.0 → 0.214.0

package/dist/internal/value/has.d.mts

@@ -1,5 +1,5 @@
-import { NestedKeys, NestedValue, PlainObject, ToString } from "../../models.mjs";
-import { Result } from "../models/result.model.mjs";
+import { NestedKeys, NestedValue, PlainObject, ToString } from "../../models/index.mjs";
+import { Result } from "../../models/result.model.mjs";
 //#region src/internal/value/has.d.ts
 /**
  * Check if a property is defined in an object

package/dist/internal/value/misc.d.mts

@@ -1,4 +1,4 @@
-import { Result } from "../models/result.model.mjs";
+import { Result } from "../../models/result.model.mjs";
 //#region src/internal/value/misc.d.ts
 export declare function findKey(needle: string, haystack: object): string;
 export declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, string>;

package/dist/internal/value/misc.mjs

@@ -1,3 +1,4 @@
+import { VALUE_MISC_EXPRESSION_BRACKET, VALUE_MISC_EXPRESSION_DOTS, VALUE_MISC_EXPRESSION_NESTED, VALUE_MISC_NESTED_MESSAGE_INPUT, VALUE_MISC_NESTED_MESSAGE_MISSING, VALUE_MISC_NESTED_MESSAGE_PATH, VALUE_MISC_NESTED_MESSAGE_UNSAFE } from "../../models/value/value.misc.model.mjs";
 import { error, ok } from "../result/misc.mjs";
 import { ignoreKey } from "../string/misc.mjs";
 //#region src/internal/value/misc.ts
@@ -7,8 +8,8 @@ function findKey(needle, haystack) {
 	return index > -1 ? keys[index] : needle;
 }
 function getNestedValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null) return error(MISC_NESTED_MESSAGE_INPUT);
-	if (typeof path !== "string" || path.trim().length === 0) return error(MISC_NESTED_MESSAGE_PATH);
+	if (typeof data !== "object" || data === null) return error(VALUE_MISC_NESTED_MESSAGE_INPUT);
+	if (typeof path !== "string" || path.trim().length === 0) return error(VALUE_MISC_NESTED_MESSAGE_PATH);
 	const shouldIgnoreCase = ignoreCase === true;
 	const paths = getPaths(path, shouldIgnoreCase);
 	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
@@ -24,25 +25,18 @@ function getNestedValue(data, path, ignoreCase) {
 }
 function getPaths(path, lowercase) {
 	const normalized = lowercase ? path.toLowerCase() : path;
-	if (!MISC_EXPRESSION_NESTED.test(normalized)) return normalized;
-	return normalized.replace(MISC_EXPRESSION_BRACKET, ".$1").replace(MISC_EXPRESSION_DOTS, "").split(".");
+	if (!VALUE_MISC_EXPRESSION_NESTED.test(normalized)) return normalized;
+	return normalized.replace(VALUE_MISC_EXPRESSION_BRACKET, ".$1").replace(VALUE_MISC_EXPRESSION_DOTS, "").split(".");
 }
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null) {
-		if (ignoreKey(path)) return error(MISC_NESTED_MESSAGE_UNSAFE);
+		if (ignoreKey(path)) return error(VALUE_MISC_NESTED_MESSAGE_UNSAFE);
 		const dataObject = data;
 		const key = ignoreCase ? findKey(path, dataObject) : path;
-		if (get) return key in dataObject ? ok(dataObject[key]) : error(MISC_NESTED_MESSAGE_MISSING);
+		if (get) return key in dataObject ? ok(dataObject[key]) : error(VALUE_MISC_NESTED_MESSAGE_MISSING);
 		dataObject[key] = typeof value === "function" ? value(dataObject[key]) : value;
 	}
-	if (get) return error(MISC_NESTED_MESSAGE_MISSING);
+	if (get) return error(VALUE_MISC_NESTED_MESSAGE_MISSING);
 }
-const MISC_EXPRESSION_BRACKET = /\[(\w+)\]/g;
-const MISC_EXPRESSION_DOTS = /^\.|\.$/g;
-const MISC_EXPRESSION_NESTED = /\.|\[\w+\]/;
-const MISC_NESTED_MESSAGE_INPUT = "Expected data to be an object";
-const MISC_NESTED_MESSAGE_MISSING = "Expected property to exist in object";
-const MISC_NESTED_MESSAGE_PATH = "Expected path to be a string";
-const MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
 //#endregion
 export { findKey, getNestedValue, getPaths, handleValue };

package/dist/internal/value/set.d.mts

@@ -1,4 +1,4 @@
-import { NestedKeys, NestedValue, PlainObject } from "../../models.mjs";
+import { NestedKeys, NestedValue, PlainObject } from "../../models/index.mjs";
 //#region src/internal/value/set.d.ts
 /**
  * Update the value in an object using a known path

package/dist/internal/value/set.mjs

@@ -1,5 +1,6 @@
 import { unwrap } from "../result/misc.mjs";
 import { getPaths, handleValue } from "./misc.mjs";
+import { EXPRESSION_INTEGER } from "../../models/misc.model.mjs";
 //#region src/internal/value/set.ts
 function setValue(data, path, value, ignoreCase) {
 	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return data;
@@ -21,7 +22,7 @@ function setValue(data, path, value, ignoreCase) {
 		let next = unwrap(handleValue(target, currentPath, null, true, shouldIgnoreCase), void 0);
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
-			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: +nextPath + 1 }, () => void 0);
+			if (EXPRESSION_INTEGER.test(nextPath)) next = Array.from({ length: +nextPath + 1 }, () => void 0);
 			else next = {};
 			target[currentPath] = next;
 		}
@@ -29,6 +30,5 @@ function setValue(data, path, value, ignoreCase) {
 	}
 	return data;
 }
-const SET_EXPRESSION_INDEX = /^\d+$/;
 //#endregion
 export { setValue };

package/dist/is.mjs

@@ -1,6 +1,7 @@
 import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonInstanceOf, isNonKey, isNonNumber, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNumber, isPlainObject, isPrimitive, isTemplateStringsArray, isTypedArray } from "./internal/is.mjs";
 import { getArray } from "./internal/array/get.mjs";
 import { getString } from "./internal/string/misc.mjs";
+import { EXPRESSION_WHITESPACE_ONLY } from "./models/misc.model.mjs";
 //#region src/is.ts
 /**
 * Is the value empty, or only containing `null` or `undefined` values?
@@ -53,7 +54,7 @@ function isNonNullableOrEmpty(value) {
 * @returns `true` if the value is not `undefined`, `null`, or matches a whitespace-only string, otherwise `false`
 */
 function isNonNullableOrWhitespace(value) {
-	return value != null && !EXPRESSION_WHITESPACE.test(getString(value));
+	return value != null && !EXPRESSION_WHITESPACE_ONLY.test(getString(value));
 }
 /**
 * Is the value not a number or a number-like string?
@@ -98,7 +99,7 @@ function isNullableOrEmpty(value) {
 * @returns `true` if the value is nullable or matches a whitespace-only string, otherwise `false`
 */
 function isNullableOrWhitespace(value) {
-	return value == null || EXPRESSION_WHITESPACE.test(getString(value));
+	return value == null || EXPRESSION_WHITESPACE_ONLY.test(getString(value));
 }
 /**
 * Is the value a number or a number-like string?
@@ -118,6 +119,5 @@ function isNumerical(value) {
 function isObject(value) {
 	return typeof value === "object" && value !== null || typeof value === "function";
 }
-const EXPRESSION_WHITESPACE = /^\s*$/;
 //#endregion
 export { isArrayOrPlainObject, isConstructor, isEmpty, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isPlainObject, isPrimitive, isTemplateStringsArray, isTypedArray };

package/dist/logger.d.mts

@@ -1,80 +1,13 @@
+import { Lumberjack, TimeLogger } from "./models/logger.model.mjs";
 //#region src/logger.d.ts
-type Logger = {
-  /**
-   * Log any number of values at the "debug" log level
-   */
-  get debug(): typeof console.debug;
-  /**
-   * Log the value and shows all its properties
-   */
-  get dir(): typeof console.dir;
-  /**
-   * Is logging to the console enabled? _(defaults to `true`)_
-   */
-  get enabled(): boolean;
-  /**
-   * Enable or disable logging to the console
-   */
-  set enabled(value: boolean);
-  /**
-   * Log any number of values at the "error" log level
-   */
-  get error(): typeof console.error;
-  /**
-   * Log any number of values at the "info" log level
-   */
-  get info(): typeof console.info;
-  /**
-   * Log any number of values at the "log" log level
-   */
-  get log(): typeof console.log;
-  /**
-   * Log data as a table, with optional properties to use as columns
-   */
-  get table(): typeof console.table;
-  /**
-   * Log any number of values together with a trace from where it was called
-   */
-  get trace(): typeof console.trace;
-  /**
-   * Log any number of values at the "warn" log level
-   */
-  get warn(): typeof console.warn;
-  /**
-   * Start a timed logger with a label
-   *
-   * @param label Label for the logger
-   * @returns _TimedLogger_ instance
-   */
-  time(label: string): TimeLogger;
-};
-/**
- * A named timer that can be used to log durations to the console
- */
-type TimeLogger = {
-  /**
-   * Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
-   */
-  get active(): boolean;
-  /**
-   * Log the current duration of the timer _(ignored if logging is disabled)_
-   */
-  get log(): () => void;
-  /**
-   * Stop the timer and logs the total duration
-   *
-   * _(Will always log the total duration, even if logging is disabled)_
-   */
-  get stop(): () => void;
-};
 declare function TimeLogger(this: any, label: string): void;
-declare function isLogger(value: unknown): value is Logger;
+declare function isLogger(value: unknown): value is Lumberjack;
 declare function isTimeLogger(value: unknown): value is TimeLogger;
 /**
  * A logger that can be used to log messages to the console
  *
  * _(Logging can be enabled or disabled by setting the `enabled` property)_
  */
-declare const Logger: Logger;
+declare const Logger: Lumberjack;
 //#endregion
 export { Logger, type TimeLogger, isLogger, isTimeLogger };

package/dist/logger.mjs

@@ -1,9 +1,7 @@
 import { noop } from "./internal/function/misc.mjs";
 import { getString } from "./internal/string/misc.mjs";
+import { LOGGER_NAME, LOGGER_NAME_TIMED, LOGGER_PROPERTY, LOGGER_SYMBOL } from "./models/logger.model.mjs";
 //#region src/logger.ts
-const LOGGER_NAME = "Logger";
-const LOGGER_NAME_TIMED = "TimedLogger";
-const LOGGER_PROPERTY = "$logger";
 function Lumberjack() {}
 Lumberjack.prototype[LOGGER_PROPERTY] = LOGGER_NAME;
 Lumberjack.prototype.time = getTimeLogger;
@@ -70,7 +68,7 @@ function isLogger(value) {
 	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
-	return typeof value === "object" && value !== null && LOGGER_PROPERTY in value && value[LOGGER_PROPERTY] === name;
+	return typeof value === "object" && value !== null && "$logger" in value && value["$logger"] === name;
 }
 function isTimeLogger(value) {
 	return isLoggerInstance(LOGGER_NAME_TIMED, value);
@@ -78,7 +76,6 @@ function isTimeLogger(value) {
 function setLoggerEnabled(value) {
 	enabled = typeof value === "boolean" ? value : enabled;
 }
-const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
 /**
 * A logger that can be used to log messages to the console
 *

package/dist/math.d.mts

@@ -1,4 +1,4 @@
-import { NumericalValues, PlainObject } from "./models.mjs";
+import { NumericalValues, PlainObject } from "./models/index.mjs";
 import { max, min } from "./internal/math/aggregate.mjs";
 import { floor, round } from "./internal/math/misc.mjs";
 //#region src/math.d.ts

package/dist/math.mjs

@@ -1,6 +1,7 @@
 import { isNumber } from "./internal/is.mjs";
 import { floor, round, roundNumber } from "./internal/math/misc.mjs";
-import { AGGREGATION_AVERAGE, aggregate, getAggregateCallback, getAggregated, max, min } from "./internal/math/aggregate.mjs";
+import { AGGREGATION_AVERAGE } from "./models/math.model.mjs";
+import { aggregate, getAggregateCallback, getAggregated, max, min } from "./internal/math/aggregate.mjs";
 //#region src/math.ts
 function average(array, key) {
 	const aggregated = aggregate(AGGREGATION_AVERAGE, array, key);

package/dist/models/aborter.model.d.mts

@@ -0,0 +1,12 @@
+import { GenericCallback } from "./index.mjs";
+//#region src/models/aborter.model.d.ts
+export type Aborter = {
+  callback: GenericCallback;
+  cancel(): void;
+  signal: AbortSignal;
+};
+export declare const ABORTER_EVENT = "abort";
+export declare const ABORTER_OPTIONS: {
+  once: boolean;
+};
+//#endregion

package/dist/models/aborter.model.mjs

@@ -0,0 +1,5 @@
+//#region src/models/aborter.model.ts
+const ABORTER_EVENT = "abort";
+const ABORTER_OPTIONS = { once: true };
+//#endregion
+export { ABORTER_EVENT, ABORTER_OPTIONS };

package/dist/models/array/array.find.model.d.mts

@@ -0,0 +1,22 @@
+//#region src/models/array/array.find.model.d.ts
+export type ArrayFindMapper = {
+  callback: unknown;
+  reverse: boolean;
+};
+export type ArrayFindValueType = "index" | "item";
+export type ArrayFindValuesResult = {
+  matched: unknown[];
+  notMatched: unknown[];
+};
+export type ArrayFindValuesType = "all" | "unique";
+export type ArrayParameters = {
+  bool?: unknown;
+  key?: unknown;
+  value?: unknown;
+};
+export declare const ARRAY_FIND_VALUE_INDEX = "index";
+export declare const ARRAY_FIND_VALUE_ITEM = "item";
+export declare const ARRAY_FIND_VALUES_ALL: ArrayFindValuesType;
+export declare const ARRAY_FIND_VALUES_UNIQUE: ArrayFindValuesType;
+export declare const ARRAY_FIND_UNIQUE_THRESHOLD = 100;
+//#endregion

package/dist/models/array/array.find.model.mjs

@@ -0,0 +1,8 @@
+//#region src/models/array/array.find.model.ts
+const ARRAY_FIND_VALUE_INDEX = "index";
+const ARRAY_FIND_VALUE_ITEM = "item";
+const ARRAY_FIND_VALUES_ALL = "all";
+const ARRAY_FIND_VALUES_UNIQUE = "unique";
+const ARRAY_FIND_UNIQUE_THRESHOLD = 100;
+//#endregion
+export { ARRAY_FIND_UNIQUE_THRESHOLD, ARRAY_FIND_VALUES_ALL, ARRAY_FIND_VALUES_UNIQUE, ARRAY_FIND_VALUE_INDEX, ARRAY_FIND_VALUE_ITEM };

package/dist/models/array/array.match.model.d.mts

@@ -0,0 +1,14 @@
+import { ArrayComparison } from "./array.misc.model.mjs";
+//#region src/models/array/array.match.model.d.ts
+export declare const ARRAY_MATCH_COMPARISON_END: ArrayComparison;
+export declare const ARRAY_MATCH_COMPARISON_INSIDE: ArrayComparison;
+export declare const ARRAY_MATCH_COMPARISON_INVALID: ArrayComparison;
+export declare const ARRAY_MATCH_COMPARISON_OUTSIDE: ArrayComparison;
+export declare const ARRAY_MATCH_COMPARISON_SAME: ArrayComparison;
+export declare const ARRAY_MATCH_COMPARISON_START: ArrayComparison;
+export declare const arrayMatchEndings: Set<ArrayComparison>;
+export declare const arrayMatchInvalid: readonly [-1, ArrayComparison];
+export declare const arrayMatchOutside: readonly [-1, ArrayComparison];
+export declare const arrayMatchOutsides: Set<ArrayComparison>;
+export declare const arrayMatchStarts: Set<ArrayComparison>;
+//#endregion

package/dist/models/array/array.match.model.mjs

@@ -0,0 +1,14 @@
+//#region src/models/array/array.match.model.ts
+const ARRAY_MATCH_COMPARISON_END = "end";
+const ARRAY_MATCH_COMPARISON_INSIDE = "inside";
+const ARRAY_MATCH_COMPARISON_INVALID = "invalid";
+const ARRAY_MATCH_COMPARISON_OUTSIDE = "outside";
+const ARRAY_MATCH_COMPARISON_SAME = "same";
+const ARRAY_MATCH_COMPARISON_START = "start";
+const arrayMatchEndings = /* @__PURE__ */ new Set(["end", ARRAY_MATCH_COMPARISON_SAME]);
+const arrayMatchInvalid = [-1, ARRAY_MATCH_COMPARISON_INVALID];
+const arrayMatchOutside = [-1, ARRAY_MATCH_COMPARISON_OUTSIDE];
+const arrayMatchOutsides = /* @__PURE__ */ new Set([ARRAY_MATCH_COMPARISON_INVALID, ARRAY_MATCH_COMPARISON_OUTSIDE]);
+const arrayMatchStarts = /* @__PURE__ */ new Set([ARRAY_MATCH_COMPARISON_START, ARRAY_MATCH_COMPARISON_SAME]);
+//#endregion
+export { ARRAY_MATCH_COMPARISON_END, ARRAY_MATCH_COMPARISON_INSIDE, ARRAY_MATCH_COMPARISON_INVALID, ARRAY_MATCH_COMPARISON_OUTSIDE, ARRAY_MATCH_COMPARISON_SAME, ARRAY_MATCH_COMPARISON_START, arrayMatchEndings, arrayMatchInvalid, arrayMatchOutside, arrayMatchOutsides, arrayMatchStarts };

package/dist/models/array/array.misc.model.d.mts

@@ -0,0 +1,36 @@
+import { GenericCallback, PlainObject } from "../index.mjs";
+//#region src/models/array/array.misc.model.d.ts
+export type ArrayCompareSetsType = "difference" | "intersection" | "union";
+/**
+ * Comparison of an array within another array
+ */
+export type ArrayComparison = "end" | "inside" | "invalid" | "outside" | "same" | "start";
+export type ArrayExtractType = "drop" | "take";
+export type ArrayGetCallbacks = {
+  bool?: GenericCallback;
+  keyed?: GenericCallback;
+  value?: GenericCallback;
+};
+export type ArrayInsertType = "insert" | "push" | "splice";
+export type ArrayOverlapItem = {
+  array: unknown[];
+  index: number;
+};
+export type ArrayMapKeyOrCallback<Item> = ((item: Item, index: number, array: Item[]) => unknown) | (Item extends PlainObject ? keyof Item : never);
+export type ArrayMapped<Item, Map extends ArrayMapKeyOrCallback<Item>> = Map extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Map> : Map extends keyof Item ? Item[Map] : never;
+export type ArrayObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ? Key : never; }[keyof Item];
+export type ArrayOverlapResult = {
+  first: ArrayOverlapItem;
+  second: ArrayOverlapItem;
+  overlap: boolean;
+};
+export declare const ARRAY_CHUNK_MAX_SIZE = 5e3;
+export declare const ARRAY_INSERT_TYPE_INSERT: ArrayInsertType;
+export declare const ARRAY_INSERT_TYPE_PUSH: ArrayInsertType;
+export declare const ARRAY_INSERT_TYPE_SPLICE: ArrayInsertType;
+export declare const ARRAY_SETS_COMPARE_DIFFERENCE: ArrayCompareSetsType;
+export declare const ARRAY_SETS_COMPARE_INTERSECTION: ArrayCompareSetsType;
+export declare const ARRAY_SETS_COMPARE_UNION: ArrayCompareSetsType;
+export declare const ARRAY_SLICE_DROP: ArrayExtractType;
+export declare const ARRAY_SLICE_TAKE: ArrayExtractType;
+//#endregion

package/dist/models/array/array.misc.model.mjs

@@ -0,0 +1,12 @@
+//#region src/models/array/array.misc.model.ts
+const ARRAY_CHUNK_MAX_SIZE = 5e3;
+const ARRAY_INSERT_TYPE_INSERT = "insert";
+const ARRAY_INSERT_TYPE_PUSH = "push";
+const ARRAY_INSERT_TYPE_SPLICE = "splice";
+const ARRAY_SETS_COMPARE_DIFFERENCE = "difference";
+const ARRAY_SETS_COMPARE_INTERSECTION = "intersection";
+const ARRAY_SETS_COMPARE_UNION = "union";
+const ARRAY_SLICE_DROP = "drop";
+const ARRAY_SLICE_TAKE = "take";
+//#endregion
+export { ARRAY_CHUNK_MAX_SIZE, ARRAY_INSERT_TYPE_INSERT, ARRAY_INSERT_TYPE_PUSH, ARRAY_INSERT_TYPE_SPLICE, ARRAY_SETS_COMPARE_DIFFERENCE, ARRAY_SETS_COMPARE_INTERSECTION, ARRAY_SETS_COMPARE_UNION, ARRAY_SLICE_DROP, ARRAY_SLICE_TAKE };

package/dist/models/array/array.sort.model.d.mts

@@ -0,0 +1,122 @@
+import { PlainObject, Primitive } from "../index.mjs";
+//#region src/models/array/array.sort.model.d.ts
+/**
+ * Sorting information for arrays _(using a comparison callback)_
+ */
+export type ArrayComparisonSorter<Item> = {
+  /**
+   * Callback to use when comparing items and values
+   */
+  comparison: ComparisonSorter<Item>;
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+};
+/**
+ * Sorting information for arrays _(using a key)_
+ */
+export type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
+  /**
+   * Comparator to use when comparing items and values
+   */
+  compare?: CompareCallback<Item, Item[ItemKey]>;
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+  /**
+   * Key to sort by
+   */
+  key: ItemKey;
+};
+/**
+ * Sorters based on keys in an object
+ */
+export type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey>; }[keyof Item];
+/**
+ * Sorter to use for sorting
+ */
+export type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+/**
+ * Sorters to use for sorting
+ */
+export type ArraySorters<Item> = Array<ArraySorter<Item>>;
+/**
+ * Sorting information for arrays _(using a value callback and built-in comparison)_
+ */
+export type ArrayValueSorter<Item> = {
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+  /**
+   * Value to sort by
+   */
+  value(item: Item): unknown;
+};
+/**
+ * Comparator to use when comparing items and values
+ */
+export type CompareCallback<Item, Value = CompareCallbackValue<Item>> = (first: Item, firstValue: Value, second: Item, secondValue: Value) => number;
+export type CompareCallbackValue<Item> = Item extends Primitive ? Item : unknown;
+/**
+ * Callback to use when comparing items and values
+ */
+export type ComparisonSorter<Item> = (first: Item, second: Item) => number;
+export type InternalSorter = {
+  [SORTER_SYMBOL]: SortHandler[];
+};
+/**
+ * Direction to sort by
+ */
+export type SortDirection = "ascending" | "descending";
+export type SortHandler = {
+  comparison?: SortHandlerComparison;
+  get: boolean;
+  identifier: string;
+  modifier: number;
+  value?: Function;
+};
+export type SortHandlerComparison = {
+  complex?: Function;
+  simple?: Function;
+};
+/**
+ * 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
+ */
+export type Sorter<Item> = {
+  /**
+   * Get the index for an item _(to be inserted into an array of items)_
+   *
+   * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+   *
+   * @param array Array to get the index from
+   * @param item Item to get the index for
+   * @returns Index for item
+   */
+  index(array: Item[], item: Item): number;
+  /**
+   * Is the array sorted?
+   *
+   * @param array Array to check
+   * @returns `true` if sorted, otherwise `false`
+   */
+  is(array: Item[]): boolean;
+  /**
+   * Sort an array of items
+   *
+   * @param array Array to sort
+   * @returns Sorted array
+   */
+  sort(array: Item[]): Item[];
+};
+export declare const SORT_PEEK_PERCENTAGE = 10;
+export declare const SORT_THRESHOLD = 100;
+export declare const SORT_DIRECTION_ASCENDING: SortDirection;
+export declare const SORT_DIRECTION_DESCENDING: SortDirection;
+export declare const SORTER_SYMBOL: unique symbol;
+export declare const arrayModifiers: Record<string, number>;
+//#endregion

package/dist/models/array/array.sort.model.mjs

@@ -0,0 +1,12 @@
+//#region src/models/array/array.sort.model.ts
+const SORT_PEEK_PERCENTAGE = 10;
+const SORT_THRESHOLD = 100;
+const SORT_DIRECTION_ASCENDING = "ascending";
+const SORT_DIRECTION_DESCENDING = "descending";
+const SORTER_SYMBOL = Symbol("sorter");
+const arrayModifiers = {
+	[SORT_DIRECTION_ASCENDING]: 1,
+	[SORT_DIRECTION_DESCENDING]: -1
+};
+//#endregion
+export { SORTER_SYMBOL, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SORT_PEEK_PERCENTAGE, SORT_THRESHOLD, arrayModifiers };

package/dist/models/beacon.model.d.mts

@@ -0,0 +1,119 @@
+import { Subscription, SubscriptionProperty, Subscriptions } from "./subscription.model.mjs";
+//#region src/models/beacon.model.d.ts
+/**
+ * A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
+ */
+export type Beacon<Value> = {
+  /**
+   * Is the beacon active?
+   */
+  get active(): boolean;
+  /**
+   * The observable that can be subscribed to
+   */
+  get observable(): Observable<Value>;
+  /**
+   * The current value
+   */
+  get value(): Value;
+  /**
+   * Deactivate the beacon
+   */
+  deactivate(): void;
+  /**
+   * Emit a new value
+   *
+   * @param value Value to set and emit
+   * @param finish Finish the beacon after emitting? _(defaults to `false`)_
+   */
+  emit(value: Value, finish?: boolean): void;
+  /**
+   * Emit an error
+   *
+   * @param value Error to emit
+   * @param finish Finish the beacon after emitting? _(defaults to `false`)_
+   */
+  error(value: Error, finish?: boolean): void;
+  /**
+   * Finish the beacon
+   */
+  finish(): void;
+};
+export type BeaconOptions<Value> = {
+  /**
+   * Method for comparing values for equality
+   *
+   * @param first First value
+   * @param second Second value
+   * @returns `true` if the values are equal, otherwise `false`
+   * @default Object.is
+   */
+  equal?: (first: Value, second: Value) => boolean;
+};
+export type BeaconState<Value> = {
+  active: boolean;
+  observable?: Observable<Value>;
+  options: Required<BeaconOptions<Value>>;
+  subscriptions?: Subscriptions<Observer<unknown>>;
+  value: Value;
+};
+export type InternalBeacon = {
+  [BEACON_SYMBOL]: BeaconState<unknown>;
+} & Beacon<unknown>;
+export type InternalObservable = {
+  [BEACON_SYMBOL]: ObservableState<unknown>;
+} & Observable<unknown>;
+export type Observable<Value> = {
+  /**
+   * Is the observable active?
+   */
+  get active(): boolean;
+  /**
+   * Deactivate the observable
+   */
+  deactivate(): void;
+  /**
+   * Subscribe to value changes
+   *
+   * @param onNext Callback for when the observable receives a new value
+   * @param onError Callback for when the observable receives an error
+   * @param onComplete Callback for when the observable is completed
+   * @returns Subscription to the observable
+   */
+  subscribe(onNext: (value: Value) => void, onError?: (error: Error) => void, onComplete?: () => void): Subscription;
+  /**
+   * Subscribe to value changes
+   *
+   * @param observer Observer for changes
+   * @returns Subscription to the observable
+   */
+  subscribe(observer: Observer<Value>): Subscription;
+};
+export type ObservableState<Value> = {
+  active: boolean;
+  beacon: BeaconState<Value>;
+};
+export type Observer<Value> = {
+  /**
+   * Callback for when the observable is completed
+   */
+  complete?: () => void;
+  /**
+   * Callback for when the observable receives an error
+   */
+  error?: (error: Error) => void;
+  /**
+   * Callback for when the observable receives a new value
+   */
+  next?: (value: Value) => void;
+};
+export declare const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
+export declare const BEACON_MESSAGE_SUBSCRIBE = "Cannot subscribe to a closed observable";
+export declare const BEACON_PROPERTY = "$beacon";
+export declare const BEACON_NAME = "beacon";
+export declare const BEACON_OBSERVABLE = "observable";
+export declare const BEACON_SYMBOL: unique symbol;
+export declare const BEACON_TYPE_ERROR = "error";
+export declare const BEACON_TYPE_NEXT = "next";
+export declare const beaconSubscription: SubscriptionProperty;
+//#endregion

package/dist/models/beacon.model.mjs

@@ -0,0 +1,16 @@
+import { SUBSCRIPTION_NAME } from "./subscription.model.mjs";
+//#region src/models/beacon.model.ts
+const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
+const BEACON_MESSAGE_SUBSCRIBE = "Cannot subscribe to a closed observable";
+const BEACON_PROPERTY = "$beacon";
+const BEACON_NAME = "beacon";
+const BEACON_OBSERVABLE = "observable";
+const BEACON_SYMBOL = Symbol(BEACON_PROPERTY);
+const BEACON_TYPE_ERROR = "error";
+const BEACON_TYPE_NEXT = "next";
+const beaconSubscription = {
+	key: BEACON_PROPERTY,
+	value: SUBSCRIPTION_NAME
+};
+//#endregion
+export { BEACON_MESSAGE_RETRIEVE, BEACON_MESSAGE_SUBSCRIBE, BEACON_NAME, BEACON_OBSERVABLE, BEACON_PROPERTY, BEACON_SYMBOL, BEACON_TYPE_ERROR, BEACON_TYPE_NEXT, beaconSubscription };