@oscarpalmer/atoms 0.197.0 → 0.199.0

package/dist/internal/value/handlers.mjs

@@ -1,7 +1,7 @@
 import { isNonConstructor } from "../is.mjs";
 //#region src/internal/value/handlers.ts
-function getCompareHandlers(owner, options) {
-	const handlers = getHandlers(owner, options);
+function createCompareHandlers(owner, options) {
+	const handlers = createHandlers(owner, options);
 	return {
 		deregister(constructor) {
 			handlers.deregister(constructor);
@@ -16,7 +16,7 @@ function getCompareHandlers(owner, options) {
 		}
 	};
 }
-function getHandlers(owner, options) {
+function createHandlers(owner, options) {
 	const handlers = /* @__PURE__ */ new WeakMap();
 	return {
 		deregister(constructor) {
@@ -34,8 +34,8 @@ function getHandlers(owner, options) {
 		}
 	};
 }
-function getSelfHandlers(owner, options) {
-	const handlers = getHandlers(owner, options);
+function createSelfHandlers(owner, options) {
+	const handlers = createHandlers(owner, options);
 	return {
 		deregister(constructor) {
 			handlers.deregister(constructor);
@@ -54,4 +54,4 @@ function isConstructable(value) {
 	return typeof value === "object" && value !== null;
 }
 //#endregion
-export { getCompareHandlers, getSelfHandlers };
+export { createCompareHandlers, createSelfHandlers };

package/dist/promise/delay.mjs

@@ -1,10 +1,10 @@
 import { createAborter } from "../internal/abort.mjs";
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
-import { getPromiseOptions } from "./helpers.mjs";
+import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/delay.ts
 function delay(options) {
-	const { signal, time } = getPromiseOptions(options);
+	const { signal, time } = createPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	const aborter = createAborter(signal, () => {
 		timer.cancel();

package/dist/promise/helpers.d.mts

@@ -2,8 +2,8 @@ import { RequiredKeys } from "../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'>;
-declare function getPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, 'strategy'>;
+declare function createPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, 'time'>;
+declare function createPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, 'strategy'>;
 declare function getResultsFromPromises<Value>(promised: PromisesValue<Value>[]): Result<Value>[];
 declare function getStrategyOrDefault(value: unknown): PromiseStrategy;
 /**
@@ -21,4 +21,4 @@ declare function isFulfilled<Value>(value: unknown): value is FulfilledPromise<V
  */
 declare function isRejected(value: unknown): value is RejectedPromise;
 //#endregion
-export { getPromiseOptions, getPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };
+export { createPromiseOptions, createPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };

package/dist/promise/helpers.mjs

@@ -1,8 +1,8 @@
-import { error, ok } from "../internal/result/misc.mjs";
 import { getNumberOrDefault } from "../internal/defaults.mjs";
+import { error, ok } from "../internal/result/misc.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) {
+function createPromiseOptions(input) {
 	if (typeof input === "number") return { time: getNumberOrDefault(input, 0) };
 	if (input instanceof AbortSignal) return {
 		signal: input,
@@ -14,7 +14,7 @@ function getPromiseOptions(input) {
 		time: getNumberOrDefault(options.time, 0)
 	};
 }
-function getPromisesOptions(input) {
+function createPromisesOptions(input) {
 	if (typeof input === "string") return { strategy: getStrategyOrDefault(input) };
 	if (input instanceof AbortSignal) return {
 		signal: input,
@@ -54,4 +54,4 @@ function isType(value, type) {
 	return typeof value === "object" && value !== null && value.status === type;
 }
 //#endregion
-export { getPromiseOptions, getPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };
+export { createPromiseOptions, createPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };

package/dist/promise/index.mjs

@@ -1,13 +1,13 @@
 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 { createPromiseOptions, createPromisesOptions, getResultsFromPromises } from "./helpers.mjs";
 import { handleResult, settlePromise } from "./misc.mjs";
 import { getTimedPromise } from "./timed.mjs";
 //#region src/promise/index.ts
 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);
+	const { signal, time } = createPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	const aborter = createAborter(signal, () => {
 		rejector(signal?.reason);
@@ -29,7 +29,7 @@ async function attemptPromise(value, options) {
 	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
 }
 async function promises(items, options) {
-	const { signal, strategy } = getPromisesOptions(options);
+	const { signal, strategy } = createPromisesOptions(options);
 	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);

package/dist/promise/timed.mjs

@@ -2,7 +2,7 @@ import { createAborter } from "../internal/abort.mjs";
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
 import { PROMISE_MESSAGE_EXPECTATION_TIMED } from "./constants.mjs";
 import { PromiseTimeoutError } from "./models.mjs";
-import { getPromiseOptions } from "./helpers.mjs";
+import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/timed.ts
 async function getTimedPromise(promise, time, signal) {
@@ -24,7 +24,7 @@ async function getTimedPromise(promise, time, signal) {
 }
 async function timed(promise, options) {
 	if (!(promise instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED));
-	const { signal, time } = getPromiseOptions(options);
+	const { signal, time } = createPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
 }

package/dist/queue.mjs

@@ -54,7 +54,7 @@ function createQueue(callback, options, key) {
 		handled: [],
 		id: 0,
 		items: [],
-		options: getOptions(options),
+		options: createQueueOptions(options),
 		paused: !getBooleanOrDefault(options?.autostart, true),
 		runners: 0
 	};
@@ -104,7 +104,7 @@ function createQueue(callback, options, key) {
 	});
 	return Object.freeze(instance);
 }
-function getOptions(input) {
+function createQueueOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
 	return {
 		autostart: getBooleanOrDefault(options.autostart, true),
@@ -182,7 +182,7 @@ function keyedQueue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
 	const state = {
 		callback,
-		options: getOptions(options),
+		options: createQueueOptions(options),
 		queues: /* @__PURE__ */ new Map()
 	};
 	const instance = {

package/dist/string/fuzzy.mjs

@@ -3,20 +3,7 @@ import { getString } from "../internal/string/misc.mjs";
 import { lowerCase } from "../internal/string/case.mjs";
 import { includes } from "./match.mjs";
 //#region src/string/fuzzy.ts
-function getHandler(input) {
-	if (input == null || input === getString) return getString;
-	switch (typeof input) {
-		case "function": return input;
-		case "string": return (item) => item[input];
-		default:
-			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
-			throw new TypeError(FUZZY_MESSAGE_HANDLER);
-	}
-}
-function getFuzzyItems(items) {
-	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
-}
-function getFuzzyOptions(input, state) {
+function createFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
 	const limit = typeof input === "number" ? input : options.limit;
 	if (typeof limit === "number" && !Number.isNaN(limit) && limit >= 1) options.limit = Math.floor(limit);
@@ -24,9 +11,9 @@ function getFuzzyOptions(input, state) {
 	options.tolerance = getTolerance(options.tolerance, state);
 	return options;
 }
-function getFuzzyState(items, input) {
+function createFuzzyState(items, input) {
 	const handler = getHandler(input);
-	const options = getFuzzyOptions(input);
+	const options = createFuzzyOptions(input);
 	return {
 		handler,
 		items: items.slice(),
@@ -35,14 +22,27 @@ function getFuzzyState(items, input) {
 		tolerance: options.tolerance
 	};
 }
+function getHandler(input) {
+	if (input == null || input === getString) return getString;
+	switch (typeof input) {
+		case "function": return input;
+		case "string": return (item) => item[input];
+		default:
+			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
+			throw new TypeError(FUZZY_MESSAGE_HANDLER);
+	}
+}
+function getFuzzyItems(items) {
+	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
+}
 function getTolerance(input, state) {
 	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
 	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
 }
 function fuzzy(items, configuration) {
 	if (!Array.isArray(items)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
-	const state = getFuzzyState(items, configuration);
-	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : getFuzzyOptions(options, state)) };
+	const state = createFuzzyState(items, configuration);
+	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : createFuzzyOptions(options, state)) };
 	Object.defineProperties(instance, {
 		items: {
 			enumerable: true,

package/dist/string/normalize.mjs

@@ -2,6 +2,16 @@ import { isPlainObject } from "../internal/is.mjs";
 import { memoize } from "../internal/function/memoize.mjs";
 import { lowerCase } from "../internal/string/case.mjs";
 //#region src/string/normalize.ts
+function createNormalizeOptions(input) {
+	const options = isPlainObject(input) ? input : {};
+	return {
+		deburr: options.deburr !== false,
+		lowerCase: options.lowerCase !== false,
+		special: options.special === true,
+		trim: options.trim !== false,
+		whitespace: options.whitespace !== false
+	};
+}
 /**
 * Deburr a string, removing diacritical marks
 *
@@ -17,16 +27,6 @@ function deburr(value) {
 	});
 	return deburrMemoizer.run(value);
 }
-function getNormalizeOptions(input) {
-	const options = isPlainObject(input) ? input : {};
-	return {
-		deburr: options.deburr !== false,
-		lowerCase: options.lowerCase !== false,
-		special: options.special === true,
-		trim: options.trim !== false,
-		whitespace: options.whitespace !== false
-	};
-}
 /**
 * Initialize a string normalizer
 *
@@ -36,7 +36,7 @@ function getNormalizeOptions(input) {
 * @returns Normalizer function
 */
 function initializeNormalizer(options) {
-	const normalization = getNormalizeOptions(options);
+	const normalization = createNormalizeOptions(options);
 	return (value) => normalizeString(value, normalization);
 }
 /**
@@ -49,7 +49,7 @@ function initializeNormalizer(options) {
 * @returns Normalized string
 */
 function normalize(value, options) {
-	return normalizeString(value, getNormalizeOptions(options));
+	return normalizeString(value, createNormalizeOptions(options));
 }
 function normalizeString(value, options) {
 	if (typeof value !== "string") return "";

package/dist/string/template.mjs

@@ -2,18 +2,18 @@ import { isPlainObject, isTemplateStringsArray } from "../internal/is.mjs";
 import { getString, interpolate } from "../internal/string/misc.mjs";
 import { getValue } from "../internal/value/get.mjs";
 //#region src/string/template.ts
-function getRenderer(strings, values) {
-	return (variables, options) => {
-		return template(interpolate(strings, values), variables, options);
-	};
-}
-function getTemplateOptions(input) {
+function createTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
 		ignoreCase: options.ignoreCase === true,
 		pattern: options.pattern instanceof RegExp ? options.pattern : TEMPLATE_EXPRESSION_VARIABLE
 	};
 }
+function getRenderer(strings, values) {
+	return (variables, options) => {
+		return template(interpolate(strings, values), variables, options);
+	};
+}
 function handleTemplate(value, pattern, ignoreCase, variables) {
 	if (typeof value !== "string") return "";
 	if (typeof variables !== "object" || variables === null || Object.keys(variables).length === 0) return value;
@@ -35,14 +35,14 @@ function handleTemplate(value, pattern, ignoreCase, variables) {
 * @returns _Templater_ function
 */
 function initializeTemplater(options) {
-	const { ignoreCase, pattern } = getTemplateOptions(options);
+	const { ignoreCase, pattern } = createTemplateOptions(options);
 	return ((value, ...parameters) => {
 		return isTemplateStringsArray(value) ? (variables) => handleTemplate(interpolate(value, parameters), pattern, ignoreCase, variables) : handleTemplate(value, pattern, ignoreCase, parameters[0]);
 	});
 }
 function template(value, ...parameters) {
 	if (isTemplateStringsArray(value)) return getRenderer(value, parameters);
-	const { ignoreCase, pattern } = getTemplateOptions(parameters[1]);
+	const { ignoreCase, pattern } = createTemplateOptions(parameters[1]);
 	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
 const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;

package/dist/subscription.d.mts

@@ -1,2 +1,2 @@
-import { Subscription, isSubscription } from "./internal/subscription.mjs";
-export { type Subscription, isSubscription };
+import { Subscription, SubscriptionParameters, SubscriptionProperty, Subscriptions, SubscriptionsParameters, isSubscription, isSubscriptions, subscriptions } from "./internal/subscription.mjs";
+export { type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, isSubscription, isSubscriptions, subscriptions };

package/dist/subscription.mjs

@@ -1,2 +1,2 @@
-import { isSubscription } from "./internal/subscription.mjs";
-export { isSubscription };
+import { isSubscription, isSubscriptions, subscriptions } from "./internal/subscription.mjs";
+export { isSubscription, isSubscriptions, subscriptions };

package/dist/value/clone.d.mts

@@ -9,19 +9,36 @@ type CloneOptions = {
    * Copy symbols instead of returning `Symbol(description)`? _(defaults to `false`)_
    */
   copySymbols?: boolean;
-  /**
-   * Clone only the value itself, without cloning nested values? _(defaults to `false`)_
-   */
-  flat?: boolean;
 };
 /**
- * Clone any kind of value _(shallowly)_
- *
- * @param value Value to clone
- * @param flat Clone only the value itself, without cloning nested values
- * @returns Cloned value
+ * A cloning function with predefined options
  */
-declare function clone<Value>(value: Value, flat: true): Value;
+type Cloner = {
+  /**
+   * Clone any kind of value
+   *
+   * @param value Value to clone
+   * @returns Cloned value
+   */
+  <Value>(value: Value): Value;
+  /**
+   * Deregister a clone handler for a specific class
+   *
+   * _Available as `deregisterCloner` and `template.deregister`_
+   *
+   * @param constructor Class constructor
+   */
+  deregister: typeof deregisterCloner;
+  /**
+   * Register a clone handler for a specific class
+   *
+   * _Available as `registerCloner` and `template.register`_
+   *
+   * @param constructor Class constructor
+   * @param handler Method name or clone function _(defaults to method name `clone`)_
+   */
+  register: typeof registerCloner;
+};
 /**
  * Clone any kind of value _(deeply, if needed)_
  *
@@ -31,18 +48,19 @@ declare function clone<Value>(value: Value, flat: true): Value;
  */
 declare function clone<Value>(value: Value, options?: CloneOptions): Value;
 declare namespace clone {
+  var deregister: typeof deregisterCloner;
   var handlers: {
     deregister(constructor: Constructor): void;
     handle(value: unknown, ...parameters: unknown[]): unknown;
     register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
-  var deregister: typeof deregisterCloner;
+  var initialize: typeof initializeCloner;
   var register: typeof registerCloner;
 }
 /**
  * Copy any kind of value
  *
- * - Clones the value shallowly, without cloning nested values
+ * - Copies the value shallowly _(if possible)_, without copying or cloning nested values
  * - To copy a value deeply, use `clone` instead
  *
  * @param value Value to copy
@@ -57,6 +75,15 @@ declare function copy<Value>(value: Value): Value;
  * @param constructor Class constructor
  */
 declare function deregisterCloner<Instance>(constructor: Constructor<Instance>): void;
+/**
+ * Create a cloner with predefined options
+ *
+ * _Available as `initializeCloner` and `clone.initialize`_
+ *
+ * @param options Clone options
+ * @returns Cloner function
+ */
+declare function initializeCloner(options?: CloneOptions): Cloner;
 /**
  * Register a clone handler for a specific class
  *
@@ -67,4 +94,4 @@ declare function deregisterCloner<Instance>(constructor: Constructor<Instance>):
  */
 declare function registerCloner<Instance>(constructor: Constructor<Instance>, handler?: string | ((value: Instance) => Instance)): void;
 //#endregion
-export { CloneOptions, clone, copy, deregisterCloner, registerCloner };
+export { CloneOptions, Cloner, clone, copy, deregisterCloner, initializeCloner, registerCloner };