@oscarpalmer/atoms 0.193.0 → 0.194.0

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.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 { 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.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 { 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,5 +1,6 @@
 import { error, ok, toPromise } from "../result/misc.mjs";
-import { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_MESSAGE_EXPECTATION_RESULT } from "./models.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_RESULT } from "./constants.mjs";
+import { CancelablePromise } from "./models.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";
 //#region src/promise/misc.ts
 /**
@@ -12,10 +13,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 +26,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 { 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

package/dist/query.mjs

@@ -11,15 +11,15 @@ import { setValue } from "./internal/value/set.mjs";
 */
 function fromQuery(query) {
 	if (typeof query !== "string" || query.trim().length === 0) return {};
-	const parts = query.split(AMPERSAND).map((part) => part.split(EQUAL).map(tryDecode)).sort(([first], [second]) => first.localeCompare(second));
+	const parts = query.split(QUERY_AMPERSAND).map((part) => part.split(QUERY_EQUAL).map(tryDecode)).sort(([first], [second]) => first.localeCompare(second));
 	const { length } = parts;
 	const parameters = {};
 	let position = 0;
 	let array;
 	for (let index = 0; index < length; index += 1) {
 		const [key, value] = parts[index];
-		if (EXPRESSION_ARRAY_SUFFIX.test(key)) {
-			const named = key.replace(EXPRESSION_ARRAY_SUFFIX, "");
+		if (QUERY_EXPRESSION_ARRAY_SUFFIX.test(key)) {
+			const named = key.replace(QUERY_EXPRESSION_ARRAY_SUFFIX, "");
 			if (named !== array) {
 				array = named;
 				position = 0;
@@ -41,9 +41,9 @@ function getParts(value, fromArray, prefix) {
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		const val = value[key];
-		const fullKey = join([prefix, fromArray ? void 0 : key], DOT);
+		const fullKey = join([prefix, fromArray ? void 0 : key], QUERY_DOT);
 		const encodedKey = getString(tryEncode(fullKey));
-		const prefixedKey = fromArray ? join([encodedKey, index], DOT) : encodedKey;
+		const prefixedKey = fromArray ? join([encodedKey, index], QUERY_DOT) : encodedKey;
 		if (Array.isArray(val)) parts.push(...getParts(val, true, fullKey));
 		else if (isPlainObject(val)) parts.push(...getParts(val, false, fullKey));
 		else if (isDecodable(val)) parts.push(`${prefixedKey}=${getString(tryEncode(val))}`);
@@ -52,7 +52,7 @@ function getParts(value, fromArray, prefix) {
 	return parts;
 }
 function getQueryValue(value) {
-	if (EXPRESSION_BOOLEAN.test(value)) return value === TRUE;
+	if (QUERY_EXPRESSION_BOOLEAN.test(value)) return value === QUERY_TRUE;
 	const asNumber = getNumber(value);
 	if (!Number.isNaN(asNumber)) return asNumber;
 	const parsed = Date.parse(value);
@@ -61,7 +61,7 @@ function getQueryValue(value) {
 	return date.toJSON() === value ? date : value;
 }
 function isDecodable(value) {
-	return TYPES.has(typeof value);
+	return QUERY_TYPES.has(typeof value);
 }
 /**
 * Convert a plain _(nested)_ object to a query string
@@ -70,15 +70,15 @@ function isDecodable(value) {
 * @returns Query string representation of the object
 */
 function toQuery(parameters) {
-	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), AMPERSAND) : "";
+	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), QUERY_AMPERSAND) : "";
 }
-const AMPERSAND = "&";
-const DOT = ".";
-const EQUAL = "=";
-const EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
-const EXPRESSION_BOOLEAN = /^(false|true)$/;
-const TRUE = "true";
-const TYPES = /* @__PURE__ */ new Set([
+const QUERY_AMPERSAND = "&";
+const QUERY_DOT = ".";
+const QUERY_EQUAL = "=";
+const QUERY_EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
+const QUERY_EXPRESSION_BOOLEAN = /^(false|true)$/;
+const QUERY_TRUE = "true";
+const QUERY_TYPES = /* @__PURE__ */ new Set([
 	"boolean",
 	"number",
 	"string"