shelving 1.165.0 → 1.167.0

package/api/Endpoint.d.ts

@@ -1,26 +1,33 @@
 import { type Schema } from "../schema/Schema.js";
-import type { AbsolutePath } from "../util/path.js";
+import type { AnyCaller } from "../util/function.js";
+import type { AbsoluteLink } from "../util/link.js";
 import type { EndpointCallback, EndpointHandler } from "./util.js";
-/** Types for an HTTP request or response that does something. */
-export type EndpointMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+/** HTTP request methods. */
+export type EndpointMethod = EndpointBodyMethod | EndpointHeadMethod;
+/** HTTP request methods that have no body. */
+export type EndpointHeadMethod = "HEAD" | "GET";
+/** HTTP request methods that have a body. */
+export type EndpointBodyMethod = "POST" | "PUT" | "PATCH" | "DELETE";
+/** Configurable options for endpoint. */
+export type EndpointOptions = Omit<RequestInit, "method" | "body">;
 /**
  * An abstract API resource definition, used to specify types for e.g. serverless functions.
  *
- * @param method The method of the resource, e.g. `GET`
- * @param path The path of the resource optionally including `{placeholder}` values, e.g. `/patient/{id}`
- * @param payload A `Schema` for the payload of the resource.
- * @param result A `Schema` for the result of the resource.
+ * @param method The method of the endpoint, e.g. `GET`
+ * @param url Endpoint URL, possibly including placeholders e.g. `https://api.mysite.com/users/{id}`
+ * @param payload A `Schema` for the payload of the endpoint.
+ * @param result A `Schema` for the result of the endpoint.
  */
 export declare class Endpoint<P, R> {
     /** Endpoint method. */
     readonly method: EndpointMethod;
-    /** Endpoint path, e.g. `/patient/{id}` */
-    readonly path: AbsolutePath;
-    /** Payload validator. */
+    /** Endpoint URL, possibly including placeholders e.g. `https://api.mysite.com/users/{id}` */
+    readonly url: AbsoluteLink;
+    /** Payload schema. */
     readonly payload: Schema<P>;
-    /** Result validator. */
+    /** Result schema. */
     readonly result: Schema<R>;
-    constructor(method: EndpointMethod, path: AbsolutePath, payload: Schema<P>, result: Schema<R>);
+    constructor(method: EndpointMethod, url: AbsoluteLink, payload: Schema<P>, result: Schema<R>);
     /**
      * Return an `EndpointHandler` for this endpoint.
      *
@@ -35,7 +42,36 @@ export declare class Endpoint<P, R> {
      * @param request The entire HTTP request that is being handled (payload was possibly extracted from this somehow).
      */
     handle(callback: EndpointCallback<P, R>, unsafePayload: unknown, request: Request): Promise<Response>;
-    /** Convert to string, e.g. `GET /user/{id}` */
+    /**
+     * Render the URL for this endpoint with the given payload.
+     * - URL mioght contain `{placeholder}` values that are replaced with values from the payload.
+     */
+    renderURL(payload: P, caller?: AnyCaller): string;
+    /**
+     * Get an HTTP `Request` object for this endpoint.
+     * - Validates a payload against this endpoints payload schema
+     * - Return an HTTP `Request` that will send it the valid payload to this endpoint.
+     *
+     * @throws Feedback if the payload is invalid.
+     */
+    request(payload: P, options?: EndpointOptions, caller?: AnyCaller): Request;
+    /**
+     * Validate an HTTP `Response` against this endpoint.
+     * @throws ResponseError if the response status is not ok (200-299)
+     * @throws ResponseError if the response content is invalid.
+     */
+    response(response: Response, caller?: AnyCaller): Promise<R>;
+    /**
+     * Perform a fetch to this endpoint.
+     * - Validate the `payload` against this endpoint's payload schema.
+     * - Validate the returned response against this endpoint's result schema.
+     *
+     * @throws Feedback if the payload is invalid.
+     * @throws ResponseError if the response status is not ok (200-299)
+     * @throws ResponseError if the response content is invalid.
+     */
+    fetch(payload: P, options?: EndpointOptions, caller?: AnyCaller): Promise<R>;
+    /** Convert to string, e.g. `GET https://a.com/user/{id}` */
     toString(): string;
 }
 /** Extract the payload type from a `Endpoint`. */
@@ -43,37 +79,37 @@ export type PayloadType<X extends Endpoint<unknown, unknown>> = X extends Endpoi
 /** Extract the result type from a `Endpoint`. */
 export type EndpointType<X extends Endpoint<unknown, unknown>> = X extends Endpoint<unknown, infer Y> ? Y : never;
 /**
- * Represent a GET request to a specified path, with validated payload and return types.
+ * Represent a GET request to a specified URL, with validated payload and return types.
  * "The GET method requests a representation of the specified resource. Requests using GET should only retrieve data and should not contain a request content."
  */
-export declare function GET<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
-export declare function GET<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
-export declare function GET<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
+export declare function GET<P, R>(url: AbsoluteLink, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function GET<P>(url: AbsoluteLink, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function GET<R>(url: AbsoluteLink, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
- * Represent a POST request to a specified path, with validated payload and return types.
+ * Represent a POST request to a specified URL, with validated payload and return types.
  * "The POST method submits an entity to the specified resource, often causing a change in state or side effects on the server.
  */
-export declare function POST<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
-export declare function POST<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
-export declare function POST<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
+export declare function POST<P, R>(url: AbsoluteLink, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function POST<P>(url: AbsoluteLink, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function POST<R>(url: AbsoluteLink, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
- * Represent a PUT request to a specified path, with validated payload and return types.
+ * Represent a PUT request to a specified URL, with validated payload and return types.
  * "The PUT method replaces all current representations of the target resource with the request content."
  */
-export declare function PUT<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
-export declare function PUT<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
-export declare function PUT<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
+export declare function PUT<P, R>(url: AbsoluteLink, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function PUT<P>(url: AbsoluteLink, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function PUT<R>(url: AbsoluteLink, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
- * Represent a PATCH request to a specified path, with validated payload and return types.
+ * Represent a PATCH request to a specified URL, with validated payload and return types.
  * "The PATCH method applies partial modifications to a resource."
  */
-export declare function PATCH<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
-export declare function PATCH<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
-export declare function PATCH<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
+export declare function PATCH<P, R>(url: AbsoluteLink, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function PATCH<P>(url: AbsoluteLink, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function PATCH<R>(url: AbsoluteLink, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
- * Represent a DELETE request to a specified path, with validated payload and return types.
+ * Represent a DELETE request to a specified URL, with validated payload and return types.
  * "The DELETE method deletes the specified resource."
  */
-export declare function DELETE<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
-export declare function DELETE<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
-export declare function DELETE<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
+export declare function DELETE<P, R>(url: AbsoluteLink, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function DELETE<P>(url: AbsoluteLink, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function DELETE<R>(url: AbsoluteLink, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;

package/api/Endpoint.js

@@ -1,26 +1,31 @@
+import { ResponseError } from "../error/ResponseError.js";
 import { UNDEFINED } from "../schema/Schema.js";
-import { getResponse } from "../util/http.js";
+import { assertDictionary } from "../util/dictionary.js";
+import { getMessage } from "../util/error.js";
+import { getResponse, getResponseContent } from "../util/http.js";
+import { getPlaceholders, renderTemplate } from "../util/template.js";
+import { omitURLParams, withURLParams } from "../util/url.js";
 import { getValid } from "../util/validate.js";
 /**
  * An abstract API resource definition, used to specify types for e.g. serverless functions.
  *
- * @param method The method of the resource, e.g. `GET`
- * @param path The path of the resource optionally including `{placeholder}` values, e.g. `/patient/{id}`
- * @param payload A `Schema` for the payload of the resource.
- * @param result A `Schema` for the result of the resource.
+ * @param method The method of the endpoint, e.g. `GET`
+ * @param url Endpoint URL, possibly including placeholders e.g. `https://api.mysite.com/users/{id}`
+ * @param payload A `Schema` for the payload of the endpoint.
+ * @param result A `Schema` for the result of the endpoint.
  */
 export class Endpoint {
     /** Endpoint method. */
     method;
-    /** Endpoint path, e.g. `/patient/{id}` */
-    path;
-    /** Payload validator. */
+    /** Endpoint URL, possibly including placeholders e.g. `https://api.mysite.com/users/{id}` */
+    url;
+    /** Payload schema. */
     payload;
-    /** Result validator. */
+    /** Result schema. */
     result;
-    constructor(method, path, payload, result) {
+    constructor(method, url, payload, result) {
         this.method = method;
-        this.path = path;
+        this.url = url;
         this.payload = payload;
         this.result = result;
     }
@@ -49,23 +54,142 @@ export class Endpoint {
         // Convert the result to a `Response` object.
         return getResponse(result);
     }
-    /** Convert to string, e.g. `GET /user/{id}` */
+    /**
+     * Render the URL for this endpoint with the given payload.
+     * - URL mioght contain `{placeholder}` values that are replaced with values from the payload.
+     */
+    renderURL(payload, caller = this.renderURL) {
+        const { url } = this;
+        // URL has `{placeholders}` to render.
+        const placeholders = getPlaceholders(url);
+        if (placeholders.length) {
+            assertDictionary(payload, caller);
+            return renderTemplate(url, payload, caller);
+        }
+        // URL has no `{placeholders}`
+        return url;
+    }
+    /**
+     * Get an HTTP `Request` object for this endpoint.
+     * - Validates a payload against this endpoints payload schema
+     * - Return an HTTP `Request` that will send it the valid payload to this endpoint.
+     *
+     * @throws Feedback if the payload is invalid.
+     */
+    request(payload, options = {}, caller = this.request) {
+        return createRequest(this.method, this.url, this.payload.validate(payload), options, caller);
+    }
+    /**
+     * Validate an HTTP `Response` against this endpoint.
+     * @throws ResponseError if the response status is not ok (200-299)
+     * @throws ResponseError if the response content is invalid.
+     */
+    async response(response, caller = this.response) {
+        // Get the response.
+        const { ok, status } = response;
+        const content = await getResponseContent(response, caller);
+        // Throw `ResponseError` if the API returns status outside the 200-299 range.
+        if (!ok)
+            throw new ResponseError(getMessage(content) ?? `Error ${status}`);
+        // Validate the success response.
+        return getValid(content, this.result, ResponseError, caller);
+    }
+    /**
+     * Perform a fetch to this endpoint.
+     * - Validate the `payload` against this endpoint's payload schema.
+     * - Validate the returned response against this endpoint's result schema.
+     *
+     * @throws Feedback if the payload is invalid.
+     * @throws ResponseError if the response status is not ok (200-299)
+     * @throws ResponseError if the response content is invalid.
+     */
+    async fetch(payload, options = {}, caller = this.fetch) {
+        const response = await fetch(this.request(payload, options, caller));
+        return this.response(response, caller);
+    }
+    /** Convert to string, e.g. `GET https://a.com/user/{id}` */
     toString() {
-        return `${this.method} ${this.path}`;
+        return `${this.method} ${this.url}`;
+    }
+}
+export function GET(url, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("GET", url, payload, result);
+}
+export function POST(url, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("POST", url, payload, result);
+}
+export function PUT(url, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("PUT", url, payload, result);
+}
+export function PATCH(url, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("PATCH", url, payload, result);
+}
+export function DELETE(url, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("DELETE", url, payload, result);
+}
+/**
+ * Create a `Request` instance for a method/url and payload.
+ *
+ * - If `{placeholders}` are set in the URL, they are replaced by values from payload (will throw if `payload` is not a dictionary object).
+ * - If the method is `HEAD` or `GET`, the payload is sent as `?query` parameters in the URL.
+ * - If the method is anything else, the payload is sent in the body (either as JSON, string, or `FormData`).
+ *
+ * @throws ValueError if this is a `HEAD` or `GET` request but `body` is not a dictionary object.
+ * @throws ValueError if `{placeholders}` are set in the URL but `body` is not a dictionary object.
+ */
+function createRequest(method, url, payload, options = {}, caller = createRequest) {
+    // This is a head request, so ensure the payload is a dictionary object.
+    if (method === "GET" || method === "HEAD") {
+        assertDictionary(payload, caller);
+        return createHeadRequest(method, url, payload, options, caller);
     }
+    // This is a normal body request.
+    return createBodyRequest(method, url, payload, options, caller);
 }
-export function GET(path, payload = UNDEFINED, result = UNDEFINED) {
-    return new Endpoint("GET", path, payload, result);
+/**
+ * Create a body-less request to a URL.
+ * - Any `{placeholders}` in the URL will be rendered with values from `params`, and won't be set in `?query` parameters in the URL.
+ */
+function createHeadRequest(method, url, params, options = {}, caller = createHeadRequest) {
+    const placeholders = getPlaceholders(url);
+    // URL has `{placeholders}` to render, so rendere those to the URL and add all other params as `?query` params.
+    if (placeholders.length) {
+        const rendered = omitURLParams(withURLParams(renderTemplate(url, params, caller), params, caller), ...placeholders);
+        return new Request(rendered, { ...options, method });
+    }
+    // URL has no `{placeholders}`, so add all payload params to the URL.
+    return new Request(withURLParams(url, params, caller), { ...options, method });
 }
-export function POST(path, payload = UNDEFINED, result = UNDEFINED) {
-    return new Endpoint("POST", path, payload, result);
+/**
+ * Create a body request to a URL.
+ * - Any `{placeholders}` in the URL will be rendered with values from `data`, and won't be set in the request body.
+ * - The payload is sent in the body (either as JSON, string, or `FormData`).
+ *
+ * @throws ValueError if `{placeholders}` are set in the URL but `body` is not a dictionary object.
+ */
+function createBodyRequest(method, url, body, options = {}, caller = createBodyRequest) {
+    const placeholders = getPlaceholders(url);
+    // If `{placeholders}` are set in the URL then body must be a dictionary object and is sent as JSON.
+    if (placeholders.length) {
+        assertDictionary(body, caller);
+        return createJSONRequest(method, url, body, options);
+    }
+    // `FormData` instances pass through unaltered and will set their own `Content-Type` with complex boundary information.
+    if (body instanceof FormData)
+        return createFormDataRequest(method, url, body, options);
+    if (typeof body === "string")
+        return createTextRequest(method, url, body, options);
+    return createJSONRequest(method, url, body, options); // JSON is the default.
 }
-export function PUT(path, payload = UNDEFINED, result = UNDEFINED) {
-    return new Endpoint("PUT", path, payload, result);
+/** Create a `FormData` request to a URL. */
+function createFormDataRequest(method, url, body, options = {}) {
+    return new Request(url, { ...options, method, body });
 }
-export function PATCH(path, payload = UNDEFINED, result = UNDEFINED) {
-    return new Endpoint("PATCH", path, payload, result);
+/** Create a plain text request to a URL. */
+function createTextRequest(method, url, body, { headers, ...options } = {}) {
+    return new Request(url, { ...options, headers: { ...headers, "Content-Type": "text/plain" }, method, body });
 }
-export function DELETE(path, payload = UNDEFINED, result = UNDEFINED) {
-    return new Endpoint("DELETE", path, payload, result);
+/** Create a JSON request to a URL. */
+function createJSONRequest(method, url, body, { headers, ...options } = {}) {
+    return new Request(url, { ...options, headers: { ...headers, "Content-Type": "application/json" }, method, body: JSON.stringify(body) });
 }

package/api/util.js

@@ -20,7 +20,7 @@ export function handleEndpoints(request, endpoints) {
     const url = getURL(requestUrl);
     if (!url)
         throw new RequestError("Invalid request URL", { received: requestUrl, caller: handleEndpoints });
-    const { pathname, searchParams } = url;
+    const { origin, pathname, searchParams } = url;
     // Iterate over the handlers and return the first one that matches the request.
     for (const { endpoint, callback } of endpoints) {
         // Ensure the request method e.g. `GET`, does not match the endpoint method e.g. `POST`
@@ -28,7 +28,7 @@ export function handleEndpoints(request, endpoints) {
             continue;
         // Ensure the request URL e.g. `/user/123` matches the endpoint path e.g. `/user/{id}`
         // Any `{placeholders}` in the endpoint path are matched against the request URL to extract parameters.
-        const pathParams = matchTemplate(endpoint.path, pathname, handleEndpoints);
+        const pathParams = matchTemplate(endpoint.url, `${origin}${pathname}`, handleEndpoints);
         if (!pathParams)
             continue;
         // Make a simple dictionary object from the `{placeholder}` path params and the `?a=123` query params from the URL.

package/package.json

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

package/util/dictionary.d.ts

@@ -20,7 +20,8 @@ export declare function assertDictionary(value: unknown, caller?: AnyCaller): as
 /** Convert a possible dictionary into a dictionary. */
 export declare function getDictionary<T>(dict: PossibleDictionary<T>): ImmutableDictionary<T>;
 /** Turn a dictionary object into a set of props. */
-export declare function getDictionaryItems<T>(dict: ImmutableDictionary<T>): readonly DictionaryItem<T>[];
+export declare function getDictionaryItems<T>(input: ImmutableDictionary<T>): readonly DictionaryItem<T>[];
+export declare function getDictionaryItems<T>(input: PossibleDictionary<T>): Iterable<DictionaryItem<T>>;
 /** Is an unknown value the key for an own prop of a dictionary. */
 export declare function isDictionaryItem<T>(dict: ImmutableDictionary<T>, key: unknown): key is string;
 /** Assert that an unknown value is the key for an own prop of a dictionary. */

package/util/dictionary.js

@@ -1,5 +1,6 @@
 import { RequiredError } from "../error/RequiredError.js";
 import { ValueError } from "../error/ValueError.js";
+import { isIterable } from "./iterate.js";
 import { deleteProps, isPlainObject, omitProps, pickProps, setProp, setProps, withProp, withProps } from "./object.js";
 /** Is an unknown value a dictionary object? */
 export function isDictionary(value) {
@@ -14,9 +15,8 @@ export function assertDictionary(value, caller = assertDictionary) {
 export function getDictionary(dict) {
     return isDictionary(dict) ? dict : Object.fromEntries(dict);
 }
-/** Turn a dictionary object into a set of props. */
-export function getDictionaryItems(dict) {
-    return Object.entries(dict);
+export function getDictionaryItems(input) {
+    return isIterable(input) ? input : Object.entries(input);
 }
 /** Is an unknown value the key for an own prop of a dictionary. */
 export function isDictionaryItem(dict, key) {

package/util/template.d.ts

@@ -1,6 +1,6 @@
 import type { ImmutableArray } from "./array.js";
 import { type ImmutableDictionary } from "./dictionary.js";
-import type { AnyCaller } from "./function.js";
+import { type AnyCaller } from "./function.js";
 import { type NotString, type PossibleString } from "./string.js";
 /**
  * Things that can be converted to the value for a named placeholder.
@@ -10,7 +10,7 @@ import { type NotString, type PossibleString } from "./string.js";
  * `ImmutableDictionary<PossibleString>` — Object containing named strings used for named placeholders, e.g. `{ val1: "Ellie", val2: 123 }`
  * `(placeholder: string) => string` — Function that returns the right string for a named `{placeholder}`.v
  */
-export type TemplateValues = PossibleString | ImmutableArray<PossibleString> | ImmutableDictionary<PossibleString> | ((placeholder: string) => string);
+export type TemplateValues = PossibleString | ImmutableArray<unknown> | ImmutableDictionary<unknown> | ((placeholder: string) => string);
 /** The output of matching a template is a dictionary in `{ myPlaceholder: "value" }` format. */
 export type TemplateMatches = ImmutableDictionary<string>;
 /**

package/util/template.js

@@ -1,6 +1,7 @@
 import { RequiredError } from "../error/RequiredError.js";
 import { ValueError } from "../error/ValueError.js";
 import { EMPTY_DICTIONARY } from "./dictionary.js";
+import { isFunction } from "./function.js";
 import { setMapItem } from "./map.js";
 import { isObject } from "./object.js";
 import { getString } from "./string.js";
@@ -118,7 +119,7 @@ export function renderTemplate(template, values, caller = renderTemplate) {
     return output;
 }
 function _replaceTemplateKey(key, values, caller) {
-    if (typeof values === "function")
+    if (isFunction(values))
         return values(key);
     if (isObject(values)) {
         // Dictionary or array of values.
@@ -132,5 +133,5 @@ function _replaceTemplateKey(key, values, caller) {
         if (v !== undefined)
             return v;
     }
-    throw new RequiredError(`Template key "${key}" must be defined`, { received: values, key, caller });
+    throw new RequiredError(`Template value for "${key}" must be string`, { received: values, key, caller });
 }

package/util/url.d.ts

@@ -1,4 +1,3 @@
-import { type Data } from "./data.js";
 import type { DictionaryItem, ImmutableDictionary } from "./dictionary.js";
 import type { AnyCaller } from "./function.js";
 import { type Nullish } from "./null.js";
@@ -15,7 +14,7 @@ export declare function requireURL(possible: PossibleURL, base?: PossibleURL, ca
 /** Type for a set of named URL parameters. */
 export type URLParams = ImmutableDictionary<string>;
 /** Type for things that can be converted to named URL parameters. */
-export type PossibleURLParams = PossibleURL | URLSearchParams | Data | Iterable<DictionaryItem<unknown>>;
+export type PossibleURLParams = PossibleURL | URLSearchParams | ImmutableDictionary<unknown>;
 /**
  * Get a set of entries for a set of possible URL params.
  *

package/util/url.js

@@ -1,20 +1,8 @@
 import { RequiredError } from "../error/RequiredError.js";
 import { ValueError } from "../error/ValueError.js";
-import { isData } from "./data.js";
+import { getDictionaryItems, isDictionary } from "./dictionary.js";
 import { notNullish } from "./null.js";
-import { getProps } from "./object.js";
 import { getString, isString } from "./string.js";
-function parseURL(value, base) {
-    const ctor = URL;
-    if (typeof ctor.parse === "function")
-        return ctor.parse(value, base);
-    try {
-        return new URL(value, base);
-    }
-    catch {
-        return null;
-    }
-}
 /** Is an unknown value a URL object? */
 export function isURL(value) {
     return value instanceof URL;
@@ -26,8 +14,16 @@ 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 (notNullish(possible))
-        return isURL(possible) ? possible : parseURL(possible, base) || undefined;
+    if (notNullish(possible)) {
+        if (isURL(possible))
+            return possible;
+        try {
+            return new URL(possible, base);
+        }
+        catch {
+            return undefined;
+        }
+    }
 }
 const _BASE = typeof document === "object" ? document.baseURI : undefined;
 /** Convert a possible URL to a URL, or throw `RequiredError` if conversion fails. */
@@ -53,7 +49,7 @@ export function* getURLEntries(input, caller = getURLParams) {
     }
     else {
         const done = [];
-        for (const [key, value] of getProps(input)) {
+        for (const [key, value] of getDictionaryItems(input)) {
             if (done.includes(key))
                 continue;
             done.push(key);
@@ -75,7 +71,7 @@ export function getURLParams(input, caller = getURLParams) {
 export function getURLParam(input, key) {
     if (input instanceof URLSearchParams)
         return input.get(key) || undefined;
-    if (isData(input))
+    if (isDictionary(input))
         return getString(input[key]);
     return getURLParams(input)[key];
 }