shelving 1.131.0 → 1.132.0

package/package.json

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

package/schema/ColorSchema.d.ts

@@ -1,5 +1,4 @@
-import type { StringSchemaOptions } from "./StringSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema, type TextSchemaOptions } from "./TextSchema.js";
 /**
  * Define a valid color hex string, e.g `#00CCFF`
  *
@@ -9,8 +8,8 @@ import { StringSchema } from "./StringSchema.js";
  *
  * Colors are limited to 512 characters (this can be changed with `max`), but generally these won't be data: URIs so this is a reasonable limit.
  */
-export declare class ColorSchema extends StringSchema {
-    constructor({ title, value, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "multiline" | "match">);
+export declare class ColorSchema extends TextSchema {
+    constructor({ title, value, ...options }: Omit<TextSchemaOptions, "type" | "min" | "max" | "multiline" | "match">);
     sanitize(insaneString: string): string;
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */

package/schema/ColorSchema.js

@@ -1,5 +1,5 @@
 import { OPTIONAL } from "./OptionalSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.js";
 const COLOR_REGEXP = /^#[0-9A-F]{6}$/;
 const NOT_HEX_REGEXP = /[^0-9A-F]/g;
 /**
@@ -11,7 +11,7 @@ const NOT_HEX_REGEXP = /[^0-9A-F]/g;
  *
  * Colors are limited to 512 characters (this can be changed with `max`), but generally these won't be data: URIs so this is a reasonable limit.
  */
-export class ColorSchema extends StringSchema {
+export class ColorSchema extends TextSchema {
     constructor({ title = "Color", value = "#000000", ...options }) {
         super({
             title,

package/schema/EmailSchema.d.ts

@@ -1,5 +1,5 @@
 import type { StringSchemaOptions } from "./StringSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.js";
 /**
  * Define a valid email address.
  *
@@ -17,9 +17,9 @@ import { StringSchema } from "./StringSchema.js";
  *     - Up to 10 segments of up to 63 characters each, separated by `.`
  *     - TLD is a segment of 2-63 characters, possibly in `xn--` international format.
  */
-export declare class EmailSchema extends StringSchema {
+export declare class EmailSchema extends TextSchema {
     constructor({ title, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "match" | "multiline">);
-    sanitize(uncleanString: string): string;
+    sanitize(str: string): string;
 }
 /** Valid email, e.g. `test@test.com` */
 export declare const EMAIL: EmailSchema;

package/schema/EmailSchema.js

@@ -1,5 +1,5 @@
 import { OPTIONAL } from "./OptionalSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.js";
 const R_MATCH = /^[a-z0-9](?:[a-zA-Z0-9._+-]{0,62}[a-zA-Z0-9])?@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.){1,3}(?:[a-z]{2,63}|xn--[a-z0-9-]{0,58}[a-z0-9])$/;
 /**
  * Define a valid email address.
@@ -18,7 +18,7 @@ const R_MATCH = /^[a-z0-9](?:[a-zA-Z0-9._+-]{0,62}[a-zA-Z0-9])?@(?:[a-z0-9](?:[a
  *     - Up to 10 segments of up to 63 characters each, separated by `.`
  *     - TLD is a segment of 2-63 characters, possibly in `xn--` international format.
  */
-export class EmailSchema extends StringSchema {
+export class EmailSchema extends TextSchema {
     constructor({ title = "Email", ...options }) {
         super({
             title,
@@ -30,9 +30,8 @@ export class EmailSchema extends StringSchema {
             multiline: false,
         });
     }
-    sanitize(uncleanString) {
-        const sanitizedString = super.sanitize(uncleanString);
-        return typeof sanitizedString === "string" ? sanitizedString.toLowerCase() : sanitizedString;
+    sanitize(str) {
+        return super.sanitize(str).toLowerCase();
     }
 }
 /** Valid email, e.g. `test@test.com` */

package/schema/KeySchema.d.ts

@@ -2,11 +2,14 @@ import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
 /**
  * Define a valid database key.
  *
+ * - Characters that are not a-z, A-Z, 0-9 are removed.
  * - Default minimum key length is 1 character.
- * - Default maximum key length is 64 characters.
+ * - Default maximum key length is 32 characters.
+ * - 32 characters is enough for UUIDs, as the 4 `-` hyphens are removed.
  */
 export declare class KeySchema extends StringSchema {
     constructor({ min, max, ...options }: StringSchemaOptions);
+    sanitize(str: string): string;
 }
 /** Valid database key. */
 export declare const KEY: KeySchema;

package/schema/KeySchema.js

@@ -1,17 +1,23 @@
 import { OPTIONAL } from "./OptionalSchema.js";
 import { StringSchema } from "./StringSchema.js";
+const R_NOT_CHAR = /[^a-zA-Z0-9]/g;
 /**
  * Define a valid database key.
  *
+ * - Characters that are not a-z, A-Z, 0-9 are removed.
  * - Default minimum key length is 1 character.
- * - Default maximum key length is 64 characters.
+ * - Default maximum key length is 32 characters.
+ * - 32 characters is enough for UUIDs, as the 4 `-` hyphens are removed.
  */
 export class KeySchema extends StringSchema {
-    constructor({ min = 1, max = 64, ...options }) {
+    constructor({ min = 1, max = 32, ...options }) {
         super({ min, max, ...options });
     }
+    sanitize(str) {
+        return str.replace(R_NOT_CHAR, "");
+    }
 }
 /** Valid database key. */
-export const KEY = new KeySchema({});
+export const KEY = new KeySchema({ title: "ID" });
 /** Valid optional database key. */
 export const OPTIONAL_KEY = OPTIONAL(KEY);

package/schema/LinkSchema.d.ts

@@ -1,7 +1,7 @@
 import type { ImmutableArray } from "../util/array.js";
 import { type AbsoluteLink } from "../util/link.js";
 import type { StringSchemaOptions } from "./StringSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.js";
 /** Allowed options for `LinkSchema` */
 export interface LinkSchemaOptions extends Omit<StringSchemaOptions, "type" | "min" | "max" | "multiline"> {
     readonly base?: AbsoluteLink | undefined;
@@ -14,7 +14,7 @@ export interface LinkSchemaOptions extends Omit<StringSchemaOptions, "type" | "m
  * - URLs are limited to 512 characters, but generally these won't be data: URIs so this is a reasonable limit.
  * - Falsy values are converted to `""` empty string.
  */
-export declare class LinkSchema extends StringSchema {
+export declare class LinkSchema extends TextSchema {
     readonly base: AbsoluteLink | undefined;
     readonly schemes: ImmutableArray<string> | undefined;
     readonly hosts: ImmutableArray<string> | undefined;

package/schema/LinkSchema.js

@@ -1,14 +1,14 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { getOptionalLinkURL } from "../util/link.js";
 import { OPTIONAL } from "./OptionalSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.js";
 /**
  * Type of `StringSchema` that defines a valid URL link.
  * - Checks URL scheme against a whitelist (always), and checks URL domain against a whitelist (optional).
  * - URLs are limited to 512 characters, but generally these won't be data: URIs so this is a reasonable limit.
  * - Falsy values are converted to `""` empty string.
  */
-export class LinkSchema extends StringSchema {
+export class LinkSchema extends TextSchema {
     base;
     schemes;
     hosts;
@@ -27,10 +27,10 @@ export class LinkSchema extends StringSchema {
     }
     // Override to clean the URL using builtin helper functions and check the schemes and hosts against the whitelists.
     validate(unsafeValue) {
-        const unsafeString = super.validate(unsafeValue);
-        const url = getOptionalLinkURL(super.sanitize(unsafeString), this.base, this.schemes, this.hosts);
+        const str = super.validate(unsafeValue);
+        const url = getOptionalLinkURL(str, this.base, this.schemes, this.hosts);
         if (!url)
-            throw new ValueFeedback(unsafeString ? "Invalid format" : "Required", unsafeString);
+            throw new ValueFeedback(str ? "Invalid format" : "Required", str);
         return url.href;
     }
 }

package/schema/NumberSchema.js

@@ -26,7 +26,7 @@ export class NumberSchema extends Schema {
     }
 }
 /** Valid number, e.g. `2048.12345` or `0` zero. */
-export const NUMBER = new NumberSchema({});
+export const NUMBER = new NumberSchema({ title: "Number" });
 /** Valid optional number, e.g. `2048.12345` or `0` zero, or `null` */
 export const OPTIONAL_NUMBER = OPTIONAL(NUMBER);
 /** Valid integer number, e.g. `2048` or `0` zero. */

package/schema/PhoneSchema.d.ts

@@ -1,11 +1,11 @@
 import type { StringSchemaOptions } from "./StringSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.js";
 /**
  * Type of `StringSchema` that defines a valid phone number.
  * - Multiple string formats are automatically converted to E.164 format (starting with `+` plus).
  * - Falsy values are converted to `""` empty string.
  */
-export declare class PhoneSchema extends StringSchema {
+export declare class PhoneSchema extends TextSchema {
     constructor({ title, ...options }: StringSchemaOptions);
     sanitize(insaneString: string): string;
 }

package/schema/PhoneSchema.js

@@ -1,5 +1,5 @@
 import { OPTIONAL } from "./OptionalSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.js";
 // Valid phone number is max 16 digits made up of:
 // - Country code (`+` plus character and 1-3 digits, e.g. `+44` or `+1`).
 // - Subscriber number (5-12 digits — the Solomon Islands have five-digit phone numbers apparently).
@@ -9,7 +9,7 @@ const PHONE_REGEXP = /^\+[1-9][0-9]{0,2}[0-9]{5,12}$/;
  * - Multiple string formats are automatically converted to E.164 format (starting with `+` plus).
  * - Falsy values are converted to `""` empty string.
  */
-export class PhoneSchema extends StringSchema {
+export class PhoneSchema extends TextSchema {
     constructor({ title = "Phone", ...options }) {
         super({
             title,

package/schema/SlugSchema.d.ts

@@ -8,7 +8,7 @@ import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
  */
 export declare class SlugSchema extends StringSchema {
     constructor(options: Omit<StringSchemaOptions, "min" | "max" | "multiline">);
-    sanitize(insaneString: string): string;
+    sanitize(str: string): string;
 }
 /** Valid slug, e.g. `this-is-a-slug` */
 export declare const SLUG: SlugSchema;

package/schema/SlugSchema.js

@@ -14,11 +14,10 @@ export class SlugSchema extends StringSchema {
             ...options,
             min: 2,
             max: 32,
-            multiline: false,
         });
     }
-    sanitize(insaneString) {
-        return getSlug(insaneString);
+    sanitize(str) {
+        return getSlug(str);
     }
 }
 /** Valid slug, e.g. `this-is-a-slug` */

package/schema/StringSchema.d.ts

@@ -1,27 +1,16 @@
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
-/** `type=""` prop for HTML `<input />` tags that are relevant for strings. */
-export type HtmlInputType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
 /** Function that sanitizes a string. */
 export type Sanitizer = (str: string) => string;
 /** Options for `StringSchema` */
 export interface StringSchemaOptions extends SchemaOptions {
     readonly value?: string | undefined;
-    readonly type?: HtmlInputType | undefined;
     readonly min?: number | undefined;
     readonly max?: number | undefined;
-    readonly match?: RegExp | undefined;
-    readonly sanitizer?: Sanitizer | undefined;
-    readonly multiline?: boolean | undefined;
 }
 /**
  * Schema that defines a valid string.
  *
- * Ensures value is string and optionally enforces min/max length, whether to trim whitespace, and regex match format.
- * Doesn't allow `null` to mean no value — empty string is the equivalent for StringSchema (because it means we'll never accidentally get `"null"` by converting the `null` to string).
- *
- * Defaults to a single line text string (newlines are stripped). Use `multiline=true` to allow newlines.
- *
  * @example
  *  const schema = new StringSchema({ default: 'abc', required: true, min: 2, max: 6, match: /^[a-z0-9]+$/, trim: true });
  *  schema.validate('def'); // Returns 'def'
@@ -36,32 +25,14 @@ export interface StringSchemaOptions extends SchemaOptions {
  */
 export declare class StringSchema extends Schema<string> {
     readonly value: string;
-    readonly type: HtmlInputType;
     readonly min: number;
     readonly max: number;
-    readonly match: RegExp | undefined;
-    readonly sanitizer: Sanitizer | undefined;
-    readonly multiline: boolean;
-    constructor({ type, min, max, match, sanitizer, multiline, value, ...options }: StringSchemaOptions);
+    constructor({ min, max, value, ...options }: StringSchemaOptions);
     validate(unsafeValue?: unknown): string;
-    /**
-     * Clean a string by removing characters that aren't digits.
-     * - Might be empty string if the string contained only invalid characters.
-     * - Applies `options.sanitizer` too (if it's set).
-     */
-    sanitize(insaneString: string): string;
+    /** Sanitize the string by removing unwanted characters. */
+    sanitize(str: string): string;
 }
 /** Valid string, e.g. `Hello there!` */
 export declare const STRING: StringSchema;
 /** Valid string, `Hello there!`, with more than one character. */
 export declare const REQUIRED_STRING: StringSchema;
-/** Title string, e.g. `Title of something` */
-export declare const TITLE: StringSchema;
-/** Optional name string, e.g. `Title of something` or `null` */
-export declare const OPTIONAL_TITLE: import("./OptionalSchema.js").OptionalSchema<string>;
-/** Name string, e.g. `Name of Something` */
-export declare const NAME: StringSchema;
-/** Optional name string, e.g. `Name of Something` or `null` */
-export declare const OPTIONAL_NAME: import("./OptionalSchema.js").OptionalSchema<string>;
-/** Password string. */
-export declare const PASSWORD: StringSchema;

package/schema/StringSchema.js

@@ -1,15 +1,8 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
-import { sanitizeLines, sanitizeString } from "../util/string.js";
-import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /**
  * Schema that defines a valid string.
  *
- * Ensures value is string and optionally enforces min/max length, whether to trim whitespace, and regex match format.
- * Doesn't allow `null` to mean no value — empty string is the equivalent for StringSchema (because it means we'll never accidentally get `"null"` by converting the `null` to string).
- *
- * Defaults to a single line text string (newlines are stripped). Use `multiline=true` to allow newlines.
- *
  * @example
  *  const schema = new StringSchema({ default: 'abc', required: true, min: 2, max: 6, match: /^[a-z0-9]+$/, trim: true });
  *  schema.validate('def'); // Returns 'def'
@@ -23,20 +16,12 @@ import { Schema } from "./Schema.js";
  *  schema.validate('j'); // Throws 'Minimum 3 chaacters'
  */
 export class StringSchema extends Schema {
-    type;
     min;
     max;
-    match;
-    sanitizer;
-    multiline;
-    constructor({ type = "text", min = 0, max = Number.POSITIVE_INFINITY, match, sanitizer, multiline = false, value = "", ...options }) {
+    constructor({ min = 0, max = Number.POSITIVE_INFINITY, value = "", ...options }) {
         super({ value, ...options });
-        this.type = type;
         this.min = min;
         this.max = max;
-        this.match = match;
-        this.sanitizer = sanitizer;
-        this.multiline = multiline;
     }
     validate(unsafeValue = this.value) {
         const possibleString = typeof unsafeValue === "number" ? unsafeValue.toString() : unsafeValue;
@@ -47,30 +32,14 @@ export class StringSchema extends Schema {
             throw new ValueFeedback(saneString ? `Minimum ${this.min} characters` : "Required", saneString);
         if (saneString.length > this.max)
             throw new ValueFeedback(`Maximum ${this.max} characters`, saneString);
-        if (this.match && !this.match.test(saneString))
-            throw new ValueFeedback(saneString ? "Invalid format" : "Required", saneString);
         return saneString;
     }
-    /**
-     * Clean a string by removing characters that aren't digits.
-     * - Might be empty string if the string contained only invalid characters.
-     * - Applies `options.sanitizer` too (if it's set).
-     */
-    sanitize(insaneString) {
-        return this.sanitizer ? this.sanitizer(insaneString) : this.multiline ? sanitizeLines(insaneString) : sanitizeString(insaneString);
+    /** Sanitize the string by removing unwanted characters. */
+    sanitize(str) {
+        return str;
     }
 }
 /** Valid string, e.g. `Hello there!` */
 export const STRING = new StringSchema({});
 /** Valid string, `Hello there!`, with more than one character. */
 export const REQUIRED_STRING = new StringSchema({ min: 1 });
-/** Title string, e.g. `Title of something` */
-export const TITLE = new StringSchema({ title: "Title", min: 1, max: 100 });
-/** Optional name string, e.g. `Title of something` or `null` */
-export const OPTIONAL_TITLE = OPTIONAL(TITLE);
-/** Name string, e.g. `Name of Something` */
-export const NAME = new StringSchema({ title: "Name", min: 1, max: 100 });
-/** Optional name string, e.g. `Name of Something` or `null` */
-export const OPTIONAL_NAME = OPTIONAL(NAME);
-/** Password string. */
-export const PASSWORD = new StringSchema({ title: "Password", min: 6, type: "password" });

package/schema/TextSchema.d.ts

@@ -0,0 +1,40 @@
+import { type Sanitizer, StringSchema, type StringSchemaOptions } from "./StringSchema.js";
+/** `type=""` prop for HTML `<input />` tags that are relevant for strings. */
+export type TextSchemaType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
+/** Options for `TextSchema` */
+export interface TextSchemaOptions extends StringSchemaOptions {
+    readonly type?: TextSchemaType | undefined;
+    readonly match?: RegExp | undefined;
+    readonly multiline?: boolean | undefined;
+}
+/**
+ * Schema that defines a valid text string.
+ *
+ * Ensures value is string and optionally enforces min/max length, whether to trim whitespace, and regex match format.
+ * Doesn't allow `null` to mean no value — empty string is the equivalent for StringSchema (because it means we'll never accidentally get `"null"` by converting the `null` to string).
+ *
+ * Defaults to a single line text string (newlines are stripped). Use `multiline=true` to allow newlines.
+ */
+export declare class TextSchema extends StringSchema {
+    readonly type: TextSchemaType;
+    readonly match: RegExp | undefined;
+    readonly sanitizer: Sanitizer | undefined;
+    readonly multiline: boolean;
+    constructor({ type, match, multiline, ...options }: TextSchemaOptions);
+    validate(unsafeValue?: unknown): string;
+    sanitize(str: string): string;
+}
+/** Valid text, e.g. `Hello there!` */
+export declare const TEXT: TextSchema;
+/** Valid text, `Hello there!`, with more than one character. */
+export declare const REQUIRED_TEXT: TextSchema;
+/** Title string, e.g. `Title of something` */
+export declare const TITLE: TextSchema;
+/** Optional name string, e.g. `Title of something` or `null` */
+export declare const OPTIONAL_TITLE: import("./OptionalSchema.js").OptionalSchema<string>;
+/** Name string, e.g. `Name of Something` */
+export declare const NAME: TextSchema;
+/** Optional name string, e.g. `Name of Something` or `null` */
+export declare const OPTIONAL_NAME: import("./OptionalSchema.js").OptionalSchema<string>;
+/** Password string. */
+export declare const PASSWORD: TextSchema;

package/schema/TextSchema.js

@@ -0,0 +1,47 @@
+import { ValueFeedback } from "../feedback/Feedback.js";
+import { sanitizeMultilineText, sanitizeText } from "../util/string.js";
+import { OPTIONAL } from "./OptionalSchema.js";
+import { StringSchema } from "./StringSchema.js";
+/**
+ * Schema that defines a valid text string.
+ *
+ * Ensures value is string and optionally enforces min/max length, whether to trim whitespace, and regex match format.
+ * Doesn't allow `null` to mean no value — empty string is the equivalent for StringSchema (because it means we'll never accidentally get `"null"` by converting the `null` to string).
+ *
+ * Defaults to a single line text string (newlines are stripped). Use `multiline=true` to allow newlines.
+ */
+export class TextSchema extends StringSchema {
+    type;
+    match;
+    sanitizer;
+    multiline;
+    constructor({ type = "text", match, multiline = false, ...options }) {
+        super(options);
+        this.type = type;
+        this.match = match;
+        this.multiline = multiline;
+    }
+    validate(unsafeValue = this.value) {
+        const str = super.validate(unsafeValue);
+        if (this.match && !this.match.test(str))
+            throw new ValueFeedback(str ? "Invalid format" : "Required", str);
+        return str;
+    }
+    sanitize(str) {
+        return this.multiline ? sanitizeMultilineText(str) : sanitizeText(str);
+    }
+}
+/** Valid text, e.g. `Hello there!` */
+export const TEXT = new TextSchema({ title: "Text" });
+/** Valid text, `Hello there!`, with more than one character. */
+export const REQUIRED_TEXT = new TextSchema({ min: 1 });
+/** Title string, e.g. `Title of something` */
+export const TITLE = new TextSchema({ title: "Title", min: 1, max: 100 });
+/** Optional name string, e.g. `Title of something` or `null` */
+export const OPTIONAL_TITLE = OPTIONAL(TITLE);
+/** Name string, e.g. `Name of Something` */
+export const NAME = new TextSchema({ title: "Name", min: 1, max: 100 });
+/** Optional name string, e.g. `Name of Something` or `null` */
+export const OPTIONAL_NAME = OPTIONAL(NAME);
+/** Password string. */
+export const PASSWORD = new TextSchema({ title: "Password", min: 6, type: "password" });

package/schema/index.d.ts

@@ -15,6 +15,7 @@ export * from "./NumberSchema.js";
 export * from "./PhoneSchema.js";
 export * from "./SlugSchema.js";
 export * from "./StringSchema.js";
+export * from "./TextSchema.js";
 export * from "./TimeSchema.js";
 export * from "./ThroughSchema.js";
 export * from "./OptionalSchema.js";

package/schema/index.js

@@ -15,6 +15,7 @@ export * from "./NumberSchema.js";
 export * from "./PhoneSchema.js";
 export * from "./SlugSchema.js";
 export * from "./StringSchema.js";
+export * from "./TextSchema.js";
 export * from "./TimeSchema.js";
 export * from "./ThroughSchema.js";
 export * from "./OptionalSchema.js";

package/util/string.d.ts

@@ -36,7 +36,7 @@ export declare function getStringLength(str: string, min?: number, max?: number)
 /** Concatenate an iterable set of strings together. */
 export declare function joinStrings(strs: Iterable<string> & NotString, joiner?: string): string;
 /**
- * Sanitize a single-line string.
+ * Sanitize a single line of text.
  * - Used when you're sanitising a single-line input, e.g. a title for something.
  * - Remove allow control characters
  * - Normalise runs of whitespace to one ` ` space,
@@ -44,9 +44,9 @@ export declare function joinStrings(strs: Iterable<string> & NotString, joiner?:
  *
  * @example santizeString("\x00Nice!   "); // Returns `"Nice!"`
  */
-export declare function sanitizeString(str: string): string;
+export declare function sanitizeText(str: string): string;
 /**
- * Sanitize a multiline string.
+ * Sanitize multiple lines of text.
  * - Used when you're sanitising a multi-line input, e.g. a description for something.
  * - Remove all control characters except `\n` newline.
  * - Normalise weird characters like paragraph separator, line separator, `\t` tab, `\r` carriage return.
@@ -55,7 +55,7 @@ export declare function sanitizeString(str: string): string;
  * - Allow spaces at the start of each line (for indentation) but trim the end of each line.
  * - Trim excess newlines at the start and end of the string and runs of more than two newlines in a row.
  */
-export declare function sanitizeLines(str: string): string;
+export declare function sanitizeMultilineText(str: string): string;
 /**
  * Simplify a string by removing anything that isn't a number, letter, or space.
  * - Normalizes the string by

package/util/string.js

@@ -65,7 +65,7 @@ export function joinStrings(strs, joiner = "") {
     return getArray(strs).join(joiner);
 }
 /**
- * Sanitize a single-line string.
+ * Sanitize a single line of text.
  * - Used when you're sanitising a single-line input, e.g. a title for something.
  * - Remove allow control characters
  * - Normalise runs of whitespace to one ` ` space,
@@ -73,14 +73,14 @@ export function joinStrings(strs, joiner = "") {
  *
  * @example santizeString("\x00Nice!   "); // Returns `"Nice!"`
  */
-export function sanitizeString(str) {
+export function sanitizeText(str) {
     return str
         .replace(/[^\P{C}\s]/gu, "") // Strip control characters (except whitespace).
         .replace(/\s+/gu, " ") // Normalise runs of whitespace to one ` ` space.
         .trim(); // Trim whitespace from the start and end of the string.
 }
 /**
- * Sanitize a multiline string.
+ * Sanitize multiple lines of text.
  * - Used when you're sanitising a multi-line input, e.g. a description for something.
  * - Remove all control characters except `\n` newline.
  * - Normalise weird characters like paragraph separator, line separator, `\t` tab, `\r` carriage return.
@@ -89,7 +89,7 @@ export function sanitizeString(str) {
  * - Allow spaces at the start of each line (for indentation) but trim the end of each line.
  * - Trim excess newlines at the start and end of the string and runs of more than two newlines in a row.
  */
-export function sanitizeLines(str) {
+export function sanitizeMultilineText(str) {
     return str
         .replace(/[^\P{C}\s]/gu, "") // Strip control characters (except whitespace).
         .replace(/\r\n?|\v|\x85|\u2028/g, "\n") // Normalise line separators to `\n` newline