shelving 1.150.5 → 1.150.7

package/db/Change.d.ts

@@ -1,7 +1,7 @@
 import type { ImmutableArray } from "../util/array.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { ItemQuery } from "../util/item.js";
-import { type Optional } from "../util/optional.js";
+import { type Nullish } from "../util/null.js";
 import type { Updates } from "../util/update.js";
 import type { AsyncProvider, Provider } from "./Provider.js";
 /** A change to a database. */
@@ -68,8 +68,8 @@ export type DatabaseChanges<T extends Database> = ImmutableArray<DatabaseChange<
 /** Write a single change to a synchronous provider and return an array of the changes that were written. */
 export declare function writeChange<T extends Database>(provider: Provider<T>, change: DatabaseChange<T>): DatabaseChange<T>;
 /** Write a set of changes to a synchronous provider. */
-export declare function writeChanges<T extends Database>(provider: Provider<T>, ...changes: Optional<DatabaseChange<T>>[]): DatabaseChanges<T>;
+export declare function writeChanges<T extends Database>(provider: Provider<T>, ...changes: Nullish<DatabaseChange<T>>[]): DatabaseChanges<T>;
 /** Write a single change to an asynchronous provider and return the change that was written. */
 export declare function writeAsyncChange<T extends Database>(provider: AsyncProvider<T>, change: DatabaseChange<T>): Promise<DatabaseChange<T>>;
 /** Write a set of changes to an asynchronous provider. */
-export declare function writeAsyncChanges<T extends Database>(provider: AsyncProvider<T>, ...changes: Optional<DatabaseChange<T>>[]): Promise<DatabaseChanges<T>>;
+export declare function writeAsyncChanges<T extends Database>(provider: AsyncProvider<T>, ...changes: Nullish<DatabaseChange<T>>[]): Promise<DatabaseChanges<T>>;

package/db/Change.js

@@ -1,4 +1,4 @@
-import { notOptional } from "../util/optional.js";
+import { notNullish } from "../util/null.js";
 /** Write a single change to a synchronous provider and return an array of the changes that were written. */
 export function writeChange(provider, change) {
     const { action, collection, id, query } = change;
@@ -26,7 +26,7 @@ export function writeChange(provider, change) {
 }
 /** Write a set of changes to a synchronous provider. */
 export function writeChanges(provider, ...changes) {
-    return changes.filter(notOptional).map(change => writeChange(provider, change));
+    return changes.filter(notNullish).map(change => writeChange(provider, change));
 }
 /** Write a single change to an asynchronous provider and return the change that was written. */
 export async function writeAsyncChange(provider, change) {
@@ -55,5 +55,5 @@ export async function writeAsyncChange(provider, change) {
 }
 /** Write a set of changes to an asynchronous provider. */
 export function writeAsyncChanges(provider, ...changes) {
-    return Promise.all(changes.filter(notOptional).map(change => writeAsyncChange(provider, change)));
+    return Promise.all(changes.filter(notNullish).map(change => writeAsyncChange(provider, change)));
 }

package/package.json

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

package/react/createDataContext.d.ts

@@ -4,14 +4,14 @@ import type { AbstractProvider } from "../db/Provider.js";
 import { QueryStore } from "../db/QueryStore.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { ItemQuery } from "../util/item.js";
-import type { Optional } from "../util/optional.js";
+import type { Nullish } from "../util/null.js";
 export interface DataContext<T extends Database> {
     /** Get an `ItemStore` for the specified collection item in the current `DataProvider` context and subscribe to any changes in it. */
     useItem<K extends DataKey<T>>(this: void, collection: K, id: string): ItemStore<T, K>;
-    useItem<K extends DataKey<T>>(this: void, collection: Optional<K>, id: Optional<string>): ItemStore<T, K> | undefined;
+    useItem<K extends DataKey<T>>(this: void, collection: Nullish<K>, id: Nullish<string>): ItemStore<T, K> | undefined;
     /** Get an `QueryStore` for the specified collection query in the current `DataProvider` context and subscribe to any changes in it. */
     useQuery<K extends DataKey<T>>(this: void, collection: K, query: ItemQuery<T[K]>): QueryStore<T, K>;
-    useQuery<K extends DataKey<T>>(this: void, collection: Optional<K>, query: Optional<ItemQuery<T[K]>>): QueryStore<T, K> | undefined;
+    useQuery<K extends DataKey<T>>(this: void, collection: Nullish<K>, query: Nullish<ItemQuery<T[K]>>): QueryStore<T, K> | undefined;
     readonly DataContext: ({ children }: {
         children: ReactNode;
     }) => ReactElement;

package/schema/DateSchema.d.ts

@@ -1,12 +1,12 @@
 import type { PossibleDate } from "../util/date.js";
-import type { Optional } from "../util/optional.js";
+import type { Nullish } from "../util/null.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `DateSchema` */
 export interface DateSchemaOptions extends SchemaOptions {
     readonly value?: PossibleDate | undefined;
-    readonly min?: Optional<PossibleDate> | undefined;
-    readonly max?: Optional<PossibleDate> | undefined;
+    readonly min?: Nullish<PossibleDate>;
+    readonly max?: Nullish<PossibleDate>;
 }
 /** Define a valid date in YMD format, e.g. `2005-09-12` */
 export declare class DateSchema extends Schema<string> {

package/schema/TimeSchema.d.ts

@@ -1,4 +1,4 @@
-import type { Optional } from "../util/optional.js";
+import type { Nullish } from "../util/null.js";
 import type { PossibleTime } from "../util/time.js";
 import { Time } from "../util/time.js";
 import type { SchemaOptions } from "./Schema.js";
@@ -6,8 +6,8 @@ import { Schema } from "./Schema.js";
 /** Allowed options for `TimeSchama` */
 export interface TimeSchemaOptions extends SchemaOptions {
     readonly value?: PossibleTime | undefined;
-    readonly min?: Optional<PossibleTime> | undefined;
-    readonly max?: Optional<PossibleTime> | undefined;
+    readonly min?: Nullish<PossibleTime>;
+    readonly max?: Nullish<PossibleTime>;
     readonly step?: number | undefined;
 }
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */

package/store/DataStore.d.ts

@@ -1,4 +1,5 @@
 import type { Data, DataKey } from "../util/data.js";
+import type { AnyCaller } from "../util/function.js";
 import type { Updates } from "../util/update.js";
 import { Store } from "./Store.js";
 /** Store a data object. */
@@ -22,12 +23,14 @@ export declare class OptionalDataStore<T extends Data> extends Store<T | undefin
     set data(data: T);
     /** Does the data exist or not? */
     get exists(): boolean;
+    /** Require the data for this data store, or throw `RequiredError` if it is not set. */
+    require(caller?: AnyCaller): T;
     /** Update several props in this data. */
     update(updates: Updates<T>): void;
     /** Update a single named prop in this data. */
-    getProp<K extends DataKey<T>>(name: K): T[K];
+    get<K extends DataKey<T>>(name: K): T[K];
     /** Update a single named prop in this data. */
-    setProp<K extends DataKey<T>>(name: K, value: T[K]): void;
+    set<K extends DataKey<T>>(name: K, value: T[K]): void;
     /** Set the data to `undefined`. */
-    unset(): void;
+    delete(): void;
 }

package/store/DataStore.js

@@ -1,5 +1,6 @@
+import { RequiredError } from "../error/RequiredError.js";
+import { getGetter } from "../util/class.js";
 import { withProp } from "../util/object.js";
-import { getRequired } from "../util/optional.js";
 import { updateData } from "../util/update.js";
 import { Store } from "./Store.js";
 /** Store a data object. */
@@ -29,7 +30,7 @@ export class DataStore extends Store {
 export class OptionalDataStore extends Store {
     /** Get current data value of this store (or throw `Promise` that resolves to the next required value). */
     get data() {
-        return getRequired(this.value);
+        return this.require(getGetter(this, "data"));
     }
     /** Set the data of this store. */
     set data(data) {
@@ -39,20 +40,27 @@ export class OptionalDataStore extends Store {
     get exists() {
         return !!this.value;
     }
+    /** Require the data for this data store, or throw `RequiredError` if it is not set. */
+    require(caller = this.require) {
+        const data = this.value;
+        if (!data)
+            throw new RequiredError("Data is empty", { caller });
+        return data;
+    }
     /** Update several props in this data. */
     update(updates) {
-        this.value = updateData(this.data, updates);
+        this.value = updateData(this.require(this.update), updates);
     }
     /** Update a single named prop in this data. */
-    getProp(name) {
-        return this.data[name];
+    get(name) {
+        return this.require(this.get)[name];
     }
     /** Update a single named prop in this data. */
-    setProp(name, value) {
-        this.value = withProp(this.data, name, value);
+    set(name, value) {
+        this.value = withProp(this.require(this.set), name, value);
     }
     /** Set the data to `undefined`. */
-    unset() {
+    delete() {
         this.value = undefined;
     }
 }

package/store/DictionaryStore.d.ts

@@ -9,11 +9,11 @@ export declare class DictionaryStore<T> extends Store<ImmutableDictionary<T>> im
     /** Set a named entry in this object with a different value. */
     update(updates: Updates<ImmutableDictionary<T>>): void;
     /** Remove a named entry from this object. */
-    delete(...keys: string[]): void;
+    deleteItems(...keys: string[]): void;
     /** Get an item in this dictionary. */
-    getItem(name: string): T | undefined;
+    get(name: string): T | undefined;
     /** Set an item in this dictionary. */
-    setItem(name: string, value: T): void;
+    set(name: string, value: T): void;
     /** Iterate over the entries of the object. */
     [Symbol.iterator](): Iterator<DictionaryItem<T>>;
 }

package/store/DictionaryStore.js

@@ -16,15 +16,15 @@ export class DictionaryStore extends Store {
         this.value = updateData(this.value, updates);
     }
     /** Remove a named entry from this object. */
-    delete(...keys) {
+    deleteItems(...keys) {
         this.value = omitDictionaryItems(this.value, ...keys);
     }
     /** Get an item in this dictionary. */
-    getItem(name) {
+    get(name) {
         return this.value[name];
     }
     /** Set an item in this dictionary. */
-    setItem(name, value) {
+    set(name, value) {
         this.value = withProp(this.value, name, value);
     }
     /** Iterate over the entries of the object. */

package/store/PathStore.d.ts

@@ -3,11 +3,12 @@ import { Store } from "./Store.js";
 /** Store an absolute path, e.g. `/a/b/c` */
 export declare class PathStore extends Store<AbsolutePath> {
     constructor(path?: string, time?: number);
+    get value(): AbsolutePath;
+    set value(path: string);
     /** Based on the current store path, is a path active? */
     isActive(path: AbsolutePath): boolean;
     /** Based on the current store path, is a path proud (i.e. a child of the current store path)? */
     isProud(path: AbsolutePath): boolean;
     /** Get an absolute path from a path relative to the current store path. */
     getPath(path: string): AbsolutePath;
-    set(path: string): void;
 }

package/store/PathStore.js

@@ -5,6 +5,13 @@ export class PathStore extends Store {
     constructor(path = ".", time) {
         super(requirePath(path), time);
     }
+    // Override to clean the path on set.
+    get value() {
+        return super.value;
+    }
+    set value(path) {
+        super.value = requirePath(path, super.value);
+    }
     /** Based on the current store path, is a path active? */
     isActive(path) {
         return isPathActive(this.value, path);
@@ -17,8 +24,4 @@ export class PathStore extends Store {
     getPath(path) {
         return requirePath(path, this.value);
     }
-    // Override to clean the path.
-    set(path) {
-        super.set(requirePath(path, this.value));
-    }
 }

package/store/Store.d.ts

@@ -36,8 +36,6 @@ export declare class Store<T> implements AsyncIterable<T> {
     private _starter;
     /** Store is initiated with an initial store. */
     constructor(value: T | typeof NONE, time?: number);
-    /** Set the value of the store. */
-    set(next: T): void;
     /** Set the value of the store as values are pulled from a sequence. */
     through(sequence: AsyncIterable<T>): AsyncIterable<T>;
     [Symbol.asyncIterator](): AsyncGenerator<T, void, void>;

package/store/Store.js

@@ -70,10 +70,6 @@ export class Store {
         this._value = value;
         this._time = time;
     }
-    /** Set the value of the store. */
-    set(next) {
-        this.value = next;
-    }
     /** Set the value of the store as values are pulled from a sequence. */
     async *through(sequence) {
         for await (const value of sequence) {

package/util/entity.d.ts

@@ -1,5 +1,5 @@
 import type { AnyCaller } from "./function.js";
-import type { Optional } from "./optional.js";
+import type { Nullish } from "./null.js";
 /** Entity strings combine a type and ID, e.g. `challenge:a1b2c3` */
 export type Entity<T extends string = string> = `${T}:${string}`;
 /** Extract the type from an `Entity` string. */
@@ -10,8 +10,8 @@ export type EmptyEntity = [type: undefined, id: undefined];
 export declare const EMPTY_ENTITY: EmptyEntity;
 /** Split an optional entity tag like `challenge:a1b2c3` into `["challenge", "a1b2c3"]`, or return `EmptyEntity` if the entity was invalid. */
 export declare function getEntity<T extends string>(entity: Entity<T>): [type: T, id: string];
-export declare function getEntity<T extends string>(entity: Optional<Entity<T>>): [type: T, id: string] | EmptyEntity;
-export declare function getEntity(entity: Optional<string>): [type: string, id: string] | EmptyEntity;
+export declare function getEntity<T extends string>(entity: Nullish<Entity<T>>): [type: T, id: string] | EmptyEntity;
+export declare function getEntity(entity: Nullish<string>): [type: string, id: string] | EmptyEntity;
 /** Split an entity tag like `challenge:a1b2c3` into `type` and `id`, or throw `RequiredError` if the entity tag was invalid. */
 export declare function requireEntity<T extends string>(entity: Entity<T>, caller?: AnyCaller): [type: T, id: string];
 export declare function requireEntity(entity: string, caller?: AnyCaller): [type: string, id: string];

package/util/error.d.ts

@@ -1,31 +1,23 @@
+import type { ImmutableDictionary } from "./dictionary.js";
+import type { AnyCaller } from "./function.js";
 /** Log an error to the console. */
 export declare function logError(reason: unknown): void;
 /** Is an unknown value an `Error` instance? */
 export declare function isError(v: unknown): v is Error & {
     readonly code?: string | undefined;
 };
+/** Things that can be a message. */
+export type PossibleMessage = {
+    message: string;
+} | string;
+/** Return the string message from an unknown value, or return `undefined` if it could not be found. */
+export declare function getMessage(input: unknown): string | undefined;
+/** Require a message from an unknown value, or throw `RequiredError` if it could not be found. */
+export declare function requireMessage(input: PossibleMessage, caller?: AnyCaller): string;
 /**
- * Extract the _main message(s)_ from a full error message string.
- *
- * - Error messages can have multiple lines separated by `\n` newline.
- * - Some lines may be _named messages_ in `name: This is a message` format.
- * - The _main_ message is any line(s) that is not a named message.
- *
- * @returns The combined main message(s) found in the full message string.
+ * Split a string message into lines, look for prefixes like `name:`, and return a dictionary of those named messages.
+ * - Full messages strings can have multiple lines separated by `\n` newline.
+ * - Named messages are extracted into their own entries in the dictionary.
+ * - Unnamed messages are combined into a single entry with the key `""` (empty string).
  */
-export declare function getMainMessage(fullMessage: string): string;
-/**
- * Extract the _named message(s)_ from a full error message string.
- *
- * - Error messages can have multiple lines separated by `\n` newline.
- * - Some lines may be _named messages_ in `name: This is a message` format.
- * - This function extracts any `name: This is a message` lines from the full message string.
- * - Note there may be multiple lines starting with `name:` (in the case where there were multiple errors with that name).
- * - This trims the `name: ` prefix from found messages and rejoins them with `\n` newline.
- *
- * @param fullMessage The full message string which may contain named messages in `name: This is a message` format.
- * @param name The name of the prop to extract the message for.
- *
- * @returns The combined message(s) for the named prop found in the full message string, or an empty string if no messages were found for that prop.
- */
-export declare function getNamedMessage(fullMessage: string, name: string | number): string;
+export declare function splitMessage(input: PossibleMessage): ImmutableDictionary<string>;

package/util/error.js

@@ -1,3 +1,5 @@
+import { RequiredError } from "../error/RequiredError.js";
+import { isObject } from "./object.js";
 /** Log an error to the console. */
 export function logError(reason) {
     console.error(reason);
@@ -6,40 +8,43 @@ export function logError(reason) {
 export function isError(v) {
     return typeof Error.isError === "function" ? Error.isError(v) : v instanceof Error;
 }
-/**
- * Extract the _main message(s)_ from a full error message string.
- *
- * - Error messages can have multiple lines separated by `\n` newline.
- * - Some lines may be _named messages_ in `name: This is a message` format.
- * - The _main_ message is any line(s) that is not a named message.
- *
- * @returns The combined main message(s) found in the full message string.
- */
-export function getMainMessage(fullMessage) {
-    let propMessages = "";
-    for (const [foundMessage] of fullMessage.matchAll(/^\s*(?!.*: )(.*?)\s*/g))
-        if (foundMessage)
-            propMessages = propMessages ? `${propMessages}\n${foundMessage}` : foundMessage;
-    return propMessages;
+/** Return the string message from an unknown value, or return `undefined` if it could not be found. */
+export function getMessage(input) {
+    return typeof input === "string" ? input : isObject(input) && typeof input.message === "string" ? input.message : undefined;
+}
+/** Require a message from an unknown value, or throw `RequiredError` if it could not be found. */
+export function requireMessage(input, caller = requireMessage) {
+    const message = getMessage(input);
+    if (message === undefined)
+        throw new RequiredError("Message is required", { received: input, caller });
+    return message;
 }
 /**
- * Extract the _named message(s)_ from a full error message string.
- *
- * - Error messages can have multiple lines separated by `\n` newline.
- * - Some lines may be _named messages_ in `name: This is a message` format.
- * - This function extracts any `name: This is a message` lines from the full message string.
- * - Note there may be multiple lines starting with `name:` (in the case where there were multiple errors with that name).
- * - This trims the `name: ` prefix from found messages and rejoins them with `\n` newline.
- *
- * @param fullMessage The full message string which may contain named messages in `name: This is a message` format.
- * @param name The name of the prop to extract the message for.
- *
- * @returns The combined message(s) for the named prop found in the full message string, or an empty string if no messages were found for that prop.
+ * Split a string message into lines, look for prefixes like `name:`, and return a dictionary of those named messages.
+ * - Full messages strings can have multiple lines separated by `\n` newline.
+ * - Named messages are extracted into their own entries in the dictionary.
+ * - Unnamed messages are combined into a single entry with the key `""` (empty string).
  */
-export function getNamedMessage(fullMessage, name) {
-    let namedMessages = "";
-    for (const [foundMessage] of fullMessage.matchAll(new RegExp(`^${name}: \s*(.*?)\s*$`, "g")))
-        if (foundMessage)
-            namedMessages = namedMessages ? `${namedMessages}\n${foundMessage}` : foundMessage;
-    return namedMessages;
+export function splitMessage(input) {
+    const messages = requireMessage(input, splitMessage).split("\n");
+    const output = {};
+    for (const line of messages) {
+        const i = line.indexOf(": ");
+        if (i >= 0) {
+            const name = line.slice(0, i).trim();
+            const message = line.slice(i + 2).trim();
+            if (Object.hasOwn(output, name))
+                output[name] += `\n${message}`;
+            else
+                output[name] = message;
+        }
+        else {
+            const message = line.trim();
+            if (Object.hasOwn(output, ""))
+                output[""] += `\n${message}`;
+            else
+                output[""] = message;
+        }
+    }
+    return output;
 }

package/util/index.d.ts

@@ -39,7 +39,6 @@ export * from "./merge.js";
 export * from "./null.js";
 export * from "./number.js";
 export * from "./object.js";
-export * from "./optional.js";
 export * from "./path.js";
 export * from "./query.js";
 export * from "./random.js";

package/util/index.js

@@ -39,7 +39,6 @@ export * from "./merge.js";
 export * from "./null.js";
 export * from "./number.js";
 export * from "./object.js";
-export * from "./optional.js";
 export * from "./path.js";
 export * from "./query.js";
 export * from "./random.js";

package/util/link.d.ts

@@ -1,6 +1,6 @@
 import type { ImmutableArray } from "./array.js";
 import type { AnyCaller } from "./function.js";
-import type { Optional } from "./optional.js";
+import type { Nullish } from "./null.js";
 import type { Path } from "./path.js";
 import { type PossibleURL } from "./url.js";
 /**
@@ -53,7 +53,7 @@ export declare function isLinkURL(value: unknown, schemes?: LinkSchemes, hosts?:
  * Convert a possible URL to a link URL, or return `undefined` if conversion fails.
  * - A valid link URL is a `URL` instance with a scheme matching the `schemes` array, and `host` matching the optional `hosts` array.
  */
-export declare function getLinkURL(value: Optional<PossibleURL>, base?: AbsoluteLinkURL | AbsoluteLink, schemes?: LinkSchemes, hosts?: LinkHosts): AbsoluteLinkURL | undefined;
+export declare function getLinkURL(value: Nullish<PossibleURL>, base?: AbsoluteLinkURL | AbsoluteLink, schemes?: LinkSchemes, hosts?: LinkHosts): AbsoluteLinkURL | undefined;
 /**
  * Convert a possible URL to a link URL, or throw `RequiredError` if conversion fails.
  * - A valid link URL is a `URL` instance with a scheme matching the `schemes` array, and `host` matching the optional `hosts` array.
@@ -63,7 +63,7 @@ export declare function requireLinkURL(value: PossibleURL, base?: AbsoluteLinkUR
  * Convert a possible URL to an link URL string, or return `undefined` if conversion fails.
  * - A valid link URL string is an absolute URL string with a scheme matching the `schemes` array, and `host` matching the optional `hosts` array.
  */
-export declare function getLink(value: Optional<PossibleURL>, base?: AbsoluteLinkURL | AbsoluteLink, schemes?: LinkSchemes, hosts?: LinkHosts): AbsoluteLink | undefined;
+export declare function getLink(value: Nullish<PossibleURL>, base?: AbsoluteLinkURL | AbsoluteLink, schemes?: LinkSchemes, hosts?: LinkHosts): AbsoluteLink | undefined;
 /**
  * Convert a possible URL to an link URL string, or throw `RequiredError` if conversion fails.
  * - A valid link URL string is an absolute URL string with a scheme matching the `schemes` array, and `host` matching the optional `hosts` array.

package/util/path.d.ts

@@ -1,5 +1,5 @@
 import type { AnyCaller } from "./function.js";
-import { type Optional } from "./optional.js";
+import { type Nullish } from "./null.js";
 /** Absolute path string starts with `/` slash. */
 export type AbsolutePath = `/` | `/${string}`;
 /** Relative path string starts with `./` or `../` */
@@ -19,7 +19,7 @@ export declare function isRelativePath(path: string): path is RelativePath;
  * @param base Absolute path used for resolving relative paths in `possible`
  * @return Absolute path with a leading trailing slash, e.g. `/a/c/b`
  */
-export declare function getPath(value: Optional<string | URL>, base?: AbsolutePath | undefined): AbsolutePath | undefined;
+export declare function getPath(value: Nullish<string | URL>, base?: AbsolutePath | undefined): AbsolutePath | undefined;
 /**
  * Resolve a relative or absolute path and return the path, or throw `RequiredError` if not a valid path.
  * - Internally uses `new URL` to do path processing but shouldn't ever reveal that fact.

package/util/path.js

@@ -1,5 +1,5 @@
 import { RequiredError } from "../error/RequiredError.js";
-import { notOptional } from "./optional.js";
+import { notNullish } from "./null.js";
 /** Is a string path an absolute path? */
 export function isAbsolutePath(path) {
     return path.startsWith("/");
@@ -23,7 +23,7 @@ function _cleanPath(path) {
  * @return Absolute path with a leading trailing slash, e.g. `/a/c/b`
  */
 export function getPath(value, base = "/") {
-    if (notOptional(value)) {
+    if (notNullish(value)) {
         try {
             const { pathname, search, hash } = new URL(value, `http://j.com${base}/`);
             if (isAbsolutePath(pathname))

package/util/string.d.ts

@@ -101,3 +101,7 @@ export declare function splitString(str: string, separator: string, min: 2, max?
 export declare function splitString(str: string, separator: string, min: 3, max?: number, caller?: AnyCaller): readonly [string, string, string, ...string[]];
 export declare function splitString(str: string, separator: string, min: 4, max?: number, caller?: AnyCaller): readonly [string, string, string, string, ...string[]];
 export declare function splitString(str: string, separator: string, min?: number, max?: number, caller?: AnyCaller): ImmutableArray<string>;
+/** Trim a string (as a function, so it can be used in mapping. */
+export declare function trimString(str: string): string;
+/** Does a string have length? */
+export declare function isNonEmptyString(str: string): boolean;

package/util/string.js

@@ -167,3 +167,11 @@ export function splitString(str, separator, min = 1, max = Number.POSITIVE_INFIN
         });
     return segments;
 }
+/** Trim a string (as a function, so it can be used in mapping. */
+export function trimString(str) {
+    return str.trim();
+}
+/** Does a string have length? */
+export function isNonEmptyString(str) {
+    return str.length > 0;
+}

package/util/url.d.ts

@@ -1,5 +1,5 @@
 import type { AnyCaller } from "./function.js";
-import { type Optional } from "./optional.js";
+import { type Nullish } from "./null.js";
 /** Values that can be converted to a URL instance. */
 export type PossibleURL = string | URL;
 /** Is an unknown value a URL object? */
@@ -7,6 +7,6 @@ export declare function isURL(value: unknown): value is URL;
 /** Assert that an unknown value is a URL object. */
 export declare function assertURL(value: unknown, caller?: AnyCaller): asserts value is URL;
 /** Convert a possible URL to a URL, or return `undefined` if conversion fails. */
-export declare function getURL(possible: Optional<PossibleURL>, base?: PossibleURL | undefined): URL | undefined;
+export declare function getURL(possible: Nullish<PossibleURL>, base?: PossibleURL | undefined): URL | undefined;
 /** Convert a possible URL to a URL, or throw `RequiredError` if conversion fails. */
 export declare function requireURL(possible: PossibleURL, base?: PossibleURL, caller?: AnyCaller): URL;

package/util/url.js

@@ -1,5 +1,5 @@
 import { RequiredError } from "../error/RequiredError.js";
-import { notOptional } from "./optional.js";
+import { notNullish } from "./null.js";
 /** Is an unknown value a URL object? */
 export function isURL(value) {
     return value instanceof URL;
@@ -11,7 +11,7 @@ export function assertURL(value, caller = assertURL) {
 }
 /** Convert a possible URL to a URL, or return `undefined` if conversion fails. */
 export function getURL(possible, base = _BASE) {
-    if (notOptional(possible)) {
+    if (notNullish(possible)) {
         try {
             return isURL(possible) ? possible : new URL(possible, base);
         }

package/util/optional.d.ts

@@ -1,7 +0,0 @@
-import type { AnyCaller } from "./function.js";
-/** Optional is the value or `null` or `undefined` (synonym for `Nullish`). */
-export type Optional<T> = T | null | undefined;
-/** Get a required value. */
-export declare function getRequired<T>(value: Optional<T>, caller?: AnyCaller): T;
-/** Is a value not optional? */
-export declare function notOptional<T>(value: Optional<T>): value is T;

package/util/optional.js

@@ -1,11 +0,0 @@
-import { RequiredError } from "../error/RequiredError.js";
-/** Get a required value. */
-export function getRequired(value, caller = getRequired) {
-    if (value === null || value === undefined)
-        throw new RequiredError("Value is required", { received: value, caller });
-    return value;
-}
-/** Is a value not optional? */
-export function notOptional(value) {
-    return value !== null && value !== undefined;
-}