shelving 1.130.1 → 1.132.0

package/api/Resource.js

@@ -1,4 +1,4 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { UNDEFINED_VALIDATOR } from "../util/validate.js";
 /**
@@ -41,7 +41,7 @@ export class Resource {
         }
         catch (thrown) {
             if (thrown instanceof Feedback)
-                throw new ValueError("Invalid result for resource", thrown);
+                throw new ValidationError("Invalid result for resource", thrown);
             throw thrown;
         }
     }

package/db/ItemStore.js

@@ -1,4 +1,4 @@
-import { RequiredError } from "../error/RequiredError.js";
+import { NotFoundError } from "../error/NotFoundError.js";
 import { BooleanStore } from "../store/BooleanStore.js";
 import { OptionalDataStore } from "../store/DataStore.js";
 import { NONE } from "../util/constants.js";
@@ -14,7 +14,7 @@ export class ItemStore extends OptionalDataStore {
     get data() {
         const item = this.value;
         if (!item)
-            throw new RequiredError(`Item must exist in "${this.collection}"`, this.id);
+            throw new NotFoundError(`Item must exist in "${this.collection}"`, this.id);
         return item;
     }
     /** Set the data of this store. */

package/db/Provider.js

@@ -1,11 +1,11 @@
-import { RequiredError } from "../error/RequiredError.js";
+import { NotFoundError } from "../error/NotFoundError.js";
 import { countArray, getOptionalFirstItem } from "../util/array.js";
 /** Provider with a fully synchronous interface */
 export class Provider {
     requireItem(collection, id) {
         const item = this.getItem(collection, id);
         if (!item)
-            throw new RequiredError(`Item must exist in "${collection}"`, id);
+            throw new NotFoundError(`Item must exist in "${collection}"`, id);
         return item;
     }
     countQuery(collection, query) {
@@ -17,7 +17,7 @@ export class Provider {
     requireFirst(collection, query) {
         const first = this.getFirst(collection, query);
         if (!first)
-            throw new RequiredError(`First item must exist in "${collection}"`, query);
+            throw new NotFoundError(`First item must exist in "${collection}"`, query);
         return first;
     }
 }
@@ -26,7 +26,7 @@ export class AsyncProvider {
     async requireItem(collection, id) {
         const item = await this.getItem(collection, id);
         if (!item)
-            throw new RequiredError(`Item must exist in "${collection}"`, id);
+            throw new NotFoundError(`Item must exist in "${collection}"`, id);
         return item;
     }
     async countQuery(collection, query) {
@@ -38,7 +38,7 @@ export class AsyncProvider {
     async requireFirst(collection, query) {
         const first = await this.getFirst(collection, query);
         if (!first)
-            throw new RequiredError(`First item must exist in "${collection}"`, query);
+            throw new NotFoundError(`First item must exist in "${collection}"`, query);
         return first;
     }
 }

package/db/QueryStore.js

@@ -1,5 +1,5 @@
 import { collection, query } from "firebase/firestore";
-import { RequiredError } from "../error/RequiredError.js";
+import { NotFoundError } from "../error/NotFoundError.js";
 import { ArrayStore } from "../store/ArrayStore.js";
 import { BooleanStore } from "../store/BooleanStore.js";
 import { NONE } from "../util/constants.js";
@@ -21,14 +21,14 @@ export class QueryStore extends ArrayStore {
     get first() {
         const first = this.optionalFirst;
         if (!first)
-            throw new RequiredError(`First item must exist in "${collection}"`, query);
+            throw new NotFoundError(`First item must exist in "${collection}"`, query);
         return first;
     }
     /** Get the last item in this store. */
     get last() {
         const last = this.optionalLast;
         if (!last)
-            throw new RequiredError(`Last item must exist in "${collection}"`, query);
+            throw new NotFoundError(`Last item must exist in "${collection}"`, query);
         return last;
     }
     constructor(collection, query, provider, memory) {

package/db/ValidationProvider.js

@@ -1,4 +1,4 @@
-import { ValueError } from "../error/ValueError.js";
+import { ValidationError } from "../error/ValidationError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { updateData } from "../util/update.js";
 import { validateWithContext } from "../util/validate.js";
@@ -124,7 +124,7 @@ function _validateItem(collection, unsafeEntity, schema) {
     catch (thrown) {
         if (!(thrown instanceof Feedback))
             throw thrown;
-        throw new ValueError(`Invalid data for "${collection}"`, thrown.message);
+        throw new ValidationError(`Invalid data for "${collection}"`, thrown.message);
     }
 }
 /** Validate a set of entities for this query reference. */
@@ -146,5 +146,5 @@ function* _yieldValidItems(collection, unsafeEntities, schema) {
         }
     }
     if (invalid)
-        throw new ValueError(`Invalid data for "${collection}"`, messages);
+        throw new ValidationError(`Invalid data for "${collection}"`, messages);
 }

package/error/ConflictError.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if the state of the program is not correct to execute a given operation. */
+export declare class ConflictError extends EnhancedError {
+    readonly code = 509;
+    constructor(message?: string, context?: unknown);
+}

package/error/ConflictError.js

@@ -0,0 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if the state of the program is not correct to execute a given operation. */
+export class ConflictError extends EnhancedError {
+    code = 509;
+    constructor(message = "Conflict", context) {
+        super(message, context);
+    }
+}
+ConflictError.prototype.name = "ConflictError";

package/error/EnhancedError.d.ts

@@ -4,6 +4,7 @@
  * - Context is converted to a string using `debug()`
  */
 export declare class EnhancedError extends Error {
+    readonly code: number;
     readonly context: unknown;
     constructor(message: string, context?: unknown);
 }

package/error/EnhancedError.js

@@ -5,6 +5,7 @@ import { debug } from "../util/debug.js";
  * - Context is converted to a string using `debug()`
  */
 export class EnhancedError extends Error {
+    code = 500;
     context;
     constructor(message, context) {
         const debugged = context !== undefined ? debug(context, 2) : "";

package/error/ForbiddenError.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if an operation failed because the user is logged in but does not have sufficient privileges to access something. */
+export declare class ForbiddenError extends EnhancedError {
+    readonly code = 403;
+    constructor(message?: string, context?: unknown);
+}

package/error/ForbiddenError.js

@@ -0,0 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if an operation failed because the user is logged in but does not have sufficient privileges to access something. */
+export class ForbiddenError extends EnhancedError {
+    code = 403;
+    constructor(message = "Forbidden", context) {
+        super(message, context);
+    }
+}
+ForbiddenError.prototype.name = "ForbiddenError";

package/error/NotFoundError.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if if a value is required but doesn't exist. */
+export declare class NotFoundError extends EnhancedError {
+    readonly code = 404;
+    constructor(message?: string, context?: unknown);
+}

package/error/NotFoundError.js

@@ -0,0 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if if a value is required but doesn't exist. */
+export class NotFoundError extends EnhancedError {
+    code = 404;
+    constructor(message = "Not found", context) {
+        super(message, context);
+    }
+}
+NotFoundError.prototype.name = "NotFoundError";

package/error/{UnimplementedError.d.ts → NotImplementedError.d.ts}

@@ -1,5 +1,6 @@
 import { EnhancedError } from "./EnhancedError.js";
 /** Error thrown when functionality is called but is not implemented by an interface. */
-export declare class UnimplementedError extends EnhancedError {
+export declare class NotImplementedError extends EnhancedError {
+    readonly code = 501;
     constructor(message?: string, value?: unknown);
 }

package/error/{UnimplementedError.js → NotImplementedError.js}

@@ -1,8 +1,9 @@
 import { EnhancedError } from "./EnhancedError.js";
 /** Error thrown when functionality is called but is not implemented by an interface. */
-export class UnimplementedError extends EnhancedError {
+export class NotImplementedError extends EnhancedError {
+    code = 501;
     constructor(message = "Not implemented", value) {
         super(message, value);
     }
 }
-UnimplementedError.prototype.name = "UnimplementedError";
+NotImplementedError.prototype.name = "NotImplementedError";

package/error/UnauthorizedError.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if an operation failed because the user is logged in but does not have sufficient privileges to access something. */
+export declare class UnauthorizedError extends EnhancedError {
+    readonly code = 403;
+    constructor(message?: string, context?: unknown);
+}

package/error/UnauthorizedError.js

@@ -0,0 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if an operation failed because the user is logged in but does not have sufficient privileges to access something. */
+export class UnauthorizedError extends EnhancedError {
+    code = 403;
+    constructor(message = "Unauthorized", context) {
+        super(message, context);
+    }
+}
+UnauthorizedError.prototype.name = "UnauthorizedError";

package/error/{ValueError.d.ts → ValidationError.d.ts}

@@ -1,5 +1,6 @@
 import { EnhancedError } from "./EnhancedError.js";
 /** Error thrown when a value isn't valid. */
-export declare class ValueError extends EnhancedError {
+export declare class ValidationError extends EnhancedError {
+    readonly code = 422;
     constructor(message?: string, context?: unknown);
 }

package/error/{ValueError.js → ValidationError.js}

@@ -1,8 +1,9 @@
 import { EnhancedError } from "./EnhancedError.js";
 /** Error thrown when a value isn't valid. */
-export class ValueError extends EnhancedError {
+export class ValidationError extends EnhancedError {
+    code = 422;
     constructor(message = "Invalid value", context) {
         super(message, context);
     }
 }
-ValueError.prototype.name = "ValidationError";
+ValidationError.prototype.name = "ValidationError";

package/error/index.d.ts

@@ -1,7 +1,8 @@
 export * from "./EnhancedError.js";
-export * from "./StateError.js";
+export * from "./ConflictError.js";
 export * from "./ConnectionError.js";
-export * from "./PermissionError.js";
-export * from "./RequiredError.js";
-export * from "./UnimplementedError.js";
-export * from "./ValueError.js";
+export * from "./ForbiddenError.js";
+export * from "./UnauthorizedError.js";
+export * from "./NotFoundError.js";
+export * from "./NotImplementedError.js";
+export * from "./ValidationError.js";

package/error/index.js

@@ -1,7 +1,8 @@
 export * from "./EnhancedError.js";
-export * from "./StateError.js";
+export * from "./ConflictError.js";
 export * from "./ConnectionError.js";
-export * from "./PermissionError.js";
-export * from "./RequiredError.js";
-export * from "./UnimplementedError.js";
-export * from "./ValueError.js";
+export * from "./ForbiddenError.js";
+export * from "./UnauthorizedError.js";
+export * from "./NotFoundError.js";
+export * from "./NotImplementedError.js";
+export * from "./ValidationError.js";

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,6 +1,6 @@
 import { addDoc, arrayRemove, arrayUnion, collection, deleteDoc, doc, documentId, getCount, getDoc, getDocs, increment, limit, orderBy, query, setDoc, updateDoc, where, } from "firebase/firestore/lite";
 import { AsyncProvider } from "../../db/Provider.js";
-import { UnimplementedError } from "../../error/UnimplementedError.js";
+import { NotImplementedError } from "../../error/NotImplementedError.js";
 import { getItem } from "../../util/item.js";
 import { getObject } from "../../util/object.js";
 import { getFilters, getLimit, getOrders } from "../../util/query.js";
@@ -76,7 +76,7 @@ export class FirestoreLiteProvider extends AsyncProvider {
         return _getOptionalItem(snapshot);
     }
     getItemSequence() {
-        throw new UnimplementedError("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new NotImplementedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async addItem(c, data) {
         const reference = await addDoc(collection(this._firestore, c), data);
@@ -100,7 +100,7 @@ export class FirestoreLiteProvider extends AsyncProvider {
         return snapshot.docs.map(_getItem);
     }
     getQuerySequence() {
-        throw new UnimplementedError("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new NotImplementedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async setQuery(c, q, data) {
         const snapshot = await getDocs(_getQuery(this._firestore, c, q));

package/iterate/InspectIterator.js

@@ -1,4 +1,4 @@
-import { StateError } from "../error/StateError.js";
+import { ConflictError } from "../error/ConflictError.js";
 import { ThroughIterator } from "./ThroughIterator.js";
 /** Used when the sequence hasn't inspected anything yet. */
 const _NOVALUE = Symbol("shelving/InspectGenerator.NOVALUE");
@@ -20,21 +20,21 @@ export class InspectIterator extends ThroughIterator {
     /** The first yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get first() {
         if (this._first === _NOVALUE)
-            throw new StateError("Iteration not started");
+            throw new ConflictError("Iteration not started");
         return this._first;
     }
     _first = _NOVALUE;
     /** The last yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get last() {
         if (this._last === _NOVALUE)
-            throw new StateError("Iteration not started");
+            throw new ConflictError("Iteration not started");
         return this._last;
     }
     _last = _NOVALUE;
     /** The returned value (throws if the iteration is not done, i.e. `this.done === false`). */
     get returned() {
         if (this._returned === _NOVALUE)
-            throw new StateError("Iteration not done");
+            throw new ConflictError("Iteration not done");
         return this._returned;
     }
     _returned = _NOVALUE;

package/package.json

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

package/react/createCacheContext.js

@@ -1,5 +1,5 @@
 import { createContext, createElement, useContext, useRef } from "react";
-import { StateError } from "../error/StateError.js";
+import { ConflictError } from "../error/ConflictError.js";
 /**
  * Create a cache context that can be provided to React elements and allows them to call `useCache()`
  * - Cache is a `Map` indexed by strings that can be used to store any value.
@@ -10,7 +10,7 @@ export function createCacheContext() {
         useCache() {
             const cache = useContext(context);
             if (!cache)
-                throw new StateError("useCache() must be used inside <Cache>");
+                throw new ConflictError("useCache() must be used inside <Cache>");
             return cache;
         },
         CacheContext({ children }) {

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` */