@fedify/fedify 2.0.0-pr.433.1601 → 2.0.0-pr.434.1659

package/dist/docloader-D-MrRyHl.d.cts

@@ -0,0 +1,219 @@
+import { KvKey, KvStore } from "./kv-63Cil1MD.cjs";
+
+//#region src/runtime/docloader.d.ts
+/**
+ * A remote JSON-LD document and its context fetched by
+ * a {@link DocumentLoader}.
+ */
+interface RemoteDocument {
+  /**
+   * The URL of the context document.
+   */
+  contextUrl: string | null;
+  /**
+   * The fetched JSON-LD document.
+   */
+  document: unknown;
+  /**
+   * The URL of the fetched document.
+   */
+  documentUrl: string;
+}
+/**
+ * Options for {@link DocumentLoader}.
+ * @since 1.8.0
+ */
+interface DocumentLoaderOptions {
+  /**
+   * An `AbortSignal` for cancellation.
+   * @since 1.8.0
+   */
+  signal?: AbortSignal;
+}
+/**
+ * A JSON-LD document loader that fetches documents from the Web.
+ * @param url The URL of the document to load.
+ * @param options The options for the document loader.
+ * @returns The loaded remote document.
+ */
+type DocumentLoader = (url: string, options?: DocumentLoaderOptions) => Promise<RemoteDocument>;
+/**
+ * A factory function that creates a {@link DocumentLoader} with options.
+ * @param options The options for the document loader.
+ * @returns The document loader.
+ * @since 1.4.0
+ */
+type DocumentLoaderFactory = (options?: DocumentLoaderFactoryOptions) => DocumentLoader;
+/**
+ * Options for {@link DocumentLoaderFactory}.
+ * @see {@link DocumentLoaderFactory}
+ * @see {@link AuthenticatedDocumentLoaderFactory}
+ * @since 1.4.0
+ */
+interface DocumentLoaderFactoryOptions {
+  /**
+   * Whether to allow fetching private network addresses.
+   * Turned off by default.
+   * @default `false``
+   */
+  allowPrivateAddress?: boolean;
+  /**
+   * Options for making `User-Agent` string.
+   * If a string is given, it is used as the `User-Agent` header value.
+   * If an object is given, it is passed to {@link getUserAgent} function.
+   */
+  userAgent?: GetUserAgentOptions | string;
+}
+/**
+ * A factory function that creates an authenticated {@link DocumentLoader} for
+ * a given identity.  This is used for fetching documents that require
+ * authentication.
+ * @param identity The identity to create the document loader for.
+ *                 The actor's key pair.
+ * @param options The options for the document loader.
+ * @returns The authenticated document loader.
+ * @since 0.4.0
+ */
+type AuthenticatedDocumentLoaderFactory = (identity: {
+  keyId: URL;
+  privateKey: CryptoKey;
+}, options?: DocumentLoaderFactoryOptions) => DocumentLoader;
+/**
+ * Error thrown when fetching a JSON-LD document failed.
+ */
+declare class FetchError extends Error {
+  /**
+   * The URL that failed to fetch.
+   */
+  url: URL;
+  /**
+   * Constructs a new `FetchError`.
+   *
+   * @param url The URL that failed to fetch.
+   * @param message Error message.
+   */
+  constructor(url: URL | string, message?: string);
+}
+/**
+ * Options for creating a request.
+ * @internal
+ */
+
+/**
+ * Options for {@link getDocumentLoader}.
+ * @since 1.3.0
+ */
+interface GetDocumentLoaderOptions extends DocumentLoaderFactoryOptions {
+  /**
+   * Whether to preload the frequently used contexts.
+   */
+  skipPreloadedContexts?: boolean;
+}
+/**
+ * Creates a JSON-LD document loader that utilizes the browser's `fetch` API.
+ *
+ * The created loader preloads the below frequently used contexts by default
+ * (unless `options.ignorePreloadedContexts` is set to `true`):
+ *
+ * - <https://www.w3.org/ns/activitystreams>
+ * - <https://w3id.org/security/v1>
+ * - <https://w3id.org/security/data-integrity/v1>
+ * - <https://www.w3.org/ns/did/v1>
+ * - <https://w3id.org/security/multikey/v1>
+ * - <https://purl.archive.org/socialweb/webfinger>
+ * - <http://schema.org/>
+ * @param options Options for the document loader.
+ * @returns The document loader.
+ * @since 1.3.0
+ */
+declare function getDocumentLoader({
+  allowPrivateAddress,
+  skipPreloadedContexts,
+  userAgent
+}?: GetDocumentLoaderOptions): DocumentLoader;
+/**
+ * A JSON-LD document loader that utilizes the browser's `fetch` API.
+ *
+ * This loader preloads the below frequently used contexts:
+ *
+ * - <https://www.w3.org/ns/activitystreams>
+ * - <https://w3id.org/security/v1>
+ * - <https://w3id.org/security/data-integrity/v1>
+ * - <https://www.w3.org/ns/did/v1>
+ * - <https://w3id.org/security/multikey/v1>
+ * - <https://purl.archive.org/socialweb/webfinger>
+ * - <http://schema.org/>
+ * @param url The URL of the document to load.
+ * @param allowPrivateAddress Whether to allow fetching private network
+ *                            addresses.  Turned off by default.
+ * @returns The remote document.
+ * @deprecated Use {@link getDocumentLoader} instead.
+ */
+declare function fetchDocumentLoader(url: string, allowPrivateAddress?: boolean): Promise<RemoteDocument>;
+declare function fetchDocumentLoader(url: string, options?: DocumentLoaderOptions): Promise<RemoteDocument>;
+/**
+ * The parameters for {@link kvCache} function.
+ */
+interface KvCacheParameters {
+  /**
+   * The document loader to decorate with a cache.
+   */
+  loader: DocumentLoader;
+  /**
+   * The key–value store to use for backing the cache.
+   */
+  kv: KvStore;
+  /**
+   * The key prefix to use for namespacing the cache.
+   * `["_fedify", "remoteDocument"]` by default.
+   */
+  prefix?: KvKey;
+  /**
+   * The per-URL cache rules in the array of `[urlPattern, duration]` pairs
+   * where `urlPattern` is either a string, a {@link URL}, or
+   * a {@link URLPattern} and `duration` is a {@link Temporal.Duration}.
+   * The `duration` is allowed to be at most 30 days.
+   *
+   * By default, 5 minutes for all URLs.
+   */
+  rules?: [string | URL | URLPattern, Temporal.Duration][];
+}
+/**
+ * Decorates a {@link DocumentLoader} with a cache backed by a {@link Deno.Kv}.
+ * @param parameters The parameters for the cache.
+ * @returns The decorated document loader which is cache-enabled.
+ */
+declare function kvCache({
+  loader,
+  kv,
+  prefix,
+  rules
+}: KvCacheParameters): DocumentLoader;
+/**
+ * Options for making `User-Agent` string.
+ * @see {@link getUserAgent}
+ * @since 1.3.0
+ */
+interface GetUserAgentOptions {
+  /**
+   * An optional software name and version, e.g., `"Hollo/1.0.0"`.
+   */
+  software?: string | null;
+  /**
+   * An optional URL to append to the user agent string.
+   * Usually the URL of the ActivityPub instance.
+   */
+  url?: string | URL | null;
+}
+/**
+ * Gets the user agent string for the given application and URL.
+ * @param options The options for making the user agent string.
+ * @returns The user agent string.
+ * @since 1.3.0
+ */
+declare function getUserAgent({
+  software,
+  url
+}?: GetUserAgentOptions): string;
+//#endregion
+export { AuthenticatedDocumentLoaderFactory, DocumentLoader, DocumentLoaderFactory, DocumentLoaderFactoryOptions, FetchError, GetDocumentLoaderOptions, GetUserAgentOptions, KvCacheParameters, RemoteDocument, fetchDocumentLoader, getDocumentLoader, getUserAgent, kvCache };

package/dist/{docloader-C5a95do5.js → docloader-DrPHprgh.js}

@@ -1,16 +1,15 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-    
+          import { Temporal } from "@js-temporal/polyfill";
+          import { URLPattern } from "urlpattern-polyfill";
+        
 import { getLogger } from "@logtape/logtape";
-import { HTTPHeaderLink } from "@hugoalh/http-header-link";
 import process from "node:process";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
 
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.0.0-pr.433.1601+360b8a26";
+var version = "2.0.0-pr.434.1659+7c115883";
 var license = "MIT";
 var exports = {
 	".": "./src/mod.ts",
@@ -30,7 +29,6 @@ var exports = {
 };
 var imports = {
 	"@cfworker/json-schema": "npm:@cfworker/json-schema@^4.1.1",
-	"@hugoalh/http-header-link": "jsr:@hugoalh/http-header-link@^1.0.2",
 	"@multiformats/base-x": "npm:@multiformats/base-x@^4.0.1",
 	"@opentelemetry/api": "npm:@opentelemetry/api@^1.9.0",
 	"@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@^1.27.0",
@@ -4277,6 +4275,188 @@ const preloadedContexts = {
 };
 var contexts_default = preloadedContexts;
 
+//#endregion
+//#region src/runtime/link.ts
+const parametersNeedLowerCase = ["rel", "type"];
+const regexpLinkWhitespace = /[\n\r\s\t]/;
+function validateURI(uri) {
+	if (uri.includes("\n") || regexpLinkWhitespace.test(uri)) throw new SyntaxError(`\`${uri}\` is not a valid URI!`);
+}
+function* parseLinkFromString(input) {
+	const inputFmt = input.replaceAll("\xA0", "").replaceAll("", "");
+	for (let cursor = 0; cursor < inputFmt.length; cursor += 1) {
+		while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) cursor += 1;
+		if (inputFmt.charAt(cursor) !== "<") throw new SyntaxError(`Unexpected character \`${inputFmt.charAt(cursor)}\` at position ${cursor}; Expect character \`<\`!`);
+		cursor += 1;
+		const cursorEndUri = inputFmt.indexOf(">", cursor);
+		if (cursorEndUri === -1) throw new SyntaxError(`Missing end of URI delimiter character \`>\` after position ${cursor}!`);
+		if (cursorEndUri === cursor) throw new SyntaxError(`Missing URI at position ${cursor}!`);
+		const uriSlice = inputFmt.slice(cursor, cursorEndUri);
+		validateURI(uriSlice);
+		const uri = decodeURI(uriSlice);
+		const parameters = {};
+		cursor = cursorEndUri + 1;
+		while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) cursor += 1;
+		if (cursor === inputFmt.length || inputFmt.charAt(cursor) === ",") {
+			yield [uri, parameters];
+			continue;
+		}
+		if (inputFmt.charAt(cursor) !== ";") throw new SyntaxError(`Unexpected character \`${inputFmt.charAt(cursor)}\` at position ${cursor}; Expect character \`;\`!`);
+		cursor += 1;
+		while (cursor < inputFmt.length) {
+			while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) cursor += 1;
+			const parameterKey = inputFmt.slice(cursor).match(/^[\w-]+\*?/)?.[0].toLowerCase();
+			if (typeof parameterKey === "undefined") throw new SyntaxError(`Unexpected character \`${inputFmt.charAt(cursor)}\` at position ${cursor}; Expect a valid parameter key!`);
+			cursor += parameterKey.length;
+			while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) cursor += 1;
+			if (cursor === inputFmt.length || inputFmt.charAt(cursor) === ",") {
+				parameters[parameterKey] = "";
+				break;
+			}
+			if (inputFmt.charAt(cursor) === ";") {
+				parameters[parameterKey] = "";
+				cursor += 1;
+				continue;
+			}
+			if (inputFmt.charAt(cursor) !== "=") throw new SyntaxError(`Unexpected character \`${inputFmt.charAt(cursor)}\` at position ${cursor}; Expect character \`=\`!`);
+			cursor += 1;
+			while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) cursor += 1;
+			let parameterValue = "";
+			if (inputFmt.charAt(cursor) === "\"") {
+				cursor += 1;
+				while (cursor < inputFmt.length) {
+					if (inputFmt.charAt(cursor) === "\"") {
+						cursor += 1;
+						break;
+					}
+					if (inputFmt.charAt(cursor) === "\\") cursor += 1;
+					parameterValue += inputFmt.charAt(cursor);
+					cursor += 1;
+				}
+			} else {
+				const cursorDiffParameterValue = inputFmt.slice(cursor).search(/[\s;,]/);
+				if (cursorDiffParameterValue === -1) {
+					parameterValue += inputFmt.slice(cursor);
+					cursor += parameterValue.length;
+				} else {
+					parameterValue += inputFmt.slice(cursor, cursorDiffParameterValue);
+					cursor += cursorDiffParameterValue;
+				}
+			}
+			parameters[parameterKey] = parametersNeedLowerCase.includes(parameterKey) ? parameterValue.toLowerCase() : parameterValue;
+			while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) cursor += 1;
+			if (cursor === inputFmt.length || inputFmt.charAt(cursor) === ",") break;
+			if (inputFmt.charAt(cursor) === ";") {
+				cursor += 1;
+				continue;
+			}
+			throw new SyntaxError(`Unexpected character \`${inputFmt.charAt(cursor)}\` at position ${cursor}; Expect character \`,\`, character \`;\`, or end of the string!`);
+		}
+		yield [uri, parameters];
+	}
+}
+/**
+* Handle the HTTP header `Link` according to the specification RFC 8288.
+*/
+var HttpHeaderLink = class HttpHeaderLink {
+	get [Symbol.toStringTag]() {
+		return "HTTPHeaderLink";
+	}
+	#entries = [];
+	/**
+	* Handle the HTTP header `Link` according to the specification RFC 8288.
+	* @param {...(string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)} inputs Input.
+	*/
+	constructor(...inputs) {
+		if (inputs.length > 0) this.add(...inputs);
+	}
+	/**
+	* Add entries.
+	* @param {...(string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)} inputs Input.
+	* @returns {this}
+	*/
+	add(...inputs) {
+		for (const input of inputs) if (input instanceof HttpHeaderLink) this.#entries.push(...structuredClone(input.#entries));
+		else if (Array.isArray(input)) this.#entries.push(...input.map(([uri, parameters]) => {
+			validateURI(uri);
+			Object.entries(parameters).forEach(([key, value]) => {
+				if (key !== key.toLowerCase() || !/^[\w-]+\*?$/.test(key)) throw new SyntaxError(`\`${key}\` is not a valid parameter key!`);
+				if (parametersNeedLowerCase.includes(key) && value !== value.toLowerCase()) throw new SyntaxError(`\`${value}\` is not a valid parameter value!`);
+			});
+			return [uri, structuredClone(parameters)];
+		}));
+		else for (const entry of parseLinkFromString((input instanceof Headers || input instanceof Response ? (input instanceof Headers ? input : input.headers).get("Link") : input) ?? "")) this.#entries.push(entry);
+		return this;
+	}
+	/**
+	* Return all of the entries.
+	* @returns {HttpHeaderLinkEntry[]} Entries.
+	*/
+	entries() {
+		return structuredClone(this.#entries);
+	}
+	/**
+	* Get entries by parameter.
+	* @param {string} key Key of the parameter.
+	* @param {string} value Value of the parameter.
+	* @returns {HttpHeaderLinkEntry[]} Entries which match the parameter.
+	*/
+	getByParameter(key, value) {
+		if (key !== key.toLowerCase()) throw new SyntaxError(`\`${key}\` is not a valid parameter key!`);
+		if (key === "rel") return this.getByRel(value);
+		return structuredClone(this.#entries.filter((entry) => {
+			return entry[1][key] === value;
+		}));
+	}
+	/**
+	* Get entries by parameter `rel`.
+	* @param {string} value Value of the parameter `rel`.
+	* @returns {HttpHeaderLinkEntry[]} Entries which match the parameter.
+	*/
+	getByRel(value) {
+		if (value !== value.toLowerCase()) throw new SyntaxError(`\`${value}\` is not a valid parameter \`rel\` value!`);
+		return structuredClone(this.#entries.filter((entity) => {
+			return entity[1].rel?.toLowerCase() === value;
+		}));
+	}
+	/**
+	* Whether have entries that match parameter.
+	* @param {string} key Key of the parameter.
+	* @param {string} value Value of the parameter.
+	* @returns {boolean} Determine result.
+	*/
+	hasParameter(key, value) {
+		return this.getByParameter(key, value).length > 0;
+	}
+	/**
+	* Stringify entries.
+	* @returns {string} Stringified entries.
+	*/
+	toString() {
+		return this.#entries.map(([uri, parameters]) => {
+			return [`<${encodeURI(uri)}>`, ...Object.entries(parameters).map(([key, value]) => {
+				return value.length > 0 ? `${key}="${value.replaceAll("\"", "\\\"")}"` : key;
+			})].join("; ");
+		}).join(", ");
+	}
+	/**
+	* Parse the HTTP header `Link` according to the specification RFC 8288.
+	* @param {...(string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)} inputs Input.
+	* @returns {HttpHeaderLink}
+	*/
+	static parse(...inputs) {
+		return new this(...inputs);
+	}
+	/**
+	* Stringify as the HTTP header `Link` according to the specification RFC 8288.
+	* @param {...(string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)} inputs Input.
+	* @returns {string}
+	*/
+	static stringify(...inputs) {
+		return new this(...inputs).toString();
+	}
+};
+
 //#endregion
 //#region src/runtime/url.ts
 var UrlError = class extends Error {
@@ -4418,9 +4598,9 @@ async function getRemoteDocument(url, response, fetch$1) {
 	if (linkHeader != null) {
 		let link;
 		try {
-			link = new HTTPHeaderLink(linkHeader);
+			link = new HttpHeaderLink(linkHeader);
 		} catch (e) {
-			if (e instanceof SyntaxError) link = new HTTPHeaderLink();
+			if (e instanceof SyntaxError) link = new HttpHeaderLink();
 			else throw e;
 		}
 		if (jsonLd) {