@oscarpalmer/atoms 0.216.0 → 0.218.0

package/dist/internal/array/find.mjs

@@ -9,15 +9,47 @@ function createFindParameters(original) {
 		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
 	};
 }
+function findComplexValues(parameters) {
+	const { array, keyCallback, length, mapAfter, mapBefore, result, type, value } = parameters;
+	const keys = /* @__PURE__ */ new Set();
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		let keyed;
+		let transformed;
+		if (mapBefore == null) {
+			keyed = keyCallback?.(item, index, array) ?? item;
+			transformed = item;
+		} else {
+			transformed = mapBefore(item, index, array);
+			keyed = keyCallback?.(transformed, index, array) ?? transformed;
+		}
+		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
+			keys.add(keyed);
+			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
+		} else result.notMatched.push(item);
+	}
+	return result;
+}
+function findSimpleValue(array, value, findIndex, reversed) {
+	if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
+	return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
+}
+function findSimpleValues(array, length, value, boolCallback, mapBefore, mapAfter, result) {
+	const callback = boolCallback ?? ((item) => Object.is(item, value));
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const transformed = mapBefore?.(item, index, array) ?? item;
+		if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
+		else result.notMatched.push(item);
+	}
+	return result;
+}
 function findValue(type, array, parameters, reversed) {
 	const findIndex = type === ARRAY_FIND_VALUE_INDEX;
 	if (!Array.isArray(array) || array.length === 0) return findIndex ? -1 : void 0;
 	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (callbacks?.bool == null && callbacks?.keyed == null) {
-		if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
-		return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
-	}
+	if (callbacks?.bool == null && callbacks?.keyed == null) return findSimpleValue(array, value, findIndex, reversed);
 	if (callbacks.bool != null) {
 		const index = reversed ? array.findLastIndex(callbacks.bool) : array.findIndex(callbacks.bool);
 		return findIndex ? index : array[index];
@@ -38,7 +70,8 @@ function findAbsoluteValueOrDefault(array, parameters, defaultValue, useDefaultV
 		return useDefaultValue ? defaultValue : void 0;
 	}
 	const index = findValue(ARRAY_FIND_VALUE_INDEX, array, parameters, reversed);
-	return index > -1 ? array[index] : useDefaultValue ? defaultValue : void 0;
+	if (index === -1) return useDefaultValue ? defaultValue : void 0;
+	return array[index];
 }
 function findValues(type, array, parameters, mapper) {
 	const result = {
@@ -55,36 +88,26 @@ function findValues(type, array, parameters, mapper) {
 	}
 	const mapCallback = getArrayCallback(mapper?.callback);
 	const mapReverse = mapper?.reverse ?? false;
-	const mapAfter = mapCallback == null ? void 0 : mapReverse ? void 0 : mapCallback;
-	const mapBefore = mapCallback == null ? void 0 : mapReverse ? mapCallback : void 0;
-	if (callbacks?.bool != null || type === "all" && key == null) {
-		const callback = callbacks?.bool ?? ((item) => Object.is(item, value));
-		for (let index = 0; index < length; index += 1) {
-			const item = array[index];
-			const transformed = mapBefore?.(item, index, array) ?? item;
-			if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
-			else result.notMatched.push(item);
-		}
-		return result;
+	let mapAfter;
+	let mapBefore;
+	if (mapCallback == null) {
+		mapAfter = void 0;
+		mapBefore = void 0;
+	} else {
+		mapAfter = mapReverse ? void 0 : mapCallback;
+		mapBefore = mapReverse ? mapCallback : void 0;
 	}
-	const keys = /* @__PURE__ */ new Set();
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		let keyed;
-		let transformed;
-		if (mapBefore == null) {
-			keyed = callbacks?.keyed?.(item, index, array) ?? item;
-			transformed = item;
-		} else {
-			transformed = mapBefore(item, index, array);
-			keyed = callbacks?.keyed?.(transformed, index, array) ?? transformed;
-		}
-		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
-			keys.add(keyed);
-			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
-		} else result.notMatched.push(item);
-	}
-	return result;
+	if (callbacks?.bool != null || type === "all" && key == null) return findSimpleValues(array, length, value, callbacks?.bool, mapBefore, mapAfter, result);
+	return findComplexValues({
+		array,
+		length,
+		mapAfter,
+		mapBefore,
+		result,
+		type,
+		value,
+		keyCallback: callbacks?.keyed
+	});
 }
 //#endregion
 export { createFindParameters, findAbsoluteValueOrDefault, findValue, findValues };

package/dist/internal/array/insert.mjs

@@ -3,7 +3,7 @@ import { chunk } from "./chunk.mjs";
 import { max, min } from "../math/aggregate.mjs";
 //#region src/internal/array/insert.ts
 function insertChunkedValues(type, array, items, start, deleteCount) {
-	const actualDeleteCount = deleteCount < 0 ? 0 : deleteCount;
+	const actualDeleteCount = max([deleteCount, 0]);
 	const actualStart = min([max([0, start]), array.length]);
 	const chunked = chunk(items);
 	const lastIndex = chunked.length - 1;

package/dist/internal/array/match.mjs

@@ -4,6 +4,21 @@ import { ARRAY_MATCH_COMPARISON_INSIDE, ARRAY_MATCH_COMPARISON_SAME, ARRAY_MATCH
 function endsWithArray(haystack, needle, key) {
 	return arrayMatchEndings.has(getPosition(haystack, needle, key)[1]);
 }
+function evaluatePosition(haystack, haystackLength, needle, needleLength, key) {
+	const callback = getArrayCallback(key);
+	const limit = haystackLength - needleLength + 1;
+	let needleValues = callback == null ? needle : needle.slice();
+	if (callback != null) for (let needleIndex = 0; needleIndex < needleLength; needleIndex += 1) needleValues[needleIndex] = callback(needle[needleIndex], needleIndex, needle);
+	for (let haystackIndex = 0; haystackIndex < limit; haystackIndex += 1) {
+		if (!inHaystack(haystack, haystackIndex, needleValues, 0, callback)) continue;
+		if (needleLength === 1) return [haystackIndex, getName(haystackIndex, haystackLength, needleLength)];
+		for (let needleIndex = 1; needleIndex < needleLength; needleIndex += 1) {
+			if (!inHaystack(haystack, haystackIndex, needleValues, needleIndex, callback)) break;
+			if (needleIndex === needleLength - 1) return [haystackIndex, getName(haystackIndex, haystackLength, needleLength)];
+		}
+	}
+	return arrayMatchOutside;
+}
 function getArrayComparison(haystack, needle, key) {
 	return getPosition(haystack, needle, key)[1];
 }
@@ -17,23 +32,12 @@ function getPosition(haystack, needle, key) {
 	const needleLength = needle.length;
 	if (haystackLength === 0 || needleLength === 0) return arrayMatchOutside;
 	if (needleLength > haystackLength) return arrayMatchOutside;
-	const callback = getArrayCallback(key);
-	const limit = haystackLength - needleLength + 1;
-	let needleValues = callback == null ? needle : needle.slice();
-	if (callback != null) for (let needleIndex = 0; needleIndex < needleLength; needleIndex += 1) needleValues[needleIndex] = callback(needle[needleIndex], needleIndex, needle);
-	for (let haystackIndex = 0; haystackIndex < limit; haystackIndex += 1) {
-		let haystackItem = haystack[haystackIndex];
-		let haystackValue = callback?.(haystackItem, haystackIndex, haystack) ?? haystackItem;
-		if (!Object.is(haystackValue, needleValues[0])) continue;
-		if (needleLength === 1) return [haystackIndex, getName(haystackIndex, haystackLength, needleLength)];
-		for (let needleIndex = 1; needleIndex < needleLength; needleIndex += 1) {
-			haystackItem = haystack[haystackIndex + needleIndex];
-			haystackValue = callback?.(haystackItem, haystackIndex + needleIndex, haystack) ?? haystackItem;
-			if (!Object.is(haystackValue, needleValues[needleIndex])) break;
-			if (needleIndex === needleLength - 1) return [haystackIndex, getName(haystackIndex, haystackLength, needleLength)];
-		}
-	}
-	return arrayMatchOutside;
+	return evaluatePosition(haystack, haystackLength, needle, needleLength, key);
+}
+function inHaystack(haystack, haystackIndex, needleValues, needleIndex, callback) {
+	const haystackItem = haystack[haystackIndex + needleIndex];
+	const haystackValue = callback?.(haystackItem, haystackIndex + needleIndex, haystack) ?? haystackItem;
+	return Object.is(haystackValue, needleValues[needleIndex]);
 }
 function includesArray(haystack, needle, key) {
 	return !arrayMatchOutsides.has(getPosition(haystack, needle, key)[1]);

package/dist/internal/array/sets.mjs

@@ -6,8 +6,14 @@ function compareSets(type, first, second, key) {
 	const isDifference = type === ARRAY_SETS_COMPARE_DIFFERENCE;
 	const isIntersection = type === ARRAY_SETS_COMPARE_INTERSECTION;
 	const isUnion = type === ARRAY_SETS_COMPARE_UNION;
-	if (first.length === 0) return isDifference ? first.slice() : isIntersection ? [] : second.slice();
+	if (first.length === 0) {
+		if (isDifference) return first.slice();
+		return isIntersection ? [] : second.slice();
+	}
 	if (!Array.isArray(second) || second.length === 0) return isIntersection ? [] : first.slice();
+	return getComparison(first, second, isIntersection, isUnion, key);
+}
+function getComparison(first, second, isIntersection, isUnion, key) {
 	const callback = getArrayCallback(key);
 	const values = isUnion ? first : second;
 	let { length } = values;

package/dist/internal/math/aggregate.mjs

@@ -44,7 +44,10 @@ function getAggregateCallback(key) {
 }
 function getAggregated(type, array, key, first) {
 	const aggregation = aggregate(type, array, key, first);
-	if (aggregation.count === 0) return aggregation.array ? aggregation.first ? void 0 : [] : NaN;
+	if (aggregation.count === 0) {
+		if (aggregation.array) return aggregation.first ? void 0 : [];
+		return NaN;
+	}
 	if (aggregation.array) {
 		const array = aggregation.items[aggregation.value];
 		return aggregation.first ? array[0] : array;

package/dist/internal/number.d.mts

@@ -4,7 +4,7 @@
  *
  * @param value Value to check
  * @param minimum Minimum value
- * @param maximum Maximum value
+ * @param maximum Maximum value _(inclusive)_
  * @returns `true` if the value is between the minimum and maximum, otherwise `false`
  */
 export declare function between(value: number, minimum: number, maximum: number): boolean;

package/dist/internal/number.mjs

@@ -1,4 +1,5 @@
 import { isNumber } from "./is.mjs";
+import { max, min } from "./math/aggregate.mjs";
 import { EXPRESSION_NUMBER_BINARY, EXPRESSION_NUMBER_OCTAL, EXPRESSION_NUMBER_ZEROISH } from "../models/misc.model.mjs";
 //#region src/internal/number.ts
 /**
@@ -6,7 +7,7 @@ import { EXPRESSION_NUMBER_BINARY, EXPRESSION_NUMBER_OCTAL, EXPRESSION_NUMBER_ZE
 *
 * @param value Value to check
 * @param minimum Minimum value
-* @param maximum Maximum value
+* @param maximum Maximum value _(inclusive)_
 * @returns `true` if the value is between the minimum and maximum, otherwise `false`
 */
 function between(value, minimum, maximum) {
@@ -16,7 +17,8 @@ function between(value, minimum, maximum) {
 		maximum
 	].every(isNumber)) return false;
 	if (Object.is(minimum, maximum)) return Object.is(value, minimum);
-	return value >= (maximum > minimum ? minimum : maximum) && value <= (maximum > minimum ? maximum : minimum);
+	const maximumValue = max([maximum, minimum]);
+	return value >= min([maximum, minimum]) && value <= maximumValue;
 }
 /**
 * Clamp a number between a minimum and maximum value

package/dist/internal/plan/index.d.mts

@@ -0,0 +1,7 @@
+import { GenericPlanItem, InternalAsyncPlan, InternalPlan } from "../../models/plan.model.mjs";
+//#region src/internal/plan/index.d.ts
+export declare function attemptRunPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
+export declare function getGenerator(this: GenericPlanItem): AsyncGenerator | Generator;
+export declare function runAsyncPlan(this: InternalAsyncPlan, first: never, second: never): Promise<unknown>;
+export declare function runPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
+//#endregion

package/dist/internal/plan/index.mjs

@@ -0,0 +1,18 @@
+import { attempt } from "../result/attempt.mjs";
+import { PLAN_SYMBOL } from "../../models/plan.model.mjs";
+import { asyncGenerate, generate } from "./plan.generate.mjs";
+//#region src/internal/plan/index.ts
+function attemptRunPlan(...parameters) {
+	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
+}
+function getGenerator() {
+	return this[PLAN_SYMBOL].generator();
+}
+function runAsyncPlan(first, second) {
+	return asyncGenerate(this[PLAN_SYMBOL], false, first, second);
+}
+function runPlan(...parameters) {
+	return generate(this[PLAN_SYMBOL], parameters, false);
+}
+//#endregion
+export { attemptRunPlan, getGenerator, runAsyncPlan, runPlan };

package/dist/{plan/generate.d.mts → internal/plan/plan.generate.d.mts}

@@ -1,5 +1,5 @@
-import { AsyncPlanState, PlanState } from "../models/plan.model.mjs";
-//#region src/plan/generate.d.ts
+import { AsyncPlanState, PlanState } from "../../models/plan.model.mjs";
+//#region src/internal/plan/plan.generate.d.ts
 export declare function asyncGenerate(input: AsyncPlanState | ((...args: unknown[]) => AsyncGenerator), unwrap: boolean, first?: unknown, second?: unknown): Promise<unknown>;
 export declare function generate(input: PlanState | ((...parameters: unknown[]) => Generator), parameters: unknown[], unwrap: boolean): unknown;
 //#endregion

package/dist/{plan/generate.mjs → internal/plan/plan.generate.mjs}

@@ -1,10 +1,10 @@
-import { noop } from "../internal/function/misc.mjs";
-import { createAborter } from "../internal/aborter.mjs";
-import { isError, isOk } from "../internal/result/misc.mjs";
-//#region src/plan/generate.ts
+import { noop } from "../function/misc.mjs";
+import { createAborter } from "../aborter.mjs";
+import { isError, isOk } from "../result/misc.mjs";
+//#region src/internal/plan/plan.generate.ts
 async function asyncGenerate(input, unwrap, first, second) {
 	const aborter = createAborter(second ?? first, noop);
-	if (aborter != null && aborter.signal.aborted) throw aborter.signal.reason;
+	if (aborter?.signal.aborted) throw aborter.signal.reason;
 	const parameters = Array.isArray(first) ? first : [];
 	let generator;
 	if (typeof input === "function") generator = input(...parameters);
@@ -13,7 +13,7 @@ async function asyncGenerate(input, unwrap, first, second) {
 	let lastValue;
 	try {
 		while (true) {
-			if (aborter != null && aborter.signal.aborted) await generator.throw(aborter.signal.reason);
+			if (aborter?.signal.aborted) await generator.throw(aborter.signal.reason);
 			const next = await generator.next(lastValue);
 			const done = next.done === true;
 			const { value } = next;
@@ -29,7 +29,7 @@ async function asyncGenerate(input, unwrap, first, second) {
 		aborter?.cancel();
 		await generator.return(lastValue);
 	}
-	if (aborter != null && aborter.signal.aborted) throw aborter.signal.reason;
+	if (aborter?.signal.aborted) throw aborter.signal.reason;
 	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }

package/dist/internal/random.d.mts

@@ -1,4 +1,10 @@
 //#region src/internal/random.d.ts
+/**
+ * Get a random number between 0 _(inclusive)_ and 1 _(exclusive)_
+ *
+ * @returns Random number
+ */
+export declare function getRandom(): number;
 /**
  * Get a random floating-point number
  *

package/dist/internal/random.mjs

@@ -1,12 +1,22 @@
 import { isNumber } from "./is.mjs";
 import { floor } from "./math/misc.mjs";
 //#region src/internal/random.ts
+/**
+* Get a random number between 0 _(inclusive)_ and 1 _(exclusive)_
+*
+* @returns Random number
+*/
+function getRandom() {
+	/* istanbul ignore if */
+	if (globalThis.crypto == null) return Math.random();
+	return globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(1))[0] / RANDOM_DIVISOR;
+}
 function getRandomFloatingNumberValue(inclusive, minimum, maximum) {
 	let maxFloat = isNumber(maximum) && maximum <= Number.MAX_SAFE_INTEGER ? maximum : Number.MAX_SAFE_INTEGER;
 	let minFloat = isNumber(minimum) && minimum >= Number.MIN_SAFE_INTEGER ? minimum : Number.MIN_SAFE_INTEGER;
 	if (minFloat === maxFloat) return minFloat;
 	if (minFloat > maxFloat) [minFloat, maxFloat] = [maxFloat, minFloat];
-	return Math.random() * (maxFloat + (inclusive ? 1 : 0) - minFloat) + minFloat;
+	return getRandom() * (maxFloat + (inclusive ? 1 : 0) - minFloat) + minFloat;
 }
 /**
 * Get a random floating-point number
@@ -28,5 +38,6 @@ function getRandomFloatingNumber(minimum, maximum) {
 function getRandomInteger(minimum, maximum) {
 	return floor(getRandomFloatingNumberValue(true, minimum, maximum));
 }
+const RANDOM_DIVISOR = 2 ** 32;
 //#endregion
-export { getRandomFloatingNumber, getRandomInteger };
+export { getRandom, getRandomFloatingNumber, getRandomInteger };

package/dist/internal/result/attempt.mjs

@@ -7,16 +7,16 @@ async function asyncAttempt(value, err) {
 		else result = value;
 		if (result instanceof Promise) result = await result;
 		return ok(result);
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	} catch (error) {
+		return getError(err ?? error, err == null ? void 0 : error);
 	}
 }
 function attempt(callback, err) {
 	try {
 		const value = callback();
 		return ok(value);
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	} catch (error) {
+		return getError(err ?? error, err == null ? void 0 : error);
 	}
 }
 attempt.async = asyncAttempt;

package/dist/internal/string/misc.mjs

@@ -75,7 +75,8 @@ function tryEncode(value) {
 * @returns Array of words found in the string
 */
 function words(value) {
-	return typeof value === "string" ? value.match(STRING_EXPRESSION_WORDS) ?? [] : [];
+	if (typeof value === "string") return value.match(STRING_EXPRESSION_WORDS) ?? [];
+	return [];
 }
 //#endregion
 export { getString, ignoreKey, interpolate, join, tryDecode, tryEncode, words };

package/dist/internal/subscription.mjs

@@ -125,7 +125,7 @@ function createSubscriptionsProperty(input) {
 	const values = isPlainObject(input) ? input : {};
 	return {
 		key: typeof values.key === "string" ? values.key : SUBSCRIPTION_PROPERTY,
-		value: values.value == null ? SUBSCRIPTION_NAME : values.value
+		value: values.value ?? "subscription"
 	};
 }
 function createSubscriptionsState(property, keys) {

package/dist/internal/value/equal.mjs

@@ -1,5 +1,6 @@
 import { isNonPlainObject, isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
 import { round } from "../math/misc.mjs";
+import { min } from "../math/aggregate.mjs";
 import { createCompareHandler } from "./handlers.mjs";
 import { EQUAL_ERROR_PROPERTIES, EQUAL_EXPRESSION_PROPERTIES, EQUAL_SYMBOL } from "../../models/value/value.equal.model.mjs";
 //#region src/internal/value/equal.ts
@@ -63,7 +64,7 @@ function equalArray(first, second, options) {
 	let offset = 0;
 	if (length >= 100) {
 		offset = round(length / 10);
-		offset = offset > 100 ? 100 : offset;
+		offset = min([offset, 100]);
 		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
 	}
 	const end = length - offset;

package/dist/internal/value/partial.mjs

@@ -2,7 +2,9 @@ import { isPlainObject } from "../is.mjs";
 //#region src/internal/value/partial.ts
 function partial(value, providedKeys, omit) {
 	if (!isPlainObject(value)) return {};
-	const keys = omit ? Object.keys(value) : Array.isArray(providedKeys) ? providedKeys : [];
+	let keys;
+	if (omit) keys = Object.keys(value);
+	else keys = Array.isArray(providedKeys) ? providedKeys : [];
 	const { length } = keys;
 	if (length === 0) return omit ? value : {};
 	const partials = {};

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

@@ -307,4 +307,5 @@ export type ColorValue = string | HSLColor | HWBColor | RGBColor;
  * Extended color values
  */
 export type ColorValueExtended = ColorValue | HSLAColor | HWBAColor | RGBAColor;
-//#endregion
+//#endregion
+export {};

package/dist/models/function/once.model.d.mts

@@ -73,4 +73,5 @@ export declare const ONCE_PROPERTY = "$once";
 export declare const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 export declare const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
 export declare const ONCE_SYMBOL: unique symbol;
-//#endregion
+//#endregion
+export {};

package/dist/models/index.d.mts

@@ -124,4 +124,5 @@ export type UnionToIntersection<Union> = (Union extends unknown ? (distributedUn
  * A function that unsubscribes from a subscription
  */
 export type Unsubscriber = () => void;
-//#endregion
+//#endregion
+export {};