@farming-labs/docs 0.2.120 → 0.2.121

package/dist/heading-toc.mjs

@@ -0,0 +1,23 @@
+//#region src/heading-toc.ts
+/**
+* Encode heading fragments emitted by a renderer's nested table of contents.
+*
+* Fumadocs stores fragment URLs as raw DOM ids. Encoding the fragment after its
+* heading visitor runs keeps links valid without changing path prefixes.
+*/
+function encodeDocsHeadingTocUrls(value) {
+	if (Array.isArray(value)) {
+		for (const item of value) encodeDocsHeadingTocUrls(item);
+		return;
+	}
+	if (!value || typeof value !== "object") return;
+	const item = value;
+	if (typeof item.url === "string") {
+		const hashIndex = item.url.indexOf("#");
+		if (hashIndex >= 0) item.url = `${item.url.slice(0, hashIndex)}#${encodeURIComponent(item.url.slice(hashIndex + 1))}`;
+	}
+	encodeDocsHeadingTocUrls(item.children);
+}
+
+//#endregion
+export { encodeDocsHeadingTocUrls };

package/dist/http-body.d.mts

@@ -0,0 +1,14 @@
+//#region src/http-body.d.ts
+declare const DEFAULT_DOCS_JSON_BODY_MAX_BYTES: number;
+type DocsJsonBodyResult = {
+  ok: true;
+  value: unknown;
+} | {
+  ok: false;
+  reason: "invalid_json" | "request_too_large";
+  maxBodyBytes: number;
+};
+/** Read and parse JSON without buffering an unbounded request body. */
+declare function readDocsJsonBody(request: Request, maxBodyBytes?: number): Promise<DocsJsonBodyResult>;
+//#endregion
+export { DEFAULT_DOCS_JSON_BODY_MAX_BYTES, DocsJsonBodyResult, readDocsJsonBody };

package/dist/{http-body-DkAPk6D5.mjs → http-body.mjs}

@@ -61,4 +61,4 @@ async function readDocsJsonBody(request, maxBodyBytes = DEFAULT_DOCS_JSON_BODY_M
 }
 
 //#endregion
-export { readDocsJsonBody as n, DEFAULT_DOCS_JSON_BODY_MAX_BYTES as t };
+export { DEFAULT_DOCS_JSON_BODY_MAX_BYTES, readDocsJsonBody };

package/dist/http-cache.d.mts

@@ -0,0 +1,25 @@
+//#region src/http-cache.d.ts
+interface DocsCacheableResponseOptions {
+  request: Request;
+  content: string | Uint8Array;
+  status?: number;
+  headers?: HeadersInit;
+  /** Stable SHA-256 hex digest when the caller already hashed the exact response bytes. */
+  sha256?: string;
+  /** Exact representation modification time. Invalid values are omitted. */
+  lastModified?: string | Date | null;
+}
+/** Format an RFC 9530 Content-Digest field from a SHA-256 hex digest. */
+declare function formatDocsContentDigest(sha256: string): string;
+/** Normalize an exact source timestamp for Last-Modified. */
+declare function resolveDocsHttpDate(value?: string | Date | null): string | undefined;
+/** Match strong or weak If-None-Match validators for a GET/HEAD representation. */
+declare function requestMatchesDocsEtag(request: Request, etag: string): boolean;
+/** Apply If-Modified-Since only when the stronger If-None-Match validator is absent. */
+declare function requestHasFreshDocsDate(request: Request, lastModified?: string): boolean;
+/**
+ * Build a byte-stable GET/HEAD response with HTTP validators and RFC 9530 integrity metadata.
+ */
+declare function createDocsCacheableResponse(options: DocsCacheableResponseOptions): Response;
+//#endregion
+export { DocsCacheableResponseOptions, createDocsCacheableResponse, formatDocsContentDigest, requestHasFreshDocsDate, requestMatchesDocsEtag, resolveDocsHttpDate };

package/dist/http-cache.mjs

@@ -0,0 +1,140 @@
+import { sha256DocsContent } from "./retrieval-digest.mjs";
+
+//#region src/http-cache.ts
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const MAX_CACHED_TEXT_REPRESENTATIONS = 64;
+const MAX_CACHED_TEXT_CHARACTERS = 8 * 1024 * 1024;
+const textValidatorCache = /* @__PURE__ */ new Map();
+let cachedTextCharacters = 0;
+function encodeBase64(bytes) {
+	let encoded = "";
+	for (let offset = 0; offset < bytes.length; offset += 3) {
+		const first = bytes[offset];
+		const second = bytes[offset + 1];
+		const third = bytes[offset + 2];
+		const value = first << 16 | (second ?? 0) << 8 | (third ?? 0);
+		encoded += BASE64_ALPHABET[value >>> 18 & 63];
+		encoded += BASE64_ALPHABET[value >>> 12 & 63];
+		encoded += second === void 0 ? "=" : BASE64_ALPHABET[value >>> 6 & 63];
+		encoded += third === void 0 ? "=" : BASE64_ALPHABET[value & 63];
+	}
+	return encoded;
+}
+function sha256HexBytes(sha256) {
+	if (!/^[a-f\d]{64}$/iu.test(sha256)) throw new Error("A SHA-256 digest must contain exactly 64 hexadecimal characters.");
+	const bytes = new Uint8Array(32);
+	for (let index = 0; index < bytes.length; index += 1) bytes[index] = Number.parseInt(sha256.slice(index * 2, index * 2 + 2), 16);
+	return bytes;
+}
+/** Format an RFC 9530 Content-Digest field from a SHA-256 hex digest. */
+function formatDocsContentDigest(sha256) {
+	return `sha-256=:${encodeBase64(sha256HexBytes(sha256))}:`;
+}
+function resolveDocsContentValidators(content, suppliedSha256) {
+	if (suppliedSha256) return {
+		sha256: suppliedSha256,
+		contentDigest: formatDocsContentDigest(suppliedSha256)
+	};
+	const cached = typeof content === "string" ? textValidatorCache.get(content) : void 0;
+	if (cached) {
+		if (typeof content === "string") {
+			textValidatorCache.delete(content);
+			textValidatorCache.set(content, cached);
+		}
+		return cached;
+	}
+	const sha256 = sha256DocsContent(content);
+	const validators = {
+		sha256,
+		contentDigest: formatDocsContentDigest(sha256)
+	};
+	if (typeof content !== "string") return validators;
+	if (content.length <= MAX_CACHED_TEXT_CHARACTERS) {
+		textValidatorCache.set(content, validators);
+		cachedTextCharacters += content.length;
+		while (textValidatorCache.size > MAX_CACHED_TEXT_REPRESENTATIONS || cachedTextCharacters > MAX_CACHED_TEXT_CHARACTERS) {
+			const oldest = textValidatorCache.keys().next().value;
+			if (oldest === void 0) break;
+			textValidatorCache.delete(oldest);
+			cachedTextCharacters -= oldest.length;
+		}
+	}
+	return validators;
+}
+/** Normalize an exact source timestamp for Last-Modified. */
+function resolveDocsHttpDate(value) {
+	if (!value) return void 0;
+	if (typeof value === "string" && !/(?:T|\s)\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?/.test(value.trim())) return;
+	const date = value instanceof Date ? value : new Date(value);
+	if (Number.isNaN(date.getTime())) return void 0;
+	return date.toUTCString();
+}
+function normalizeEtag(value) {
+	return value.trim().replace(/^W\//iu, "");
+}
+/** Match strong or weak If-None-Match validators for a GET/HEAD representation. */
+function requestMatchesDocsEtag(request, etag) {
+	const header = request.headers.get("if-none-match");
+	if (!header) return false;
+	if (header.trim() === "*") return true;
+	const expected = normalizeEtag(etag);
+	return header.split(",").some((candidate) => normalizeEtag(candidate) === expected);
+}
+/** Apply If-Modified-Since only when the stronger If-None-Match validator is absent. */
+function requestHasFreshDocsDate(request, lastModified) {
+	const method = request.method.toUpperCase();
+	if (method !== "GET" && method !== "HEAD") return false;
+	if (!lastModified || request.headers.has("if-none-match")) return false;
+	const ifModifiedSince = request.headers.get("if-modified-since");
+	if (!ifModifiedSince) return false;
+	const resourceTime = Date.parse(lastModified);
+	const requestTime = Date.parse(ifModifiedSince);
+	return Number.isFinite(resourceTime) && Number.isFinite(requestTime) && Math.floor(resourceTime / 1e3) <= Math.floor(requestTime / 1e3);
+}
+function exposeValidatorHeaders(headers) {
+	if (!headers.has("Access-Control-Allow-Origin")) return;
+	const exposed = new Set((headers.get("Access-Control-Expose-Headers") ?? "").split(",").map((value) => value.trim()).filter(Boolean));
+	exposed.add("Content-Digest");
+	exposed.add("ETag");
+	if (headers.has("Last-Modified")) exposed.add("Last-Modified");
+	headers.set("Access-Control-Expose-Headers", [...exposed].join(", "));
+}
+/**
+* Build a byte-stable GET/HEAD response with HTTP validators and RFC 9530 integrity metadata.
+*/
+function createDocsCacheableResponse(options) {
+	const method = options.request.method.toUpperCase();
+	const isSafeRetrieval = method === "GET" || method === "HEAD";
+	const status = options.status ?? 200;
+	const canApplyConditionalRequest = status === 200;
+	const { sha256, contentDigest } = resolveDocsContentValidators(options.content, options.sha256);
+	const etag = `"${sha256}"`;
+	const lastModified = resolveDocsHttpDate(options.lastModified);
+	const headers = new Headers(options.headers);
+	headers.set("Content-Digest", contentDigest);
+	headers.set("ETag", etag);
+	if (lastModified) headers.set("Last-Modified", lastModified);
+	exposeValidatorHeaders(headers);
+	if (canApplyConditionalRequest && requestMatchesDocsEtag(options.request, etag)) {
+		headers.delete("Content-Type");
+		return new Response(null, {
+			status: isSafeRetrieval ? 304 : 412,
+			headers
+		});
+	}
+	if (canApplyConditionalRequest && isSafeRetrieval && requestHasFreshDocsDate(options.request, lastModified)) {
+		headers.delete("Content-Type");
+		return new Response(null, {
+			status: 304,
+			headers
+		});
+	}
+	const body = method === "HEAD" ? null : typeof options.content === "string" ? options.content : options.content;
+	return new Response(body, {
+		status,
+		headers
+	});
+}
+
+//#endregion
+export { createDocsCacheableResponse, formatDocsContentDigest, requestHasFreshDocsDate, requestMatchesDocsEtag, resolveDocsHttpDate };

package/dist/http-link.mjs

@@ -0,0 +1,81 @@
+//#region src/http-link.ts
+/** Split an HTTP list without treating delimiters inside quotes or URI references as separators. */
+function splitHttpList(value, delimiter) {
+	const parts = [];
+	let start = 0;
+	let quoted = false;
+	let escaped = false;
+	let angleDepth = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const character = value[index];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (quoted && character === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (character === "\"") {
+			quoted = !quoted;
+			continue;
+		}
+		if (!quoted && character === "<") angleDepth += 1;
+		if (!quoted && character === ">" && angleDepth > 0) angleDepth -= 1;
+		if (!quoted && angleDepth === 0 && character === delimiter) {
+			parts.push(value.slice(start, index).trim());
+			start = index + 1;
+		}
+	}
+	parts.push(value.slice(start).trim());
+	return parts.filter(Boolean);
+}
+function unquoteHttpValue(value) {
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("\"") || !trimmed.endsWith("\"")) return trimmed;
+	return trimmed.slice(1, -1).replace(/\\(.)/g, "$1");
+}
+/** Parse Link header values while preserving the target/relation association. */
+function parseHttpLinkHeader(header) {
+	if (!header) return [];
+	const links = [];
+	for (const value of splitHttpList(header, ",")) {
+		const target = value.match(/^\s*<([^>]*)>/);
+		if (!target) continue;
+		const relations = [];
+		for (const rawParameter of splitHttpList(value.slice(target[0].length), ";")) {
+			const separator = rawParameter.indexOf("=");
+			if (separator < 0 || rawParameter.slice(0, separator).trim().toLowerCase() !== "rel") continue;
+			relations.push(...unquoteHttpValue(rawParameter.slice(separator + 1)).toLowerCase().split(/\s+/));
+		}
+		links.push({
+			href: target[1],
+			relations: relations.filter(Boolean)
+		});
+	}
+	return links;
+}
+function httpLinkMatchesExpectation(links, expectation, responseUrl) {
+	let expectedUrl;
+	try {
+		expectedUrl = new URL(expectation.href, responseUrl).toString();
+	} catch {
+		return false;
+	}
+	return links.some((link) => {
+		try {
+			return new URL(link.href, responseUrl).toString() === expectedUrl && link.relations.includes(expectation.rel.toLowerCase());
+		} catch {
+			return false;
+		}
+	});
+}
+function httpLinkHeaderHasTargetRelation(header, href, rel, responseUrl) {
+	return httpLinkMatchesExpectation(parseHttpLinkHeader(header), {
+		href,
+		rel
+	}, responseUrl);
+}
+
+//#endregion
+export { httpLinkHeaderHasTargetRelation, httpLinkMatchesExpectation, parseHttpLinkHeader, splitHttpList, unquoteHttpValue };

package/dist/i18n.d.mts

@@ -0,0 +1,18 @@
+import { DocsI18nConfig } from "./types.mjs";
+
+//#region src/i18n.d.ts
+interface ResolvedDocsI18n {
+  locales: string[];
+  defaultLocale: string;
+}
+interface DocsPathMatch {
+  /** Slug path relative to the docs root (no leading slash). */
+  slug: string;
+  /** Entry path used for URLs (no locale segment). */
+  entryPath: string;
+}
+declare function resolveDocsI18n(config?: DocsI18nConfig | null): ResolvedDocsI18n | null;
+declare function resolveDocsLocale(searchParams: URLSearchParams, i18n?: ResolvedDocsI18n | null): string | undefined;
+declare function resolveDocsPath(pathname: string, entry: string): DocsPathMatch;
+//#endregion
+export { DocsPathMatch, ResolvedDocsI18n, resolveDocsI18n, resolveDocsLocale, resolveDocsPath };

package/dist/{i18n-B1gJ9EW0.mjs → i18n.mjs}

@@ -37,4 +37,4 @@ function resolveDocsPath(pathname, entry) {
 }
 
 //#endregion
-export { resolveDocsLocale as n, resolveDocsPath as r, resolveDocsI18n as t };
+export { resolveDocsI18n, resolveDocsLocale, resolveDocsPath };