@oscarpalmer/atoms 0.193.1 → 0.195.0

package/dist/internal/value/equal.mjs

@@ -60,7 +60,7 @@ function equalPlainObject(first, second, options) {
 		firstKeys = firstKeys.filter((key) => filterKey(key, options));
 		secondKeys = secondKeys.filter((key) => filterKey(key, options));
 	}
-	const secondSet = secondKeys.length >= MINIMUM_LENGTH_FOR_SET ? new Set(secondKeys) : void 0;
+	const secondSet = secondKeys.length >= EQUAL_MINIMUM_LENGTH_FOR_SET ? new Set(secondKeys) : void 0;
 	const { length } = firstKeys;
 	if (length !== secondKeys.length) return false;
 	for (let index = 0; index < length; index += 1) {
@@ -105,9 +105,9 @@ function equalValue(first, second, options) {
 		case first instanceof ArrayBuffer && second instanceof ArrayBuffer: return equalArrayBuffer(first, second, options);
 		case first instanceof Date && second instanceof Date: return Object.is(first.getTime(), second.getTime());
 		case first instanceof DataView && second instanceof DataView: return equalDataView(first, second, options);
-		case first instanceof Error && second instanceof Error: return equalProperties(first, second, ERROR_PROPERTIES, options);
+		case first instanceof Error && second instanceof Error: return equalProperties(first, second, EQUAL_ERROR_PROPERTIES, options);
 		case first instanceof Map && second instanceof Map: return equalMap(first, second, options);
-		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, EXPRESSION_PROPERTIES, options);
+		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, EQUAL_EXPRESSION_PROPERTIES, options);
 		case first instanceof Set && second instanceof Set: return equalSet(first, second, options);
 		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
 		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
@@ -169,8 +169,8 @@ function registerEqualizer(constructor, handler) {
 }
 const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
 const EQUAL_ARRAY_THRESHOLD = 100;
-const ERROR_PROPERTIES = ["name", "message"];
-const EXPRESSION_PROPERTIES = ["source", "flags"];
-const MINIMUM_LENGTH_FOR_SET = 16;
+const EQUAL_ERROR_PROPERTIES = ["name", "message"];
+const EQUAL_EXPRESSION_PROPERTIES = ["source", "flags"];
+const EQUAL_MINIMUM_LENGTH_FOR_SET = 16;
 //#endregion
 export { deregisterEqualizer, equal, initializeEqualizer, registerEqualizer };

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

@@ -1,5 +1,5 @@
 import { NestedKeys, NestedValue, PlainObject, ToString } from "../../models.mjs";
-import { Result } from "../../result/models.mjs";
+import { Result } from "../result/models.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 "../../result/models.mjs";
+import { Result } from "../result/models.mjs";
 //#region src/internal/value/misc.d.ts
 declare function findKey(needle: string, haystack: object): string;
 declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, string>;

package/dist/internal/value/misc.mjs

@@ -1,5 +1,5 @@
-import { ignoreKey } from "../string.mjs";
-import { error, ok } from "../../result/misc.mjs";
+import { ignoreKey } from "../string/misc.mjs";
+import { error, ok } from "../result/misc.mjs";
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
 	const keys = Object.keys(haystack);
@@ -7,8 +7,8 @@ function findKey(needle, haystack) {
 	return index > -1 ? keys[index] : needle;
 }
 function getNestedValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null) return error(NESTED_MESSAGE_INPUT);
-	if (typeof path !== "string" || path.trim().length === 0) return error(NESTED_MESSAGE_PATH);
+	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);
 	const shouldIgnoreCase = ignoreCase === true;
 	const paths = getPaths(path, shouldIgnoreCase);
 	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
@@ -24,24 +24,24 @@ function getNestedValue(data, path, ignoreCase) {
 }
 function getPaths(path, lowercase) {
 	const normalized = lowercase ? path.toLowerCase() : path;
-	if (!EXPRESSION_NESTED.test(normalized)) return normalized;
-	return normalized.replace(EXPRESSION_BRACKET, ".$1").replace(EXPRESSION_DOTS, "").split(".");
+	if (!MISC_EXPRESSION_NESTED.test(normalized)) return normalized;
+	return normalized.replace(MISC_EXPRESSION_BRACKET, ".$1").replace(MISC_EXPRESSION_DOTS, "").split(".");
 }
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null) {
-		if (ignoreKey(path)) return error(NESTED_MESSAGE_UNSAFE);
+		if (ignoreKey(path)) return error(MISC_NESTED_MESSAGE_UNSAFE);
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return key in data ? ok(data[key]) : error(NESTED_MESSAGE_MISSING);
+		if (get) return key in data ? ok(data[key]) : error(MISC_NESTED_MESSAGE_MISSING);
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
-	if (get) return error(NESTED_MESSAGE_MISSING);
+	if (get) return error(MISC_NESTED_MESSAGE_MISSING);
 }
-const EXPRESSION_BRACKET = /\[(\w+)\]/g;
-const EXPRESSION_DOTS = /^\.|\.$/g;
-const EXPRESSION_NESTED = /\.|\[\w+\]/;
-const NESTED_MESSAGE_INPUT = "Expected data to be an object";
-const NESTED_MESSAGE_MISSING = "Expected property to exist in object";
-const NESTED_MESSAGE_PATH = "Expected path to be a string";
-const NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
+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.mjs

@@ -20,7 +20,7 @@ function setValue(data, path, value, ignoreCase) {
 		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
-			if (EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
+			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
 			else next = {};
 			target[currentPath] = next;
 		}
@@ -28,6 +28,6 @@ function setValue(data, path, value, ignoreCase) {
 	}
 	return data;
 }
-const EXPRESSION_INDEX = /^\d+$/;
+const SET_EXPRESSION_INDEX = /^\d+$/;
 //#endregion
 export { setValue };

package/dist/is.mjs

@@ -1,6 +1,6 @@
 import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonInstanceOf, isNonKey, isNonNumber, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNumber, isPlainObject, isPrimitive, isTypedArray } from "./internal/is.mjs";
-import { getArray } from "./array/get.mjs";
-import { getString } from "./internal/string.mjs";
+import { getArray } from "./internal/array/get.mjs";
+import { getString } from "./internal/string/misc.mjs";
 //#region src/is.ts
 /**
 * Is the value empty, or only containing `null` or `undefined` values?

package/dist/logger.mjs

@@ -1,13 +1,14 @@
 import { noop } from "./internal/function/misc.mjs";
+import { getString } from "./internal/string/misc.mjs";
 //#region src/logger.ts
 function isLogger(value) {
-	return isLoggerInstance(NAME_LOGGER, value);
+	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
-	return typeof value === "object" && value !== null && value[KEY_LOGGER] === name;
+	return typeof value === "object" && value !== null && value[LOGGER_PROPERTY] === name;
 }
 function isTimedLogger(value) {
-	return isLoggerInstance(NAME_TIMED, value);
+	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
 function timedLogger(label) {
 	function stop() {
@@ -26,35 +27,20 @@ function timedLogger(label) {
 	};
 	const instance = {};
 	Object.defineProperties(instance, {
-		[KEY_LOGGER]: {
-			enumerable: false,
-			value: NAME_TIMED
-		},
+		[LOGGER_PROPERTY]: { value: LOGGER_NAME_TIMED },
 		active: {
 			enumerable: true,
-			get() {
-				return state.started && !state.stopped && enabled;
-			}
-		},
-		log: {
-			enumerable: true,
-			get() {
-				return this.active ? logger : noop;
-			}
+			get: () => state.started && !state.stopped && enabled
 		},
-		stop: {
-			enumerable: true,
-			get() {
-				return instance.active ? stop() : noop;
-			}
-		}
+		log: { get: () => instance.active ? logger : noop },
+		stop: { get: () => instance.active ? stop() : noop }
 	});
 	if (state.started) console.time(label);
 	return Object.freeze(instance);
 }
-const KEY_LOGGER = "$logger";
-const NAME_LOGGER = "Logger";
-const NAME_TIMED = "TimedLogger";
+const LOGGER_NAME = "Logger";
+const LOGGER_NAME_TIMED = "TimedLogger";
+const LOGGER_PROPERTY = "$logger";
 const methods = [
 	"debug",
 	"dir",
@@ -73,25 +59,15 @@ const methods = [
 const Logger = (() => {
 	const instance = {};
 	Object.defineProperties(instance, {
-		[KEY_LOGGER]: {
-			enumerable: false,
-			value: NAME_LOGGER
-		},
+		[LOGGER_PROPERTY]: { value: LOGGER_NAME },
 		enabled: {
 			enumerable: true,
-			get() {
-				return enabled;
-			},
-			set(value) {
+			get: () => enabled,
+			set: (value) => {
 				enabled = typeof value === "boolean" ? value : enabled;
 			}
 		},
-		time: {
-			enumerable: true,
-			value(label) {
-				return timedLogger(label);
-			}
-		}
+		time: { value: (label) => timedLogger(getString(label)) }
 	});
 	for (const method of methods) Object.defineProperty(instance, method, {
 		enumerable: true,

package/dist/promise/constants.d.mts

@@ -0,0 +1,17 @@
+import { PromiseStrategy } from "./models.mjs";
+//#region src/promise/constants.d.ts
+declare const PROMISE_ABORT_EVENT = "abort";
+declare const PROMISE_ABORT_OPTIONS: {
+  once: boolean;
+};
+declare const PROMISE_ERROR_NAME = "PromiseTimeoutError";
+declare const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
+declare const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
+declare const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
+declare const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
+declare const PROMISE_STRATEGY_ALL: Set<PromiseStrategy>;
+declare const PROMISE_STRATEGY_DEFAULT: PromiseStrategy;
+declare const PROMISE_TYPE_FULFILLED = "fulfilled";
+declare const PROMISE_TYPE_REJECTED = "rejected";
+//#endregion
+export { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED };

package/dist/promise/constants.mjs

@@ -0,0 +1,14 @@
+//#region src/promise/constants.ts
+const PROMISE_ABORT_EVENT = "abort";
+const PROMISE_ABORT_OPTIONS = { once: true };
+const PROMISE_ERROR_NAME = "PromiseTimeoutError";
+const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
+const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
+const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
+const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
+const PROMISE_STRATEGY_ALL = /* @__PURE__ */ new Set(["complete", "first"]);
+const PROMISE_STRATEGY_DEFAULT = "complete";
+const PROMISE_TYPE_FULFILLED = "fulfilled";
+const PROMISE_TYPE_REJECTED = "rejected";
+//#endregion
+export { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED };

package/dist/promise/delay.mjs

@@ -1,25 +1,22 @@
+import { createAborter } from "../internal/abort.mjs";
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
-import { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS } from "./models.mjs";
 import { getPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/delay.ts
 function delay(options) {
 	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	function abort() {
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	const aborter = createAborter(signal, () => {
 		timer.cancel();
-		rejector(signal.reason);
-	}
-	const timer = getTimer(TIMER_WAIT, () => {
-		settlePromise(abort, resolver, void 0, signal);
-	}, time);
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
+		rejector(signal?.reason);
+	});
+	const timer = getTimer(TIMER_WAIT, () => settlePromise(resolver, void 0, aborter), time);
 	let rejector;
 	let resolver;
 	return new Promise((resolve, reject) => {
 		rejector = reject;
 		resolver = resolve;
-		if (time === 0) settlePromise(abort, resolve, void 0, signal);
+		if (time === 0) settlePromise(resolver, void 0, aborter);
 		else timer();
 	});
 }

package/dist/promise/helpers.d.mts

@@ -1,5 +1,5 @@
 import { RequiredKeys } from "../models.mjs";
-import { Result } from "../result/models.mjs";
+import { Result } from "../internal/result/models.mjs";
 import { FulfilledPromise, PromiseOptions, PromiseStrategy, PromisesOptions, PromisesValue, RejectedPromise } from "./models.mjs";
 //#region src/promise/helpers.d.ts
 declare function getPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, 'time'>;

package/dist/promise/helpers.mjs

@@ -1,6 +1,6 @@
-import { error, ok } from "../result/misc.mjs";
-import { getNumberOrDefault } from "../internal/number.mjs";
-import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./models.mjs";
+import { error, ok } from "../internal/result/misc.mjs";
+import { getNumberOrDefault } from "../internal/defaults.mjs";
+import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
 //#region src/promise/helpers.ts
 function getPromiseOptions(input) {
 	if (typeof input === "number") return { time: getNumberOrDefault(input, 0) };

package/dist/promise/index.d.mts

@@ -1,4 +1,4 @@
-import { Result } from "../result/models.mjs";
+import { Result } from "../internal/result/models.mjs";
 import { PromiseOptions, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues } from "./models.mjs";
 //#region src/promise/index.d.ts
 /**

package/dist/promise/index.mjs

@@ -1,4 +1,5 @@
-import { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./models.mjs";
+import { createAborter } from "../internal/abort.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
 import { getPromiseOptions, getPromisesOptions, getResultsFromPromises } from "./helpers.mjs";
 import { handleResult, settlePromise } from "./misc.mjs";
 import { getTimedPromise } from "./timed.mjs";
@@ -7,21 +8,20 @@ async function attemptPromise(value, options) {
 	const isFunction = typeof value === "function";
 	if (!isFunction && !(value instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_ATTEMPT));
 	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	function abort() {
-		rejector(signal.reason);
-	}
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	const aborter = createAborter(signal, () => {
+		rejector(signal?.reason);
+	});
 	async function handler(resolve, reject) {
 		try {
 			let result = isFunction ? value() : await value;
 			if (result instanceof Promise) result = await result;
-			settlePromise(abort, resolve, result, signal);
+			settlePromise(resolve, result, aborter);
 		} catch (error) {
-			settlePromise(abort, reject, error, signal);
+			settlePromise(reject, error, aborter);
 		}
 	}
 	let rejector;
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
 	const promise = new Promise((resolve, reject) => {
 		rejector = reject;
 		handler(resolve, reject);
@@ -30,16 +30,15 @@ async function attemptPromise(value, options) {
 }
 async function promises(items, options) {
 	const { signal, strategy } = getPromisesOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	if (!Array.isArray(items)) return Promise.resolve([]);
 	const actual = items.map((item) => typeof item === "function" ? item() : item).filter((item) => item instanceof Promise);
 	const { length } = actual;
 	if (length === 0) return Promise.resolve([]);
 	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
-	function abort() {
-		handlers.reject(signal.reason);
-	}
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
+	const aborter = createAborter(signal, () => {
+		handlers.reject(signal?.reason);
+	});
 	const data = {
 		last: length - 1,
 		result: []
@@ -51,20 +50,18 @@ async function promises(items, options) {
 			resolve
 		};
 		for (let index = 0; index < length; index += 1) actual[index].then((value) => handleResult(PROMISE_TYPE_FULFILLED, {
-			abort,
+			aborter,
 			complete,
 			data,
 			handlers,
 			index,
-			signal,
 			value
 		})).catch((reason) => handleResult(PROMISE_TYPE_REJECTED, {
-			abort,
+			aborter,
 			complete,
 			data,
 			handlers,
 			index,
-			signal,
 			value: reason
 		}));
 	});

package/dist/promise/misc.d.mts

@@ -1,4 +1,5 @@
-import { Result } from "../result/models.mjs";
+import { Result } from "../internal/result/models.mjs";
+import { Aborter } from "../internal/abort.mjs";
 import { CancelablePromise, PromiseParameters } from "./models.mjs";
 import { toPromise } from "../result/misc.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";
@@ -11,7 +12,7 @@ import { isFulfilled, isRejected } from "./helpers.mjs";
  */
 declare function cancelable<Value>(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void): CancelablePromise<Value>;
 declare function handleResult(status: string, parameters: PromiseParameters): void;
-declare function settlePromise(aborter: () => void, settler: (value: any) => void, value: unknown, signal?: AbortSignal): void;
+declare function settlePromise(settler: (value: any) => void, value: unknown, aborter?: Aborter): void;
 /**
  * Converts a _Promise_ to a promised result
  *

package/dist/promise/misc.mjs

@@ -1,6 +1,8 @@
-import { error, ok, toPromise } from "../result/misc.mjs";
-import { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_MESSAGE_EXPECTATION_RESULT } from "./models.mjs";
+import { error, ok } from "../internal/result/misc.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_RESULT } from "./constants.mjs";
+import { CancelablePromise } from "./models.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";
+import { toPromise } from "../result/misc.mjs";
 //#region src/promise/misc.ts
 /**
 * Create a cancelable _Promise_
@@ -12,10 +14,10 @@ function cancelable(executor) {
 	return new CancelablePromise(executor);
 }
 function handleResult(status, parameters) {
-	const { abort, complete, data, handlers, index, signal, value } = parameters;
-	if (signal?.aborted ?? false) return;
+	const { aborter, complete, data, handlers, index, value } = parameters;
+	if (aborter?.signal.aborted ?? false) return;
 	if (!complete && status === "rejected") {
-		settlePromise(abort, handlers.reject, value, signal);
+		settlePromise(handlers.reject, value, aborter);
 		return;
 	}
 	data.result[index] = !complete ? value : status === "fulfilled" ? {
@@ -25,10 +27,10 @@ function handleResult(status, parameters) {
 		status,
 		reason: value
 	};
-	if (index === data.last) settlePromise(abort, handlers.resolve, data.result, signal);
+	if (index === data.last) settlePromise(handlers.resolve, data.result, aborter);
 }
-function settlePromise(aborter, settler, value, signal) {
-	signal?.removeEventListener(PROMISE_ABORT_EVENT, aborter);
+function settlePromise(settler, value, aborter) {
+	aborter?.cancel();
 	settler(value);
 }
 async function toResult(value) {

package/dist/promise/models.d.mts

@@ -1,5 +1,7 @@
 import { GenericCallback } from "../models.mjs";
-import { Result } from "../result/models.mjs";
+import { Result } from "../internal/result/models.mjs";
+import { Aborter } from "../internal/abort.mjs";
+import { PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
 //#region src/promise/models.d.ts
 /**
  * A _Promise_ that can be canceled
@@ -49,12 +51,11 @@ type PromiseOptions = {
   time?: number;
 };
 type PromiseParameters = {
-  abort: () => void;
+  aborter?: Aborter;
   complete: boolean;
   data: PromiseData;
   handlers: PromiseHandlers;
   index: number;
-  signal?: AbortSignal;
   value?: unknown;
 };
 /**
@@ -101,18 +102,5 @@ type RejectedPromise = {
    */
   reason: unknown;
 };
-declare const PROMISE_ABORT_EVENT = "abort";
-declare const PROMISE_ABORT_OPTIONS: {
-  once: boolean;
-};
-declare const PROMISE_ERROR_NAME = "PromiseTimeoutError";
-declare const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
-declare const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
-declare const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
-declare const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
-declare const PROMISE_STRATEGY_ALL: Set<PromiseStrategy>;
-declare const PROMISE_STRATEGY_DEFAULT: PromiseStrategy;
-declare const PROMISE_TYPE_FULFILLED = "fulfilled";
-declare const PROMISE_TYPE_REJECTED = "rejected";
 //#endregion
-export { CancelablePromise, FulfilledPromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, RejectedPromise };
+export { CancelablePromise, FulfilledPromise, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, RejectedPromise };

package/dist/promise/models.mjs

@@ -1,3 +1,4 @@
+import { PROMISE_ERROR_NAME, PROMISE_MESSAGE_TIMEOUT } from "./constants.mjs";
 //#region src/promise/models.ts
 /**
 * A _Promise_ that can be canceled
@@ -18,7 +19,8 @@ var CancelablePromise = class extends Promise {
 	* @param reason Optional reason for canceling the _Promise_
 	*/
 	cancel(reason) {
-		this.#rejector(reason);
+		this.#rejector?.(reason);
+		this.#rejector = void 0;
 	}
 };
 /**
@@ -30,16 +32,5 @@ var PromiseTimeoutError = class extends Error {
 		this.name = PROMISE_ERROR_NAME;
 	}
 };
-const PROMISE_ABORT_EVENT = "abort";
-const PROMISE_ABORT_OPTIONS = { once: true };
-const PROMISE_ERROR_NAME = "PromiseTimeoutError";
-const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
-const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
-const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
-const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
-const PROMISE_STRATEGY_ALL = /* @__PURE__ */ new Set(["complete", "first"]);
-const PROMISE_STRATEGY_DEFAULT = "complete";
-const PROMISE_TYPE_FULFILLED = "fulfilled";
-const PROMISE_TYPE_REJECTED = "rejected";
 //#endregion
-export { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError };
+export { CancelablePromise, PromiseTimeoutError };

package/dist/promise/timed.mjs

@@ -1,32 +1,31 @@
+import { createAborter } from "../internal/abort.mjs";
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
-import { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_MESSAGE_EXPECTATION_TIMED, PromiseTimeoutError } from "./models.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_TIMED } from "./constants.mjs";
+import { PromiseTimeoutError } from "./models.mjs";
 import { getPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/timed.ts
 async function getTimedPromise(promise, time, signal) {
-	function abort() {
+	const aborter = createAborter(signal, () => {
 		timer.cancel();
-		rejector(signal.reason);
-	}
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
-	const timer = getTimer(TIMER_WAIT, () => {
-		settlePromise(abort, rejector, new PromiseTimeoutError(), signal);
-	}, time);
+		rejector(signal?.reason);
+	});
+	const timer = getTimer(TIMER_WAIT, () => settlePromise(rejector, new PromiseTimeoutError(), aborter), time);
 	let rejector;
 	return Promise.race([promise, new Promise((_, reject) => {
 		rejector = reject;
 		timer();
 	})]).then((value) => {
+		aborter?.cancel();
 		timer.cancel();
 		rejector(void 0);
-		signal?.removeEventListener(PROMISE_ABORT_EVENT, abort);
 		return value;
 	});
 }
 async function timed(promise, options) {
 	if (!(promise instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED));
 	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
 }
 //#endregion