shelving 1.30.0 → 1.30.1

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.30.0",
+	"version": "1.30.1",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/schema/StringSchema.d.ts

@@ -31,8 +31,7 @@ export declare class StringSchema extends Schema<string> {
     readonly match: RegExp | null;
     readonly sanitizer: Sanitizer | null;
     readonly multiline: boolean;
-    readonly trim: boolean;
-    constructor({ value, type, min, max, match, sanitizer, multiline, trim, ...rest }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, type, min, max, match, sanitizer, multiline, ...rest }: ConstructorParameters<typeof Schema>[0] & {
         readonly value?: string;
         readonly type?: HtmlInputType;
         readonly min?: number;
@@ -40,7 +39,6 @@ export declare class StringSchema extends Schema<string> {
         readonly match?: RegExp | null;
         readonly sanitizer?: Sanitizer | null;
         readonly multiline?: boolean;
-        readonly trim?: boolean;
     });
     validate(unsafeValue?: unknown): string;
     /**

package/schema/StringSchema.js

@@ -22,7 +22,7 @@ import { Schema } from "./Schema.js";
  *  schema.validate('j'); // Throws 'Minimum 3 chaacters'
  */
 export class StringSchema extends Schema {
-    constructor({ value = "", type = "text", min = 0, max = null, match = null, sanitizer = null, multiline = false, trim = true, ...rest }) {
+    constructor({ value = "", type = "text", min = 0, max = null, match = null, sanitizer = null, multiline = false, ...rest }) {
         super(rest);
         this.type = type;
         this.value = value;
@@ -31,7 +31,6 @@ export class StringSchema extends Schema {
         this.match = match;
         this.sanitizer = sanitizer;
         this.multiline = multiline;
-        this.trim = trim;
     }
     validate(unsafeValue = this.value) {
         const unsafeString = typeof unsafeValue === "number" ? unsafeValue.toString() : unsafeValue;
@@ -52,11 +51,7 @@ export class StringSchema extends Schema {
      * - Applies `options.sanitizer` too (if it's set).
      */
     sanitize(uncleanString) {
-        return this.sanitizer
-            ? this.sanitizer(uncleanString)
-            : this.multiline
-                ? sanitizeLines(uncleanString, this.trim)
-                : sanitizeString(uncleanString, this.trim);
+        return this.sanitizer ? this.sanitizer(uncleanString) : this.multiline ? sanitizeLines(uncleanString) : sanitizeString(uncleanString);
     }
 }
 /** Valid string, e.g. `Hello there!` */

package/util/search.d.ts

@@ -36,7 +36,7 @@ export declare function MATCHES_ANY(item: unknown, regexps: ImmutableArray<RegEx
  * - Quoted phrases match fully (starting and ending with a word boundary).
  */
 export declare const toWordRegExps: (query: string) => ImmutableArray<RegExp>;
-/** Convert a string word to the corresponding set of case-insensitive regular expressions. */
+/** Convert a string to a regular expression matching the start of a word boundary. */
 export declare const toWordRegExp: (word: string) => RegExp;
 /** Matcher that matches any words in a string. */
 export declare class MatchAnyWord implements Matchable<unknown, void> {
@@ -51,7 +51,7 @@ export declare class MatchAllWords implements Matchable<unknown, void> {
     match(value: string): boolean;
 }
 /** Matcher that matches an exact phrase. */
-export declare class MatchPhrase implements Matchable<unknown, void> {
+export declare class MatchWord implements Matchable<unknown, void> {
     private _regexp;
     constructor(phrase: string);
     match(value: string): boolean;

package/util/search.js

@@ -50,9 +50,9 @@ export function MATCHES_ANY(item, regexps) {
  * - Unquoted words match partially (starting with a word boundary).
  * - Quoted phrases match fully (starting and ending with a word boundary).
  */
-export const toWordRegExps = (query) => toWords(query).map(normalizeString).map(toWordRegExp);
-/** Convert a string word to the corresponding set of case-insensitive regular expressions. */
-export const toWordRegExp = (word) => word.includes(" ") ? new RegExp(`\\b${escapeRegExp(word)}\\b`, "i") : new RegExp(`\\b${escapeRegExp(word)}`, "i");
+export const toWordRegExps = (query) => toWords(query).map(toWordRegExp);
+/** Convert a string to a regular expression matching the start of a word boundary. */
+export const toWordRegExp = (word) => new RegExp(`\\b${escapeRegExp(normalizeString(word))}`, "i");
 /** Matcher that matches any words in a string. */
 export class MatchAnyWord {
     constructor(words) {
@@ -72,7 +72,7 @@ export class MatchAllWords {
     }
 }
 /** Matcher that matches an exact phrase. */
-export class MatchPhrase {
+export class MatchWord {
     constructor(phrase) {
         this._regexp = toWordRegExp(phrase);
     }

package/util/string.d.ts

@@ -33,25 +33,25 @@ export declare function toTitle(value: unknown): string;
  * @param multiline If `true`, `\t` horizontal tabs and `\r` newlines are allowed (defaults to `false` which strips these characters).
  * @returns The clean output string.
  */
-export declare function sanitizeString(dirty: string, trim?: boolean): string;
+export declare const sanitizeString: (dirty: string) => string;
 /**
  * Sanitize a multiline string.
  * - Like `sanitizeString()` but allows `\t` horizontal tab and `\r` newline.
  */
-export declare function sanitizeLines(dirty: string, trim?: boolean): string;
+export declare const sanitizeLines: (dirty: string) => string;
 /**
  * Normalize a string so it can be compared to another string (free from upper/lower cases, symbols, punctuation).
  *
  * Does the following:
- * - Santize the string to remove control characters.
+ * - Removes control characters.
  * - Remove symbols (e.g. `$` dollar) and punctuation (e.g. `"` double quote).
  * - Remove marks (e.g. the umlout dots above `ö`).
  * - Convert spaces/separators to " " single space (e.g. line breaks, non-breaking space).
  * - Convert to lowercase and trim excess whitespace.
  *
- * @example normalizeString("Däve-is REALLY éxcitable—apparęntly!!!    😂"); // Returns "dave is really excitable apparently"
+ * @example normalizeString("Däve-is\nREALLY    éxcitable—apparęntly!!!    😂"); // Returns "dave is really excitable apparently"
  */
-export declare const normalizeString: (value: string) => string;
+export declare const normalizeString: (str: string) => string;
 /**
  * Convert a string to a `kebab-case` URL slug.
  * - Remove any characters not in the range `[a-z0-9-]`
@@ -67,6 +67,8 @@ export declare const toSlug: (value: string) => string;
  * @returns Array of the found words, e.g. `["yellow", "dog", "Golden Retriever"
  */
 export declare const toWords: (value: string) => ImmutableArray<string>;
+/** Find and iterate over the words in a string. */
+export declare function yieldWords(value: string): Generator<string, void, void>;
 /**
  * Convert a string to a regular expression that matches that string.
  *

package/util/string.js

@@ -3,7 +3,6 @@ import { formatDate } from "./date.js";
 import { isData } from "./data.js";
 import { isArray } from "./array.js";
 import { formatNumber, isBetween } from "./number.js";
-import { IS_DEFINED } from "./undefined.js";
 /** Is a value a string? */
 export const IS_STRING = (v) => typeof v === "string";
 /**
@@ -70,47 +69,40 @@ export function toTitle(value) {
  * @param multiline If `true`, `\t` horizontal tabs and `\r` newlines are allowed (defaults to `false` which strips these characters).
  * @returns The clean output string.
  */
-export function sanitizeString(dirty, trim = true) {
-    const clean = dirty.replace(CONTROLS, "").replace(SPACES, " ");
-    return trim ? clean.trim() : clean;
-}
-const CONTROLS = /[\x00-\x1F\x7F-\x9F]/g; // All control characters (`\x00`-`\x1F`, `\x7F`-`\x9F`)
-const SPACES = /\s/g; // Sanitize zero-width spacers etc.
+export const sanitizeString = (dirty) => dirty.replace(SANE_DISALLOWED, "").replace(SANE_SPACES, " ").trim();
+const SANE_DISALLOWED = /[\x00-\x1F\x7F-\x9F]/g; // All control characters (`\x00`-`\x1F`, `\x7F`-`\x9F`)
+const SANE_SPACES = /\s/g; // Zero-width spacers etc.
 /**
  * Sanitize a multiline string.
  * - Like `sanitizeString()` but allows `\t` horizontal tab and `\r` newline.
  */
-export function sanitizeLines(dirty, trim = true) {
-    const clean = dirty.replace(CONTROLS_MULTILINE, "").replace(SPACES_MULTILINE, " ");
-    return trim ? clean.replace(TRIM_END_MULTILINE, "") : clean;
-}
-const CONTROLS_MULTILINE = /(?![\t\n])[\x00-\x1F\x7F-\x9F]/g; // Control characters except `\t` horizontal tab and `\n` new line.
-const SPACES_MULTILINE = /(?![\t\n])\s/g; // All spaces except `\t` horizontal tab and `\n` new line.
-const TRIM_END_MULTILINE = /\s+$/gm;
+export const sanitizeLines = (dirty) => dirty.replace(LINES_DISALLOW, "").replace(LINES_SPACES, " ").replace(LINES_TRIM, "");
+const LINES_DISALLOW = /(?![\t\n])[\x00-\x1F\x7F-\x9F]/g; // Control characters except `\t` horizontal tab and `\n` new line.
+const LINES_TRIM = /\s+$/gm; // Spaces at the end of lines.
+const LINES_SPACES = /(?![\t\n])\s/g; // All spaces except `\t` horizontal tab and `\n` new line.
 /**
  * Normalize a string so it can be compared to another string (free from upper/lower cases, symbols, punctuation).
  *
  * Does the following:
- * - Santize the string to remove control characters.
+ * - Removes control characters.
  * - Remove symbols (e.g. `$` dollar) and punctuation (e.g. `"` double quote).
  * - Remove marks (e.g. the umlout dots above `ö`).
  * - Convert spaces/separators to " " single space (e.g. line breaks, non-breaking space).
  * - Convert to lowercase and trim excess whitespace.
  *
- * @example normalizeString("Däve-is REALLY éxcitable—apparęntly!!!    😂"); // Returns "dave is really excitable apparently"
+ * @example normalizeString("Däve-is\nREALLY    éxcitable—apparęntly!!!    😂"); // Returns "dave is really excitable apparently"
  */
-export const normalizeString = (value) => sanitizeString(value).normalize("NFD").replace(STRIP, "").replace(SEPARATORS, " ").trim().toLowerCase();
-const STRIP = /[\p{Symbol}\p{Mark}\p{Punctuation}]+/gu;
-const SEPARATORS = /\s+/g;
+export const normalizeString = (str) => str.normalize("NFD").replace(NORMAL_DISALLOW, "").replace(NORMAL_SPACES, " ").trim().toLowerCase();
+const NORMAL_DISALLOW = /[^\p{L}\p{N}\s]+/gu; // Keep letters, numbers, separators. Don't need to use `\p{Z}` because `\s` matches those already e.g. hair space and nbsp.
+const NORMAL_SPACES = /\s+/gu; // Convert all possible separators to space.
 /**
  * Convert a string to a `kebab-case` URL slug.
  * - Remove any characters not in the range `[a-z0-9-]`
  * - Change all spaces/separators/hyphens/dashes/underscores to `-` single hyphen.
  */
-export const toSlug = (value) => value.toLowerCase().normalize("NFD").replace(TO_HYPHEN, "-").replace(NON_ALPHANUMERIC, "").replace(TRIM_HYPHENS, "");
-const TO_HYPHEN = /[\s-–—_]+/g; // Anything that is a space becomes a hyphen.
-const NON_ALPHANUMERIC = /[^a-z0-9-]+/gu; // Anything that isn't [a-z0-9-] gets removed.
-const TRIM_HYPHENS = /^-+|-+$/g; // Trim excess hyphens at start and end.
+export const toSlug = (value) => value.toLowerCase().normalize("NFD").replace(SLUG_HYPHENS, "-").replace(SLUG_DISALLOWED, "");
+const SLUG_DISALLOWED = /[^a-z0-9-]+|^-+|-+$/gu; // Remove anything outside a-z and hyphen (except at start/end).
+const SLUG_HYPHENS = /[\s\-–—_]+/gu; // Anything that is a space becomes a hyphen.
 /**
  * Split a string into its separate words.
  * - Words enclosed "in quotes" are a single word.
@@ -119,8 +111,15 @@ const TRIM_HYPHENS = /^-+|-+$/g; // Trim excess hyphens at start and end.
  * @param value The input string, e.g. `yellow dog   "Golden Retriever"`
  * @returns Array of the found words, e.g. `["yellow", "dog", "Golden Retriever"
  */
-export const toWords = (value) => Array.from(value.matchAll(MATCH_WORD)).map(toWord).filter(IS_DEFINED);
-const toWord = (matches) => matches[1] || matches[0] || undefined;
+export const toWords = (value) => Array.from(yieldWords(value));
+/** Find and iterate over the words in a string. */
+export function* yieldWords(value) {
+    for (const matches of value.matchAll(MATCH_WORD)) {
+        const str = matches[1] || matches[0];
+        if (str)
+            yield str;
+    }
+}
 const MATCH_WORD = /[^\s"]+|"([^"]*)"/g;
 /**
  * Convert a string to a regular expression that matches that string.