@fedify/fedify 1.6.0-dev.813 → 1.6.0-experiment.0

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+
+//#endregion
+export { __export };

package/dist/codegen/fs.js

@@ -0,0 +1,23 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region codegen/fs.ts
+/**
+* Recursively read a directory, yielding the paths of all files.  File paths
+* are relative to the directory, and directories are not yielded.
+* @param dir The directory to read.
+* @returns An async iterable of file paths.
+*/
+async function* readDirRecursive(dir) {
+	for (const entry of await readdir(dir, { withFileTypes: true })) if (entry.isDirectory()) {
+		const path = join(dir, entry.name);
+		for await (const subentry of readDirRecursive(path)) yield join(entry.name, subentry);
+	} else yield entry.name;
+}
+
+//#endregion
+export { readDirRecursive };

package/dist/codegen/schema.js

@@ -0,0 +1,87 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { fromFileUrl } from "../node_modules/.pnpm/@jsr_std__path@1.0.9/node_modules/@jsr/std__path/from_file_url.js";
+import { dirname$3 as dirname } from "../node_modules/.pnpm/@jsr_std__url@1.0.0-rc.3/node_modules/@jsr/std__url/dirname.js";
+import { join$3 as join } from "../node_modules/.pnpm/@jsr_std__url@1.0.0-rc.3/node_modules/@jsr/std__url/join.js";
+import { parse } from "../node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/parse.js";
+import { readDirRecursive } from "./fs.js";
+import { readFile } from "node:fs/promises";
+import { Validator } from "@cfworker/json-schema";
+import { join as join$1 } from "node:path";
+
+//#region codegen/schema.ts
+/**
+* An error that occurred while loading a schema file.
+*/
+var SchemaError = class extends Error {
+	/**
+	* The path of the schema file.
+	*/
+	path;
+	/**
+	* Constructs a new `SchemaError`.
+	* @param path The path of the schema file.
+	* @param message The error message.
+	*/
+	constructor(path, message) {
+		super(message);
+		this.path = path;
+	}
+};
+async function loadSchemaValidator() {
+	const thisFile = new URL(import.meta.url);
+	const schemaFile = join(dirname(thisFile), "schema.yaml");
+	let content;
+	if (schemaFile.protocol !== "file:") {
+		const response = await fetch(schemaFile);
+		content = await response.text();
+	} else content = await readFile(fromFileUrl(schemaFile), { encoding: "utf-8" });
+	const schemaObject = parse(content);
+	return new Validator(schemaObject);
+}
+const schemaValidator = await loadSchemaValidator();
+async function loadSchema(path) {
+	const content = await readFile(path, { encoding: "utf-8" });
+	const schema = parse(content);
+	const result = schemaValidator.validate(schema);
+	const errors = [];
+	if (result.valid) return schema;
+	for (const e of result.errors) errors.push(new SchemaError(path, `${path}:${e.instanceLocation}: ${e.error}`));
+	throw new AggregateError(errors);
+}
+/**
+* Loads all schema files in the directory.
+* @param dir The path of the directory to load schema files from.
+* @returns A map from the qualified URI of a type to its {@link SchemaFile}.
+* @throws {@link AggregateError} if any schema file is invalid.  It contains
+*         all {@link SchemaError}s of the invalid schema files.
+*/
+async function loadSchemaFiles(dir) {
+	if (typeof dir !== "string") throw new TypeError("Expected a directory path in string");
+	const result = {};
+	const errors = [];
+	for await (const relPath of readDirRecursive(dir)) {
+		if (!relPath.match(/\.ya?ml$/i)) continue;
+		const path = join$1(dir, relPath);
+		let schema;
+		try {
+			schema = await loadSchema(path);
+		} catch (e) {
+			if (e instanceof AggregateError && e.errors.length > 0 && e.errors[0] instanceof SchemaError) {
+				errors.push(...e.errors);
+				continue;
+			}
+			throw e;
+		}
+		result[schema.uri] = schema;
+	}
+	if (errors.length > 0) throw new AggregateError(errors);
+	const entries = Object.entries(result);
+	entries.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	return Object.fromEntries(entries);
+}
+
+//#endregion
+export { loadSchemaFiles };

package/dist/codegen/type.js

@@ -0,0 +1,394 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region codegen/type.ts
+const scalarTypes = {
+	"http://www.w3.org/2001/XMLSchema#boolean": {
+		name: "boolean",
+		typeGuard(v) {
+			return `typeof ${v} === "boolean"`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v} }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "boolean"`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#integer": {
+		name: "number",
+		typeGuard(v) {
+			return `typeof ${v} === "number" && Number.isInteger(${v})`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "http://www.w3.org/2001/XMLSchema#integer",
+        "@value": ${v},
+      }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@type" in ${v}
+        && ${v}["@type"] === "http://www.w3.org/2001/XMLSchema#integer"
+        && "@value" in ${v} && typeof ${v}["@value"] === "number"`;
+		},
+		decoder(v) {
+			return `${v}["@value"] as number`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#nonNegativeInteger": {
+		name: "number",
+		typeGuard(v) {
+			return `typeof ${v} === "number" && Number.isInteger(${v}) && ${v} >= 0`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "http://www.w3.org/2001/XMLSchema#nonNegativeInteger",
+        "@value": ${v},
+      }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@type" in ${v}
+        && ${v}["@type"] === "http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
+        && "@value" in ${v} && typeof ${v}["@value"] === "number"`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#float": {
+		name: "number",
+		typeGuard(v) {
+			return `typeof ${v} === "number" && !Number.isNaN(${v})`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "http://www.w3.org/2001/XMLSchema#float",
+        "@value": ${v},
+      }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@type" in ${v}
+        && ${v}["@type"] === "http://www.w3.org/2001/XMLSchema#float"
+        && "@value" in ${v} && typeof ${v}["@value"] === "number"`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#string": {
+		name: "string",
+		typeGuard(v) {
+			return `typeof ${v} === "string"`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v} }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string" && !("@language" in ${v})`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#anyURI": {
+		name: "URL",
+		typeGuard(v) {
+			return `${v} instanceof URL`;
+		},
+		encoder(v) {
+			return `{ "@id": ${v}.href }`;
+		},
+		compactEncoder(v) {
+			return `${v}.href`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@id" in ${v}
+        && typeof ${v}["@id"] === "string"
+        && ${v}["@id"] !== "" && ${v}["@id"] !== "/"`;
+		},
+		decoder(v) {
+			return `new URL(${v}["@id"])`;
+		}
+	},
+	"http://www.w3.org/1999/02/22-rdf-syntax-ns#langString": {
+		name: "LanguageString",
+		typeGuard(v) {
+			return `${v} instanceof LanguageString`;
+		},
+		encoder(v) {
+			return `{
+        "@value": ${v}.toString(),
+        "@language": ${v}.language.compact(),
+      }`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@language" in ${v} && "@value" in ${v}
+        && typeof ${v}["@language"] === "string"
+        && typeof ${v}["@value"] === "string"`;
+		},
+		decoder(v) {
+			return `new LanguageString(${v}["@value"], ${v}["@language"])`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#dateTime": {
+		name: "Temporal.Instant",
+		typeGuard(v) {
+			return `${v} instanceof Temporal.Instant`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "http://www.w3.org/2001/XMLSchema#dateTime",
+        "@value": ${v}.toString(),
+      }`;
+		},
+		compactEncoder(v) {
+			return `${v}.toString()`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@type" in ${v}
+        && "@value" in ${v} && typeof ${v}["@value"] === "string"
+        && ${v}["@type"] === "http://www.w3.org/2001/XMLSchema#dateTime"
+        // Check if the value is a valid RFC 3339 date-time string
+        && new Date(${v}["@value"]).toString() !== "Invalid Date"
+        `;
+		},
+		decoder(v) {
+			return `Temporal.Instant.from(
+        ${v}["@value"].substring(19).match(/[Z+-]/)
+          ? ${v}["@value"]
+          : ${v}["@value"] + "Z"
+      )`;
+		}
+	},
+	"http://www.w3.org/2001/XMLSchema#duration": {
+		name: "Temporal.Duration",
+		typeGuard(v) {
+			return `${v} instanceof Temporal.Duration`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "http://www.w3.org/2001/XMLSchema#duration",
+        "@value": ${v}.toString(),
+      }`;
+		},
+		compactEncoder(v) {
+			return `${v}.toString()`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@type" in ${v}
+        && "@value" in ${v} && typeof ${v}["@value"] === "string"
+        && ${v}["@type"] === "http://www.w3.org/2001/XMLSchema#duration"`;
+		},
+		decoder(v) {
+			return `Temporal.Duration.from(${v}["@value"])`;
+		}
+	},
+	"https://w3id.org/security#cryptosuiteString": {
+		name: "\"eddsa-jcs-2022\"",
+		typeGuard(v) {
+			return `${v} == "eddsa-jcs-2022"`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v} }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && !("@language" in ${v}) && ${v}["@value"] === "eddsa-jcs-2022"`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	},
+	"https://w3id.org/security#multibase": {
+		name: "Uint8Array",
+		typeGuard(v) {
+			return `${v} instanceof Uint8Array`;
+		},
+		encoder(v) {
+			return `{
+        "@type": "https://w3id.org/security#multibase",
+        "@value": new TextDecoder().decode(encodeMultibase("base58btc", ${v})),
+      }`;
+		},
+		compactEncoder(v) {
+			return `new TextDecoder().decode(encodeMultibase("base58btc", ${v}))`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string"`;
+		},
+		decoder(v) {
+			return `decodeMultibase(${v}["@value"])`;
+		}
+	},
+	"fedify:langTag": {
+		name: "LanguageTag",
+		typeGuard(v) {
+			return `${v} instanceof LanguageTag`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v}.compact() }`;
+		},
+		compactEncoder(v) {
+			return `${v}.compact()`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string" && !("@language" in ${v})`;
+		},
+		decoder(v) {
+			return `parseLanguageTag(${v}["@value"])`;
+		}
+	},
+	"fedify:url": {
+		name: "URL",
+		typeGuard(v) {
+			return `${v} instanceof URL`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v}.href }`;
+		},
+		compactEncoder(v) {
+			return `${v}.href`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string"
+        && ${v}["@value"] !== "" && ${v}["@value"] !== "/"`;
+		},
+		decoder(v) {
+			return `new URL(${v}["@value"])`;
+		}
+	},
+	"fedify:publicKey": {
+		name: "CryptoKey",
+		typeGuard(v) {
+			return `
+        // @ts-ignore: CryptoKey exists in the global scope.
+        // dnt-shim-ignore
+        ${v} instanceof CryptoKey
+      `;
+		},
+		encoder(v) {
+			return `{ "@value": await exportSpki(${v}) }`;
+		},
+		compactEncoder(v) {
+			return `await exportSpki(${v})`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string"`;
+		},
+		decoder(v) {
+			return `await importPem(${v}["@value"])`;
+		}
+	},
+	"fedify:multibaseKey": {
+		name: "CryptoKey",
+		typeGuard(v) {
+			return `
+        // @ts-ignore: CryptoKey exists in the global scope.
+        // dnt-shim-ignore
+        ${v} instanceof CryptoKey
+      `;
+		},
+		encoder(v) {
+			return `{
+        "@type": "https://w3id.org/security#multibase",
+        "@value": await exportMultibaseKey(${v}),
+      }`;
+		},
+		compactEncoder(v) {
+			return `await exportMultibaseKey(${v})`;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+        && typeof ${v}["@value"] === "string"`;
+		},
+		decoder(v) {
+			return `await importMultibaseKey(${v}["@value"])`;
+		}
+	},
+	"fedify:proofPurpose": {
+		name: "\"assertionMethod\" | \"authentication\" | \"capabilityInvocation\" | \"capabilityDelegation\" | \"keyAgreement\"",
+		typeGuard(v) {
+			return `${v} === "assertionMethod" || ${v} === "authentication" ||
+        ${v} === "capabilityInvocation" || ${v} === "capabilityDelegation" ||
+        ${v} === "keyAgreement"`;
+		},
+		encoder(v) {
+			return `{
+        "@id": "https://w3id.org/security#" + ${v},
+      }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@id" in ${v}
+        && typeof ${v}["@id"] === "string"
+        && ${v}["@id"].startsWith("https://w3id.org/security#")
+        && [
+          "assertionMethod", "authentication", "capabilityInvocation",
+          "capabilityDelegation", "keyAgreement",
+        ].includes(${v}["@id"].substring(26))`;
+		},
+		decoder(v) {
+			return `${v}["@id"].substring(26)`;
+		}
+	},
+	"fedify:units": {
+		name: "\"cm\" | \"feet\" | \"inches\" | \"km\" | \"m\" | \"miles\"",
+		typeGuard(v) {
+			return `${v} == "cm" || ${v} == "feet" || ${v} == "inches" || ${v} == "km" || ${v} == "m" || ${v} == "miles"`;
+		},
+		encoder(v) {
+			return `{ "@value": ${v} }`;
+		},
+		compactEncoder(v) {
+			return v;
+		},
+		dataCheck(v) {
+			return `typeof ${v} === "object" && "@value" in ${v}
+      && (${v}["@value"] == "cm" || ${v}["@value"] == "feet" || ${v}["@value"] == "inches" || ${v}["@value"] == "km" || ${v}["@value"] == "m" || ${v}["@value"] == "miles")`;
+		},
+		decoder(v) {
+			return `${v}["@value"]`;
+		}
+	}
+};
+function isScalarType(typeUri, types) {
+	if (typeUri in scalarTypes) return true;
+	else if (typeUri in types) return !types[typeUri].entity;
+	throw new Error(`Unknown type: ${typeUri}`);
+}
+function areAllScalarTypes(typeUris, types) {
+	return typeUris.every((typeUri) => isScalarType(typeUri, types));
+}
+
+//#endregion
+export { areAllScalarTypes };

package/dist/compat/mod.d.ts

@@ -0,0 +1,5 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+import { ActivityTransformer } from "./types.js";
+import { actorDehydrator$1 as actorDehydrator, autoIdAssigner$1 as autoIdAssigner, getDefaultActivityTransformers$1 as getDefaultActivityTransformers } from "./transformers.js";
+export { ActivityTransformer, actorDehydrator, autoIdAssigner, getDefaultActivityTransformers };

package/dist/compat/mod.js

@@ -0,0 +1,7 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { actorDehydrator, autoIdAssigner, getDefaultActivityTransformers } from "./transformers.js";
+
+export { actorDehydrator, autoIdAssigner, getDefaultActivityTransformers };

package/dist/compat/transformers.d.ts

@@ -0,0 +1,101 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+import { Activity$1 as Activity } from "../vocab/vocab.js";
+import { Context } from "../federation/context.js";
+import { ActivityTransformer } from "./types.js";
+
+//#region compat/transformers.d.ts
+/**
+* An activity transformer that assigns a new random ID to an activity if it
+* does not already have one.  This is useful for ensuring that activities
+* have an ID before they are sent to other servers.
+*
+* The generated ID is an origin URI with a fragment which contains an activity
+* type name with a random UUID:
+*
+* ```
+* https://example.com/#Follow/12345678-1234-5678-1234-567812345678
+* ```
+*
+* @typeParam TContextData The type of the context data.
+* @param activity The activity to assign an ID to.
+* @param context The context of the activity.
+* @return The activity with an ID assigned.
+* @since 1.4.0
+*/
+/**
+ * An activity transformer that assigns a new random ID to an activity if it
+ * does not already have one.  This is useful for ensuring that activities
+ * have an ID before they are sent to other servers.
+ *
+ * The generated ID is an origin URI with a fragment which contains an activity
+ * type name with a random UUID:
+ *
+ * ```
+ * https://example.com/#Follow/12345678-1234-5678-1234-567812345678
+ * ```
+ *
+ * @typeParam TContextData The type of the context data.
+ * @param activity The activity to assign an ID to.
+ * @param context The context of the activity.
+ * @return The activity with an ID assigned.
+ * @since 1.4.0
+ */
+declare function autoIdAssigner<TContextData>(activity: Activity, context: Context<TContextData>): Activity;
+/**
+ * An activity transformer that dehydrates the actor property of an activity
+ * so that it only contains the actor's URI.  For example, suppose we have an
+ * activity like this:
+ *
+ * ```typescript
+ * import { Follow, Person } from "@fedify/fedify/vocab";
+ * const input = new Follow({
+ *   id: new URL("http://example.com/activities/1"),
+ *   actor: new Person({
+ *     id: new URL("http://example.com/actors/1"),
+ *     name: "Alice",
+ *     preferredUsername: "alice",
+ *   }),
+ *   object: new Person({
+ *     id: new URL("http://example.com/actors/2"),
+ *     name: "Bob",
+ *     preferredUsername: "bob",
+ *   }),
+ * });
+ * ```
+ *
+ * The result of applying this transformer would be:
+ *
+ * ```typescript
+ * import { Follow, Person } from "@fedify/fedify/vocab";
+ * const output = new Follow({
+ *   id: new URL("http://example.com/activities/1"),
+ *   actor: new URL("http://example.com/actors/1"),
+ *   object: new Person({
+ *     id: new URL("http://example.com/actors/2"),
+ *     name: "Bob",
+ *     preferredUsername: "bob",
+ *   }),
+ * });
+ * ```
+ *
+ * As some ActivityPub implementations like Threads fail to deal with inlined
+ * actor objects, this transformer can be used to work around this issue.
+ * @typeParam TContextData The type of the context data.
+ * @param activity The activity to dehydrate the actor property of.
+ * @param context The context of the activity.
+ * @returns The dehydrated activity.
+ * @since 1.4.0
+ */
+declare function actorDehydrator<TContextData>(activity: Activity, _context: Context<TContextData>): Activity;
+/**
+ * Gets the default activity transformers that are applied to all outgoing
+ * activities.
+ * @typeParam TContextData The type of the context data.
+ * @returns The default activity transformers.
+ * @since 1.4.0
+ */
+declare function getDefaultActivityTransformers<TContextData>(): readonly ActivityTransformer<TContextData>[];
+
+//#endregion
+export { actorDehydrator as actorDehydrator$1, autoIdAssigner as autoIdAssigner$1, getDefaultActivityTransformers as getDefaultActivityTransformers$1 };