@fedify/fedify 1.6.0-dev.812 → 1.6.0-dev.814

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "@fedify/fedify",
-    "version": "1.6.0-dev.812+f522d042",
+    "version": "1.6.0-dev.814+26348fc2",
     "license": "MIT",
     "exports": {
         ".": "./mod.ts",
@@ -25,7 +25,6 @@ export default {
         "@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@^1.27.0",
         "@phensley/language-tag": "npm:@phensley/language-tag@^1.9.0",
         "@std/assert": "jsr:@std/assert@^0.226.0",
-        "@std/http": "jsr:@std/http@^1.0.6",
         "@std/testing": "jsr:@std/testing@^0.224.0",
         "@std/url": "jsr:@std/url@^0.225.1",
         "@std/yaml": "jsr:@std/yaml@^0.224.3",

package/esm/federation/handler.js

@@ -1,6 +1,5 @@
 import { getLogger } from "@logtape/logtape";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
-import { accepts } from "../deps/jsr.io/@std/http/1.0.16/negotiation.js";
 import metadata from "../deno.js";
 import { verifyRequest } from "../sig/http.js";
 import { detachSignature, verifyJsonLd } from "../sig/ld.js";
@@ -10,8 +9,10 @@ import { getTypeId } from "../vocab/type.js";
 import { Activity, Link, Object, OrderedCollection, OrderedCollectionPage, } from "../vocab/vocab.js";
 import { routeActivity } from "./inbox.js";
 import { KvKeyCache } from "./keycache.js";
+import { preferredMediaTypes } from "./negotiation.js";
 export function acceptsJsonLd(request) {
-    const types = accepts(request);
+    const accept = request.headers.get("Accept");
+    const types = accept ? preferredMediaTypes(accept) : ["*/*"];
     if (types == null)
         return true;
     if (types[0] === "text/html" || types[0] === "application/xhtml+xml") {

package/esm/{deps/jsr.io/@std/http/1.0.16/_negotiation/media_type.js → federation/negotiation.js}

@@ -1,4 +1,3 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
 /*!
  * Adapted directly from negotiator at https://github.com/jshttp/negotiator/
  * which is licensed as follows:
@@ -28,7 +27,16 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import { compareSpecs, isQuality } from "./common.js";
+function compareSpecs(a, b) {
+    return (b.q - a.q ||
+        (b.s ?? 0) - (a.s ?? 0) ||
+        (a.o ?? 0) - (b.o ?? 0) ||
+        a.i - b.i ||
+        0);
+}
+function isQuality(spec) {
+    return spec.q > 0;
+}
 const simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
 function splitKeyValuePair(str) {
     const [key, value] = str.split("=");
@@ -74,67 +82,11 @@ function parseAccept(accept) {
 function getFullType(spec) {
     return `${spec.type}/${spec.subtype}`;
 }
-function specify(type, spec, index) {
-    const p = parseMediaType(type, index);
-    if (!p) {
-        return;
-    }
-    let s = 0;
-    if (spec.type.toLowerCase() === p.type.toLowerCase()) {
-        s |= 4;
-    }
-    else if (spec.type !== "*") {
-        return;
-    }
-    if (spec.subtype.toLowerCase() === p.subtype.toLowerCase()) {
-        s |= 2;
-    }
-    else if (spec.subtype !== "*") {
-        return;
-    }
-    const keys = Object.keys(spec.params);
-    if (keys.length) {
-        if (keys.every((key) => (spec.params[key] ?? "").toLowerCase() ===
-            (p.params[key] ?? "").toLowerCase())) {
-            s |= 1;
-        }
-        else {
-            return;
-        }
-    }
-    return {
-        i: index,
-        o: spec.o,
-        q: spec.q,
-        s,
-    };
-}
-function getMediaTypePriority(type, accepted, index) {
-    let priority = { o: -1, q: 0, s: 0, i: index };
-    for (const accepts of accepted) {
-        const spec = specify(type, accepts, index);
-        if (spec &&
-            ((priority.s ?? 0) - (spec.s ?? 0) ||
-                (priority.q ?? 0) - (spec.q ?? 0) ||
-                (priority.o ?? 0) - (spec.o ?? 0)) < 0) {
-            priority = spec;
-        }
-    }
-    return priority;
-}
-export function preferredMediaTypes(accept, provided) {
+export function preferredMediaTypes(accept) {
     const accepts = parseAccept(accept === undefined ? "*/*" : accept ?? "");
-    if (!provided) {
-        return accepts
-            .filter(isQuality)
-            .sort(compareSpecs)
-            .map(getFullType);
-    }
-    const priorities = provided.map((type, index) => {
-        return getMediaTypePriority(type, accepts, index);
-    });
-    return priorities
+    return accepts
         .filter(isQuality)
         .sort(compareSpecs)
-        .map((priority) => provided[priorities.indexOf(priority)]);
+        .map(getFullType);
 }
+// cSpell: ignore Schlueter kvps

package/esm/nodeinfo/client.js

@@ -1,6 +1,6 @@
 import { getLogger } from "@logtape/logtape";
-import { parse } from "../deps/jsr.io/@std/semver/1.0.5/mod.js";
 import { getUserAgent, } from "../runtime/docloader.js";
+import { parseSemVer } from "./semver.js";
 const logger = getLogger(["fedify", "nodeinfo", "client"]);
 export async function getNodeInfo(url, options = {}) {
     try {
@@ -169,7 +169,7 @@ export function parseSoftware(data, options = {}) {
     let version;
     if ("version" in data && typeof data.version === "string") {
         try {
-            version = parse(data.version);
+            version = parseSemVer(data.version);
         }
         catch {
             if (!options.tryBestEffort)

package/esm/nodeinfo/mod.js

@@ -6,6 +6,6 @@
  * @since 0.2.0
  */
 import "../_dnt.polyfills.js";
-export { format as formatSemVer, parse as parseSemVer, } from "../deps/jsr.io/@std/semver/1.0.5/mod.js";
+export { formatSemVer, parseSemVer } from "./semver.js";
 export { getNodeInfo, parseNodeInfo, } from "./client.js";
 export * from "./types.js";

package/esm/nodeinfo/semver.js

@@ -0,0 +1,150 @@
+// Adopted from Deno's @std/semver
+const MAX_LENGTH = 256;
+/**
+ * A single `0`, or a non-zero digit followed by zero or more digits.
+ */
+const NUMERIC_IDENTIFIER = "0|[1-9]\\d*";
+/**
+ * Zero or more digits, followed by a letter or hyphen, and then zero or more letters, digits, or hyphens.
+ */
+const NON_NUMERIC_IDENTIFIER = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+/**
+ * Three dot-separated numeric identifiers.
+ */
+const VERSION_CORE = `(?<major>${NUMERIC_IDENTIFIER})\\.(?<minor>${NUMERIC_IDENTIFIER})\\.(?<patch>${NUMERIC_IDENTIFIER})`;
+/**
+ * A numeric identifier, or a non-numeric identifier.
+ */
+const PRERELEASE_IDENTIFIER = `(?:${NUMERIC_IDENTIFIER}|${NON_NUMERIC_IDENTIFIER})`;
+/**
+ * A hyphen, followed by one or more dot-separated pre-release version identifiers.
+ * @example "-pre.release"
+ */
+const PRERELEASE = `(?:-(?<prerelease>${PRERELEASE_IDENTIFIER}(?:\\.${PRERELEASE_IDENTIFIER})*))`;
+/**
+ * Any combination of digits, letters, or hyphens.
+ */
+const BUILD_IDENTIFIER = "[0-9A-Za-z-]+";
+/**
+ * A plus sign, followed by one or more period-separated build metadata identifiers.
+ * @example "+build.meta"
+ */
+const BUILD = `(?:\\+(?<buildmetadata>${BUILD_IDENTIFIER}(?:\\.${BUILD_IDENTIFIER})*))`;
+/**
+ * A version, followed optionally by a pre-release version and build metadata.
+ */
+const FULL_VERSION = `v?${VERSION_CORE}${PRERELEASE}?${BUILD}?`;
+export const FULL_REGEXP = new RegExp(`^${FULL_VERSION}$`);
+/**
+ * Attempt to parse a string as a semantic version, returning a SemVer object.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseSemVer } from "@fedify/fedify/nodeinfo";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version = parseSemVer("1.2.3");
+ * assertEquals(version, {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ *   prerelease: [],
+ *   build: [],
+ * });
+ * ```
+ *
+ * @throws {TypeError} If the input string is invalid.
+ * @param value The version string to parse
+ * @returns A valid SemVer
+ * @since 1.2.0
+ */
+export function parseSemVer(value) {
+    if (typeof value !== "string") {
+        throw new TypeError(`Cannot parse version as version must be a string: received ${typeof value}`);
+    }
+    if (value.length > MAX_LENGTH) {
+        throw new TypeError(`Cannot parse version as version length is too long: length is ${value.length}, max length is ${MAX_LENGTH}`);
+    }
+    value = value.trim();
+    const groups = value.match(FULL_REGEXP)?.groups;
+    if (!groups)
+        throw new TypeError(`Cannot parse version: ${value}`);
+    const major = parseNumber(groups.major, `Cannot parse version ${value}: invalid major version`);
+    const minor = parseNumber(groups.minor, `Cannot parse version ${value}: invalid minor version`);
+    const patch = parseNumber(groups.patch, `Cannot parse version ${value}: invalid patch version`);
+    const prerelease = groups.prerelease
+        ? parsePrerelease(groups.prerelease)
+        : [];
+    const build = groups.buildmetadata ? parseBuild(groups.buildmetadata) : [];
+    return { major, minor, patch, prerelease, build };
+}
+/**
+ * Returns true if the value is a valid SemVer number.
+ *
+ * Must be a number. Must not be NaN. Can be positive or negative infinity.
+ * Can be between 0 and MAX_SAFE_INTEGER.
+ * @param value The value to check
+ * @returns True if its a valid semver number
+ */
+function isValidNumber(value) {
+    return (typeof value === "number" &&
+        !Number.isNaN(value) &&
+        (!Number.isFinite(value) ||
+            (0 <= value && value <= Number.MAX_SAFE_INTEGER)));
+}
+const NUMERIC_IDENTIFIER_REGEXP = new RegExp(`^${NUMERIC_IDENTIFIER}$`);
+function parsePrerelease(prerelease) {
+    return prerelease
+        .split(".")
+        .filter(Boolean)
+        .map((id) => {
+        if (NUMERIC_IDENTIFIER_REGEXP.test(id)) {
+            const number = Number(id);
+            if (isValidNumber(number))
+                return number;
+        }
+        return id;
+    });
+}
+function parseBuild(buildmetadata) {
+    return buildmetadata.split(".").filter(Boolean);
+}
+function parseNumber(input, errorMessage) {
+    const number = Number(input);
+    if (!isValidNumber(number))
+        throw new TypeError(errorMessage);
+    return number;
+}
+function formatNumber(value) {
+    return value.toFixed(0);
+}
+/**
+ * Format a SemVer object into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { formatSemVer } from "@fedify/fedify/nodeinfo";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const semver = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ * assertEquals(formatSemVer(semver), "1.2.3");
+ * ```
+ *
+ * @param version The SemVer to format
+ * @returns The string representation of a semantic version.
+ * @since 1.2.0
+ */
+export function formatSemVer(version) {
+    const major = formatNumber(version.major);
+    const minor = formatNumber(version.minor);
+    const patch = formatNumber(version.patch);
+    const pre = version.prerelease?.join(".") ?? "";
+    const build = version.build?.join(".") ?? "";
+    const primary = `${major}.${minor}.${patch}`;
+    const release = [primary, pre].filter((v) => v).join("-");
+    return [release, build].filter((v) => v).join("+");
+}

package/esm/nodeinfo/types.js

@@ -1,4 +1,4 @@
-import { format } from "../deps/jsr.io/@std/semver/1.0.5/mod.js";
+import { formatSemVer } from "./semver.js";
 /**
  * Converts a {@link NodeInfo} object to a JSON value.
  * @param nodeInfo The {@link NodeInfo} object to convert.
@@ -40,7 +40,7 @@ export function nodeInfoToJson(nodeInfo) {
         version: "2.1",
         software: {
             name: nodeInfo.software.name,
-            version: format(nodeInfo.software.version),
+            version: formatSemVer(nodeInfo.software.version),
             repository: nodeInfo.software.repository?.href,
             homepage: nodeInfo.software.homepage?.href,
         },