@oscarpalmer/atoms 0.219.0 → 0.221.0

package/dist/internal/function/assert.mjs

@@ -64,9 +64,7 @@ function assertInstanceOf(constructor, message, error) {
 * @returns _Asserter_
 */
 function assertIs(condition, message, error) {
-	return (value) => {
-		assert(() => condition(value), message, error);
-	};
+	return assertCondition(condition, message, error);
 }
 /**
 * Creates an _Asserter_ that asserts a property of a value exists and satisfies a condition, throwing an error if it does not

package/dist/internal/string/case.d.mts

@@ -1,3 +1,4 @@
+import { StringCaseOptions } from "../../models/string/string.case.model.mjs";
 //#region src/internal/string/case.d.ts
 /**
  * Convert a string to camel case _(thisIsCamelCase)_
@@ -103,6 +104,7 @@ export declare function snakeCase(value: string): string;
  * ```
  */
 export declare function titleCase(value: string): string;
+export declare function toCaseCallback(this: StringCaseOptions, value: string): string;
 /**
  * Convert a string to upper case
  *

package/dist/internal/string/case.mjs

@@ -1,6 +1,6 @@
 import { join, words } from "./misc.mjs";
 import { memoize } from "../function/memoize.mjs";
-import { STRING_CASE_CAMEL, STRING_CASE_KEBAB, STRING_CASE_PASCAL, STRING_CASE_SNAKE, STRING_EXPRESSION_ACRONYM, STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE } from "../../models/string/string.case.model.mjs";
+import { STRING_CASE_CAMEL, STRING_CASE_CAPITALIZE, STRING_CASE_KEBAB, STRING_CASE_LOWER, STRING_CASE_PASCAL, STRING_CASE_SNAKE, STRING_CASE_TITLE, STRING_CASE_UPPER, STRING_EXPRESSION_ACRONYM, STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE, ignoreCachingCases } from "../../models/string/string.case.model.mjs";
 //#region src/internal/string/case.ts
 /**
 * Convert a string to camel case _(thisIsCamelCase)_
@@ -34,9 +34,11 @@ function camelCase(value) {
 * ```
 */
 function capitalize(value) {
-	if (typeof value !== "string" || value.length === 0) return "";
-	memoizedCapitalize ??= memoize((v) => v.length === 1 ? v.toLocaleUpperCase() : `${v.charAt(0).toLocaleUpperCase()}${v.slice(1).toLocaleLowerCase()}`);
-	return memoizedCapitalize.run(value);
+	return toCase(STRING_CASE_CAPITALIZE, value, true, true, capitalizeHandler);
+}
+function capitalizeHandler(value) {
+	if (value.length === 1) return value.toLocaleUpperCase();
+	return `${value.charAt(0).toLocaleUpperCase()}${value.slice(1).toLocaleLowerCase()}`;
 }
 /**
 * Convert a string to kebab case _(this-is-kebab-case)_
@@ -69,9 +71,10 @@ function kebabCase(value) {
 * ```
 */
 function lowerCase(value) {
-	if (typeof value !== "string") return "";
-	memoizedLowerCase ??= memoize((v) => v.toLocaleLowerCase());
-	return memoizedLowerCase.run(value);
+	return toCase(STRING_CASE_LOWER, value, false, false, lowerCaseHandler);
+}
+function lowerCaseHandler(value) {
+	return value.toLocaleLowerCase();
 }
 /**
 * Convert a string to pascal case _(ThisIsPascalCase)_
@@ -122,33 +125,39 @@ function snakeCase(value) {
 * ```
 */
 function titleCase(value) {
-	if (typeof value !== "string" || value.length === 0) return "";
-	memoizedTitleCase ??= memoize((v) => v.length < 2 ? capitalize(v) : join(words(v).map(capitalize), " "));
-	return memoizedTitleCase.run(value);
+	return toCase(STRING_CASE_TITLE, value, true, true, titleCaseHandler);
 }
-function toCase(type, value, capitalizeAny, capitalizeFirst) {
-	caseMemoizers[type] ??= memoize(toCaseCallback.bind({
-		type,
-		capitalizeAny,
-		capitalizeFirst
-	}));
-	return caseMemoizers[type].run(value);
+function titleCaseHandler(value) {
+	if (value.length < 2) return capitalize(value);
+	return join(words(value).map(capitalize), " ");
 }
-function toCaseCallback(value) {
+function toCase(type, value, capitalizeAny, capitalizeFirst, handler) {
 	if (typeof value !== "string") return "";
-	if (value.length < 1) return value;
+	if (value.trim().length === 0) return value;
+	if (handler == null) {
+		caseMemoizers[type] ??= memoize(toCaseCallback.bind({
+			type,
+			capitalizeAny,
+			capitalizeFirst
+		}));
+		return caseMemoizers[type].run(value);
+	}
+	if (ignoreCachingCases.has(type)) return handler(value);
+	simpleMemoizers[type] ??= memoize(handler);
+	return simpleMemoizers[type].run(value);
+}
+function toCaseCallback(value) {
 	const { capitalizeAny, capitalizeFirst, type } = this;
 	const parts = words(value);
 	const partsLength = parts.length;
 	const cased = [];
 	for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
-		const items = parts[partIndex].replace(STRING_EXPRESSION_ACRONYM, (full, one, two, three) => three === "s" ? full : `${one}-${two}${three}`).replace(STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE).split("-");
+		const items = parts[partIndex].replace(STRING_EXPRESSION_ACRONYM, "-").replace(STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE).split("-");
 		const itemsLength = items.length;
 		const partResult = [];
 		let itemCount = 0;
 		for (let itemIndex = 0; itemIndex < itemsLength; itemIndex += 1) {
 			const item = items[itemIndex];
-			if (item.length === 0) continue;
 			if (!capitalizeAny || itemCount === 0 && partIndex === 0 && !capitalizeFirst) partResult.push(item.toLocaleLowerCase());
 			else partResult.push(capitalize(item));
 			itemCount += 1;
@@ -172,9 +181,10 @@ function toCaseCallback(value) {
 * ```
 */
 function upperCase(value) {
-	if (typeof value !== "string" || value.length === 0) return "";
-	memoizedUpperCase ??= memoize((v) => v.toLocaleUpperCase());
-	return memoizedUpperCase.run(value);
+	return toCase(STRING_CASE_UPPER, value, false, false, upperCaseHandler);
+}
+function upperCaseHandler(value) {
+	return value.toLocaleUpperCase();
 }
 const caseMemoizers = {};
 const delimiters = {
@@ -183,9 +193,6 @@ const delimiters = {
 	[STRING_CASE_PASCAL]: "",
 	[STRING_CASE_SNAKE]: "_"
 };
-let memoizedCapitalize;
-let memoizedLowerCase;
-let memoizedTitleCase;
-let memoizedUpperCase;
+const simpleMemoizers = {};
 //#endregion
-export { camelCase, capitalize, kebabCase, lowerCase, pascalCase, snakeCase, titleCase, upperCase };
+export { camelCase, capitalize, kebabCase, lowerCase, pascalCase, snakeCase, titleCase, toCaseCallback, upperCase };

package/dist/internal/subscription.mjs

@@ -42,9 +42,7 @@ function addSubscription(instance) {
 		return;
 	}
 	/* istanbul ignore if */
-	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
- // istanbul ignore next
-	return;
+	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null) return;
 	let keyedItems = items.keyed.get(key);
 	if (keyedItems == null) {
 		keyedItems = /* @__PURE__ */ new Set();
@@ -194,9 +192,7 @@ function removeSubscription() {
 	}
 	const keyed = items.keyed?.get(key);
 	/* istanbul ignore if */
-	if (items.keyed == null || keyed == null)
- // istanbul ignore next
-	return;
+	if (items.keyed == null || keyed == null) return;
 	removeFromStore(keyed, values, this, value, key);
 	if (keyed.size === 0) items.keyed.delete(key);
 }

package/dist/models/string/string.case.model.d.mts

@@ -1,19 +1,24 @@
 //#region src/models/string/string.case.model.d.ts
-export type StringCase = "camel" | "kebab" | "pascal" | "snake";
+export type StringCase = "camel" | "capitalize" | "kebab" | "lower" | "pascal" | "snake" | "title" | "upper";
 export type StringCaseOptions = {
   capitalizeAny: boolean;
   capitalizeFirst: boolean;
   type: StringCase;
 };
 export declare const STRING_CASE_CAMEL: StringCase;
+export declare const STRING_CASE_CAPITALIZE: StringCase;
 export declare const STRING_CASE_KEBAB: StringCase;
+export declare const STRING_CASE_LOWER: StringCase;
 export declare const STRING_CASE_PASCAL: StringCase;
 export declare const STRING_CASE_SNAKE: StringCase;
-export declare const STRING_DELIMTER_EMPTY = "";
+export declare const STRING_CASE_TITLE: StringCase;
+export declare const STRING_CASE_UPPER: StringCase;
+export declare const STRING_DELIMITER_EMPTY = "";
 export declare const STRING_DELIMITER_HYPHEN = "-";
+export declare const STRING_DELIMITER_SPACE = " ";
 export declare const STRING_DELIMITER_UNDERSCORE = "_";
 export declare const STRING_EXPRESSION_CAMEL_CASE: RegExp;
 export declare const STRING_EXPRESSION_ACRONYM: RegExp;
 export declare const STRING_REPLACEMENT_CAMEL_CASE = "$1-$2";
-export declare const STRING_S = "s";
+export declare const ignoreCachingCases: Set<StringCase>;
 //#endregion

package/dist/models/string/string.case.model.mjs

@@ -1,14 +1,19 @@
 //#region src/models/string/string.case.model.ts
 const STRING_CASE_CAMEL = "camel";
+const STRING_CASE_CAPITALIZE = "capitalize";
 const STRING_CASE_KEBAB = "kebab";
+const STRING_CASE_LOWER = "lower";
 const STRING_CASE_PASCAL = "pascal";
 const STRING_CASE_SNAKE = "snake";
-const STRING_DELIMTER_EMPTY = "";
+const STRING_CASE_TITLE = "title";
+const STRING_CASE_UPPER = "upper";
+const STRING_DELIMITER_EMPTY = "";
 const STRING_DELIMITER_HYPHEN = "-";
+const STRING_DELIMITER_SPACE = " ";
 const STRING_DELIMITER_UNDERSCORE = "_";
 const STRING_EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
-const STRING_EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
+const STRING_EXPRESSION_ACRONYM = /(?<=\p{Lu})(?=\p{Lu}\p{Ll})(?!\p{Lu}s(?!\p{Ll}))/gu;
 const STRING_REPLACEMENT_CAMEL_CASE = "$1-$2";
-const STRING_S = "s";
+const ignoreCachingCases = /* @__PURE__ */ new Set(["lower", "upper"]);
 //#endregion
-export { STRING_CASE_CAMEL, STRING_CASE_KEBAB, STRING_CASE_PASCAL, STRING_CASE_SNAKE, STRING_DELIMITER_HYPHEN, STRING_DELIMITER_UNDERSCORE, STRING_DELIMTER_EMPTY, STRING_EXPRESSION_ACRONYM, STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE, STRING_S };
+export { STRING_CASE_CAMEL, STRING_CASE_CAPITALIZE, STRING_CASE_KEBAB, STRING_CASE_LOWER, STRING_CASE_PASCAL, STRING_CASE_SNAKE, STRING_CASE_TITLE, STRING_CASE_UPPER, STRING_DELIMITER_EMPTY, STRING_DELIMITER_HYPHEN, STRING_DELIMITER_SPACE, STRING_DELIMITER_UNDERSCORE, STRING_EXPRESSION_ACRONYM, STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE, ignoreCachingCases };

package/dist/models/string/string.fuzzy.model.d.mts

@@ -27,26 +27,28 @@ export type Fuzzy<Item> = {
    *
    * @param value Value to search for
    * @param options Search options
-   * @returns Search results, with exact matches _(ordered)_ and similar matches _(ordered by relevance)_
+   * @returns Search results, with exact, included, and similar matches
    */
   search(value: string, options?: FuzzyOptions): FuzzyResult<Item>;
   /**
    * Search for items matching the given value
    *
    * @param value Value to search for
-   * @param limit Maximum number of combined items to return in `exact` and `similar`
-   * @returns Search results, with exact matches _(ordered)_ and similar matches _(ordered by relevance)_
+   * @param limit Maximum number of combined items to return in `exact`, `included`, and `similar`
+   * @returns Search results, with exact, included, and similar matches
    */
   search(value: string, limit: number): FuzzyResult<Item>;
 };
 export type FuzzyConfiguration<Item> = {
+  handler?: (item: Item) => string;
   /**
-   * Handler to stringify items
+   * Function to compare the stringified items for results _(defaults to `Intl.Collator().compare`)_
    *
-   * - May be a function that takes an item and returns a string, or if items are plain objects, a key of the item to use to grab a string value from
-   * - Defaults to `getString`
+   * @param first First string to compare
+   * @param second Second string to compare
+   * @returns Comparison result, similar to `Array.prototype.sort` callback
    */
-  handler?: (item: Item) => string;
+  compare?: (first: string, second: string) => number;
 } & (Item extends PlainObject ? {
   /**
    * Key to use to stringify items
@@ -55,13 +57,13 @@ export type FuzzyConfiguration<Item> = {
    */
   key?: keyof Item;
 } : {}) & FuzzyOptions;
-export type FuzzyItem<Item> = {
-  item: Item;
-  haystack: string;
+export type FuzzyItem<Data> = {
+  data: Data;
+  string: FuzzyString;
 };
 export type FuzzyOptions = {
   /**
-   * Maximum number of combined items to return in `exact` and `similar` _(defaults to all matches)_
+   * Maximum number of combined items to return in `exact`, `included`, and `similar` _(defaults to all matches)_
    */
   limit?: number;
   /**
@@ -72,16 +74,27 @@ export type FuzzyOptions = {
    */
   tolerance?: number;
 };
+export type FuzzyRanked<Data> = {
+  position: number;
+  /**
+   * `0` for starting with the value, `1` for the value starting a word, `2` for anything else
+   */
+  rank: number;
+} & FuzzyItem<Data>;
 /**
- * Search results from a fuzzy search, with exact and similar matches
+ * Search results from a fuzzy search, with exact, included, and similar matches
  */
 export type FuzzyResult<Item> = {
   /**
-   * Ordered items that exactly match the search value
+   * Items whose strings exactly match the search value, ordered alphabetically
    */
   exact: Item[];
   /**
-   * Ordered items that are similar to the search value, ranked by relevance
+   * Items whose strings contain the search value, ordered alphabetically
+   */
+  included: Item[];
+  /**
+   * Items whose strings are similar to the search value, ranked by relevance, sorted by score, and ordered alphabetically within the same score
    */
   similar: Item[];
 };
@@ -90,19 +103,34 @@ export type FuzzyResult<Item> = {
  */
 export type FuzzySearchOptions = { [Key in keyof FuzzyOptions]: FuzzyOptions[Key]; };
 export type FuzzyState<Item> = {
+  compare: FuzzyStateCompare<Item>;
   handler(item: Item): string;
-  items: Item[];
-  limit?: number;
-  strings: string[];
+  items: FuzzyStateItems<Item>;
+  limit: number;
   tolerance: number;
 };
+type FuzzyStateCompare<Item = unknown> = {
+  item: (first: FuzzyItem<Item>, second: FuzzyItem<Item>) => number;
+  ranked: (first: FuzzyRanked<Item>, second: FuzzyRanked<Item>) => number;
+};
+type FuzzyStateItems<Item> = {
+  original: Array<FuzzyItem<Item>>;
+  sorted?: Array<FuzzyItem<Item>>;
+};
+export type FuzzyString = {
+  lowercase: string;
+  original: string;
+};
 export type InternalFuzzy<Item = unknown> = {
   [FUZZY_SYMBOL]: FuzzyState<Item>;
 } & Fuzzy<Item>;
+export declare const FUZZY_BOUNDARY_BONUS = 2;
+export declare const FUZZY_BOUNDARY_SEPARATOR: RegExp;
 export declare const FUZZY_LENGTH_DIVISOR = 3;
 export declare const FUZZY_MESSAGE_ARRAY = "Fuzzy requires an array of items";
 export declare const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
 export declare const FUZZY_PROPERTY = "$fuzzy";
 export declare const FUZZY_PROXIMITY_THRESHOLD = 5;
 export declare const FUZZY_SYMBOL: unique symbol;
-//#endregion
+//#endregion
+export {};

package/dist/models/string/string.fuzzy.model.mjs

@@ -1,4 +1,6 @@
 //#region src/models/string/string.fuzzy.model.ts
+const FUZZY_BOUNDARY_BONUS = 2;
+const FUZZY_BOUNDARY_SEPARATOR = /[\s./:\\_-]/;
 const FUZZY_LENGTH_DIVISOR = 3;
 const FUZZY_MESSAGE_ARRAY = "Fuzzy requires an array of items";
 const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
@@ -6,4 +8,4 @@ const FUZZY_PROPERTY = "$fuzzy";
 const FUZZY_PROXIMITY_THRESHOLD = 5;
 const FUZZY_SYMBOL = Symbol(FUZZY_PROPERTY);
 //#endregion
-export { FUZZY_LENGTH_DIVISOR, FUZZY_MESSAGE_ARRAY, FUZZY_MESSAGE_HANDLER, FUZZY_PROPERTY, FUZZY_PROXIMITY_THRESHOLD, FUZZY_SYMBOL };
+export { FUZZY_BOUNDARY_BONUS, FUZZY_BOUNDARY_SEPARATOR, FUZZY_LENGTH_DIVISOR, FUZZY_MESSAGE_ARRAY, FUZZY_MESSAGE_HANDLER, FUZZY_PROPERTY, FUZZY_PROXIMITY_THRESHOLD, FUZZY_SYMBOL };

package/dist/models/string/string.misc.model.mjs

@@ -2,7 +2,7 @@
 const STRING_DELIMITER_UUID_DEFAULT = "-";
 const STRING_DELIMITER_UUID_HTML = "_";
 const STRING_EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-const STRING_EXPRESSION_WORDS = /([^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+)/g;
+const STRING_EXPRESSION_WORDS = /[\dA-Za-z\P{ASCII}]+/gu;
 const STRING_EXPRESSION_WHITESPACE_PREFIX = /^(\s+)/;
 const STRING_MATCH_ENDS_WITH = "endsWith";
 const STRING_MATCH_INCLUDES = "includes";

package/dist/models/string/string.template.model.mjs

@@ -1,5 +1,5 @@
 //#region src/models/string/string.template.model.ts
-const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
+const TEMPLATE_EXPRESSION_VARIABLE = /{{([^{}]+)}}/g;
 const TEMPLATE_SYMBOL = Symbol("template");
 //#endregion
 export { TEMPLATE_EXPRESSION_VARIABLE, TEMPLATE_SYMBOL };

package/dist/string/fuzzy.d.mts

@@ -1,7 +1,7 @@
 import { PlainObject } from "../models/index.mjs";
-import { Fuzzy, FuzzyConfiguration, FuzzyItem, FuzzyOptions, FuzzyResult, FuzzyState } from "../models/string/string.fuzzy.model.mjs";
+import { Fuzzy, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzyState, InternalFuzzy } from "../models/string/string.fuzzy.model.mjs";
 //#region src/string/fuzzy.d.ts
-declare function Fuzzy(this: any, state: FuzzyState<unknown>): void;
+declare function Fuzzy(this: InternalFuzzy, state: FuzzyState<unknown>): void;
 /**
  * Create a fuzzy searcher for an array of items
  *
@@ -50,4 +50,4 @@ export declare namespace fuzzy {
   export var match: typeof fuzzyMatch;
 }
 //#endregion
-export type { Fuzzy, FuzzyItem, FuzzyOptions, FuzzyResult };
+export type { Fuzzy, FuzzyOptions, FuzzyResult };