@oscarpalmer/atoms 0.179.0 → 0.180.0

package/src/string/fuzzy.ts

@@ -61,7 +61,7 @@ class Fuzzy<Item> {
 			this.#state.items,
 			this.#state.strings,
 			value,
-			options == null ? this.#state : getOptions(options, this.#state),
+			options == null ? this.#state : getFuzzyOptions(options, this.#state),
 		);
 	}
 }
@@ -165,7 +165,7 @@ function getItems<Item>(items: FuzzyItem<Item>[]): Item[] {
 		.map(({item}) => item);
 }
 
-function getOptions<Item>(
+function getFuzzyOptions<Item>(
 	input: unknown,
 	state?: FuzzyState<Item>,
 ): RequiredKeys<FuzzyOptions, 'tolerance'> {
@@ -179,18 +179,14 @@ function getOptions<Item>(
 		options.limit = state?.limit;
 	}
 
-	if (typeof options.tolerance === 'number' && !Number.isNaN(options.tolerance)) {
-		options.tolerance = options.tolerance < 0 ? 0 : Math.floor(options.tolerance);
-	} else {
-		options.tolerance = state?.tolerance ?? PROXIMITY_THRESHOLD;
-	}
+	options.tolerance = getTolerance(options.tolerance, state);
 
 	return options as RequiredKeys<FuzzyOptions, 'tolerance'>;
 }
 
 function getState<Item>(items: Item[], input: unknown): FuzzyState<Item> {
 	const handler = getHandler(input);
-	const options = getOptions(input);
+	const options = getFuzzyOptions(input);
 
 	return {
 		handler,
@@ -201,6 +197,14 @@ function getState<Item>(items: Item[], input: unknown): FuzzyState<Item> {
 	};
 }
 
+function getTolerance<Item>(input: unknown, state?: FuzzyState<Item>): number {
+	if (typeof input === 'number' && !Number.isNaN(input)) {
+		return input < 0 ? 0 : Math.floor(input);
+	}
+
+	return state?.tolerance ?? PROXIMITY_THRESHOLD;
+}
+
 /**
  * Create a fuzzy searcher for an array of items
  * @param items Items to search through
@@ -236,6 +240,28 @@ export function fuzzy(items: unknown[], configuration?: unknown): Fuzzy<unknown>
 	return new Fuzzy(getState(items, configuration));
 }
 
+fuzzy.match = fuzzyMatch;
+
+/**
+ * Does the needle match the haystack in a fuzzy way?
+ * @param haystack Haystack to search through
+ * @param needle Needle to search for
+ * @returns `true` if the needle matches the haystack in a fuzzy way, `false` otherwise
+ */
+export function fuzzyMatch(haystack: string, needle: string): boolean {
+	if (typeof haystack !== 'string' || typeof needle !== 'string') {
+		return false;
+	}
+
+	const trimmed = needle.trim();
+
+	if (includes(haystack, trimmed, true)) {
+		return true;
+	}
+
+	return getScore(haystack, trimmed) > -1;
+}
+
 function isSubsequence(haystack: string, needle: string): boolean {
 	const lowerCaseHaystack = lowerCase(haystack);
 	const lowerCaseNeedle = lowerCase(needle);

package/src/string/template.ts

@@ -69,10 +69,12 @@ function handleTemplate(
 
 /**
  * Create a templater with predefined options
+ *
+ * Available as `initializeTemplater` and `template.initialize`
  * @param options Templating options
  * @returns Templater function
  */
-function initializeTemplater(options?: Partial<TemplateOptions>): Templater {
+export function initializeTemplater(options?: Partial<TemplateOptions>): Templater {
 	const {ignoreCase, pattern} = getTemplateOptions(options);
 
 	return (value: string, variables?: PlainObject): string => {

package/src/value/clone.ts

@@ -26,30 +26,9 @@ clone.handlers = getSelfHandlers(clone, {
 	method: CLONE_NAME,
 });
 
+clone.deregister = deregisterCloner;
 clone.register = registerCloner;
 
-clone.unregister = unregisterCloner;
-
-/**
- * Register a clone handler for a specific class
- * @param constructor Class constructor
- * @param handler Method name or clone function _(defaults to `clone`)_
- */
-function registerCloner<Instance>(
-	constructor: Constructor<Instance>,
-	handler?: string | ((value: Instance) => Instance),
-): void {
-	clone.handlers.register(constructor, handler);
-}
-
-/**
- * Unregister a clone handler for a specific class
- * @param constructor Class constructor
- */
-function unregisterCloner<Instance>(constructor: Constructor<Instance>): void {
-	clone.handlers.unregister(constructor);
-}
-
 function cloneArrayBuffer(
 	value: ArrayBuffer,
 	depth?: number,
@@ -260,6 +239,30 @@ function cloneValue(value: unknown, depth: number, references: WeakMap<WeakKey,
 	}
 }
 
+/**
+ * Deregister a clone handler for a specific class
+ *
+ * Available as `deregisterCloner` and `template.deregister`
+ * @param constructor Class constructor
+ */
+export function deregisterCloner<Instance>(constructor: Constructor<Instance>): void {
+	clone.handlers.deregister(constructor);
+}
+
+/**
+ * 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 `clone`)_
+ */
+export function registerCloner<Instance>(
+	constructor: Constructor<Instance>,
+	handler?: string | ((value: Instance) => Instance),
+): void {
+	clone.handlers.register(constructor, handler);
+}
+
 function tryStructuredClone(
 	value: object,
 	depth: number,

package/src/value/merge.ts

@@ -80,6 +80,20 @@ function handleMerge(values: ArrayOrPlainObject[], options: Options): ArrayOrPla
 	return !Array.isArray(values) || values.length === 0 ? {} : mergeValues(values, options, true);
 }
 
+/**
+ * Create a merger with predefined options
+ *
+ * Available as `initializeMerger` and `merge.initialize`
+ * @param options Merging options
+ * @returns Merger function
+ */
+export function initializeMerger(options?: MergeOptions): Merger {
+	const actual = getMergeOptions(options);
+
+	return <Model extends ArrayOrPlainObject>(values: NestedPartial<Model>[]): Model =>
+		handleMerge(values, actual) as Model;
+}
+
 /**
  * Merge multiple arrays or objects into a single one
  * @param values Values to merge
@@ -111,18 +125,6 @@ export function merge(
 
 merge.initialize = initializeMerger;
 
-/**
- * Create a merger with predefined options
- * @param options Merging options
- * @returns Merger function
- */
-function initializeMerger(options?: MergeOptions): Merger {
-	const actual = getMergeOptions(options);
-
-	return <Model extends ArrayOrPlainObject>(values: NestedPartial<Model>[]): Model =>
-		handleMerge(values, actual) as Model;
-}
-
 function mergeObjects(
 	values: ArrayOrPlainObject[],
 	options: Options,