@fedify/botkit 0.3.0-dev.108

package/dist/text.js

@@ -0,0 +1,640 @@
+
+      import { Temporal, toTemporalInstant } from "@js-temporal/polyfill";
+      Date.prototype.toTemporalInstant = toTemporalInstant;
+    
+import { Hashtag } from "@fedify/fedify/vocab";
+import { Emoji as Emoji$1, Link as Link$1, Mention as Mention$1, getActorHandle as getActorHandle$1, isActor as isActor$1 } from "@fedify/fedify";
+import { encode } from "html-entities";
+import { hashtag as hashtag$1 } from "@fedify/markdown-it-hashtag";
+import { mention as mention$1, toFullHandle } from "@fedify/markdown-it-mention";
+import MarkdownIt from "markdown-it";
+
+//#region src/text.ts
+/**
+* Checks if a value is a {@link Text} tree.
+* @param value The value to check.
+* @returns `true` if the value is a {@link Text} tree, `false` otherwise.
+* @typeParam TContextData The type of the context data.
+*/
+function isText(value) {
+	return typeof value === "object" && value !== null && "getHtml" in value && "getTags" in value && typeof value.getHtml === "function" && typeof value.getTags === "function" && "type" in value && (value.type === "block" || value.type === "inline");
+}
+/**
+* Checks if a given `actor` is mentioned in a `text`.
+* @param session The bot session.
+* @param text The text object to check.
+* @param actor The actor to check.  It can be either an `Actor` object or
+*              an actor URI.
+* @returns `true` if the actor is mentioned in the text, `false` otherwise.
+*/
+async function mentions(session, text$1, actor) {
+	if (isActor$1(actor)) {
+		if (actor.id == null) return false;
+		actor = actor.id;
+	}
+	for await (const tag of text$1.getTags(session)) if (tag instanceof Mention$1 && tag.href?.href === actor.href) return true;
+	return false;
+}
+/**
+* A text tree that renders a template string with values.  You normally
+* don't need to instantiate this directly; use the {@link text} function
+* instead.
+* @typeParam TContextData The type of the context data.
+*/
+var TemplatedText = class {
+	type = "block";
+	#strings;
+	#values;
+	/**
+	* Creates a text tree with a template string and values.
+	* @param strings The template strings.
+	* @param values The values to interpolate.
+	*/
+	constructor(strings, ...values) {
+		this.#strings = strings;
+		this.#values = values.map((v) => {
+			if (isText(v)) return v;
+			if (v instanceof URL) return link(v);
+			if (isActor$1(v)) return mention(v);
+			if (v instanceof Emoji$1) return customEmoji(v);
+			return new PlainText(String(v));
+		});
+	}
+	async *getHtml(session) {
+		let paraState = "closed";
+		for (let i = 0; i < this.#strings.length; i++) {
+			const paragraphs = this.#strings[i].split(/([ \t]*\r?\n){2,}/g);
+			let p = 0;
+			for (const para of paragraphs) {
+				if (p > 0 && paraState === "opened") {
+					yield "</p>";
+					paraState = "closed";
+				}
+				const lines = para.split("\n");
+				let l = 0;
+				for (const line of lines) {
+					if (line.trim() === "") continue;
+					if (l < 1 && paraState === "closed") {
+						yield "<p>";
+						paraState = "opened";
+					}
+					if (l > 0) yield "<br>";
+					yield encode(line);
+					l++;
+				}
+				p++;
+			}
+			if (i < this.#values.length) {
+				const value = this.#values[i];
+				if (value.type === "block" && paraState === "opened") {
+					yield "</p>";
+					paraState = "closed";
+				} else if (value.type === "inline" && paraState === "closed") {
+					yield "<p>";
+					paraState = "opened";
+				}
+				yield* value.getHtml(session);
+			}
+		}
+		if (paraState === "opened") yield "</p>";
+	}
+	async *getTags(session) {
+		for (const value of this.#values) {
+			if (!isText(value)) continue;
+			yield* value.getTags(session);
+		}
+	}
+	getCachedObjects() {
+		const objects = [];
+		for (const value of this.#values) {
+			if (!isText(value)) continue;
+			objects.push(...value.getCachedObjects());
+		}
+		return objects;
+	}
+};
+/**
+* A template string tag that creates a {@link Text} tree.
+*
+* Basically, it only interpolates values into the template string and
+* escapes HTML characters, except for line breaks and paragraphs.
+* For example, the below code:
+*
+* ```ts
+* text`Hello, <${em("World")}>!\n\nGoodbye!`
+* ```
+*
+* will be rendered as:
+*
+* ```html
+* <p>Hello, &lt;<em>World</em>&gt;!</p>
+* <p>Goodbye!</p>
+* ```
+*
+* @typeParam TContextData The type of the context data.
+* @param strings The template strings.
+* @param values The values to interpolate.
+* @returns A {@link Text} tree.
+*/
+function text(strings, ...values) {
+	return new TemplatedText(strings, ...values);
+}
+/**
+* A text tree that renders a plain text.  You normally don't need to
+* instantiate this directly; use the {@link plainText} function instead.
+* @typeParam TContextData The type of the context data.
+*/
+var PlainText = class {
+	type = "inline";
+	text;
+	/**
+	* Creates a {@link PlainText} tree with a plain text.
+	* @param text The plain text.
+	*/
+	constructor(text$1) {
+		this.text = text$1;
+	}
+	async *getHtml(_session) {
+		let first = true;
+		for (const line of this.text.split("\n")) {
+			if (!first) yield "<br>";
+			yield encode(line);
+			first = false;
+		}
+	}
+	async *getTags(_session) {}
+	getCachedObjects() {
+		return [];
+	}
+};
+/**
+* A function that creates a {@link PlainText} tree.  It only does two simple
+* things:
+*
+* - Escaping the given text so that it can be safely rendered as HTML
+* - Splitting the text by line breaks and rendering them as hard line breaks
+* @typeParam TContextData The type of the context data.
+* @param text The plain text.
+* @returns A {@link PlainText} tree.
+*/
+function plainText(text$1) {
+	return new PlainText(text$1);
+}
+/**
+* A text tree that renders a mention.  You normally don't need to
+* instantiate this directly; use the {@link mention} function instead.
+* @typeParam TContextData The type of the context data.
+*/
+var MentionText = class {
+	type = "inline";
+	#label;
+	#actor;
+	#cachedObject;
+	#labelPromise;
+	#actorPromise;
+	/**
+	* Creates a {@link MentionText} tree with a label and an actor.
+	* @param label The label of the mention.
+	* @param actor The actor which the mention refers to.
+	*/
+	constructor(label, actor) {
+		this.#label = label;
+		this.#actor = actor;
+		if (isActor$1(actor)) this.#cachedObject = actor;
+	}
+	#getLabel(session) {
+		if (typeof this.#label === "string") return Promise.resolve(this.#label);
+		if (this.#labelPromise != null) return this.#labelPromise;
+		return this.#labelPromise = this.#label(session);
+	}
+	#getActor(session) {
+		if (isActor$1(this.#actor)) return Promise.resolve(this.#actor);
+		if (this.#actorPromise != null) return this.#actorPromise;
+		return this.#actorPromise = this.#actor(session).then((actor) => {
+			if (actor != null) this.#cachedObject = actor;
+			return actor;
+		});
+	}
+	async *getHtml(session) {
+		const label = await this.#getLabel(session);
+		const actor = await this.#getActor(session);
+		const url = !isActor$1(actor) ? null : actor.url == null ? actor.id : actor.url instanceof Link$1 ? actor.url.href : actor.url;
+		if (url == null) {
+			yield encode(label);
+			return;
+		}
+		yield "<a href=\"";
+		yield encode(url.href);
+		yield "\" translate=\"no\" class=\"h-card u-url mention\" target=\"_blank\">";
+		if (label.startsWith("@")) {
+			yield "@<span>";
+			yield encode(label.substring(1));
+			yield "</span>";
+		} else yield encode(label);
+		yield "</a>";
+	}
+	async *getTags(session) {
+		const label = await this.#getLabel(session);
+		const actor = await this.#getActor(session);
+		if (isActor$1(actor)) yield new Mention$1({
+			name: label,
+			href: actor.id
+		});
+	}
+	getCachedObjects() {
+		return this.#cachedObject == null ? [] : [this.#cachedObject];
+	}
+};
+function mention(a, b) {
+	if (b != null) return new MentionText(a, isActor$1(b) ? b : async (session) => {
+		if (session.actorId.href === b.href) return await session.getActor();
+		const documentLoader = await session.context.getDocumentLoader(session.bot);
+		return await session.context.lookupObject(b, { documentLoader });
+	});
+	else if (typeof a === "string") return new MentionText(a, async (session) => {
+		if (session.actorHandle === a) return await session.getActor();
+		const documentLoader = await session.context.getDocumentLoader(session.bot);
+		return await session.context.lookupObject(a, { documentLoader });
+	});
+	else if (isActor$1(a)) return new MentionText((session) => a.id?.href === session.actorId.href ? Promise.resolve(session.actorHandle) : getActorHandle$1(a, session.context), a);
+	return new MentionText((session) => a.href === session.actorId.href ? Promise.resolve(session.actorHandle) : getActorHandle$1(a, session.context), async (session) => {
+		if (a.href === session.actorId.href) return await session.getActor();
+		const documentLoader = await session.context.getDocumentLoader(session.bot);
+		return await session.context.lookupObject(a, { documentLoader });
+	});
+}
+/**
+* A text tree that renders a hashtag.  You normally don't need to
+* instantiate this directly; use the {@link hashtag} function instead.
+* @typeParam TContextData The type of the context data.
+*/
+var HashtagText = class {
+	type = "inline";
+	#tag;
+	/**
+	* Creates a {@link HashtagText} tree with a tag.
+	* @param tag The hashtag.  It does not matter whether it starts with `"#"`.
+	*/
+	constructor(tag) {
+		this.#tag = tag.trimStart().replace(/^#/, "").trim().replace(/\s+/g, " ");
+	}
+	async *getHtml(session) {
+		yield "<a href=\"";
+		yield encode(session.context.origin);
+		yield "/tags/";
+		yield encode(encodeURIComponent(this.#tag.toLowerCase()));
+		yield "\" class=\"mention hashtag\" rel=\"tag\" target=\"_blank\">#<span>";
+		yield this.#tag;
+		yield "</span></a>";
+	}
+	async *getTags(session) {
+		yield new Hashtag({
+			href: new URL(`/tags/${encodeURIComponent(this.#tag.toLowerCase())}`, session.context.origin),
+			name: `#${this.#tag.toLowerCase()}`
+		});
+	}
+	getCachedObjects() {
+		return [];
+	}
+};
+/**
+* Creates a hashtag.  You can use this function to create a {@link HashtagText}
+* tree.
+* @param tag The hashtag.  It does not matter whether it starts with `"#"`.
+* @returns A {@link HashtagText} tree.
+*/
+function hashtag(tag) {
+	return new HashtagText(tag);
+}
+/**
+* A text tree that renders a `<strong>` text.  You normally don't need to
+* instantiate this directly; use the {@link strong} function instead.
+* @typeParam TContextData The type of the context data.
+*/
+var StrongText = class {
+	type = "inline";
+	#text;
+	/**
+	* Creates a {@link StrongText} tree with a text.
+	* @param text The text to render as `<strong>`.
+	*/
+	constructor(text$1) {
+		this.#text = typeof text$1 === "string" ? new PlainText(text$1) : text$1;
+	}
+	async *getHtml(session) {
+		yield "<strong>";
+		yield* this.#text.getHtml(session);
+		yield "</strong>";
+	}
+	getTags(session) {
+		return this.#text.getTags(session);
+	}
+	getCachedObjects() {
+		return [];
+	}
+};
+/**
+* Applies `<strong>` tag to a text.  You can use this function to create a
+* {@link StrongText} tree.
+* @typeParam TContextData The type of the context data.
+* @param text The text to render as `<strong>`.  It can be a plain text or
+*             another text tree.
+* @returns A {@link StrongText} tree.
+*/
+function strong(text$1) {
+	return new StrongText(text$1);
+}
+/**
+* A text tree that renders an `<em>` text.  You normally don't need to
+* instantiate this directly; use the {@link em} function instead.
+* @typeParam TContextData The type of the context data.
+*/
+var EmText = class {
+	type = "inline";
+	#text;
+	constructor(text$1) {
+		this.#text = typeof text$1 === "string" ? new PlainText(text$1) : text$1;
+	}
+	async *getHtml(session) {
+		yield "<em>";
+		yield* this.#text.getHtml(session);
+		yield "</em>";
+	}
+	getTags(session) {
+		return this.#text.getTags(session);
+	}
+	getCachedObjects() {
+		return [];
+	}
+};
+/**
+* Applies `<em>` tag to a text.  You can use this function to create an
+* {@link EmText} tree.
+* @typeParam TContextData The type of the context data.
+* @param text The text to render as `<em>`.  It can be a plain text or
+*             another text tree.
+* @returns A {@link EmText} tree.
+*/
+function em(text$1) {
+	return new EmText(text$1);
+}
+/**
+* A text tree that renders a link.  You normally don't need to instantiate
+* this directly; use the {@link link} function instead.
+* @typeParam TContextData The type of the context data.
+*/
+var LinkText = class {
+	type = "inline";
+	#label;
+	#href;
+	/**
+	* Creates a {@link LinkText} tree with a label and a URL.
+	* @param label The label of the link.
+	* @param href The URL of the link.  It has to be an absolute URL.
+	*/
+	constructor(label, href) {
+		this.#label = typeof label === "string" ? new PlainText(label) : label;
+		this.#href = typeof href === "string" ? new URL(href) : href;
+	}
+	async *getHtml(session) {
+		yield "<a href=\"";
+		yield encode(this.#href.href);
+		yield "\" target=\"_blank\">";
+		yield* this.#label.getHtml(session);
+		yield "</a>";
+	}
+	getTags(session) {
+		return this.#label.getTags(session);
+	}
+	getCachedObjects() {
+		return this.#label.getCachedObjects();
+	}
+};
+function link(label, href) {
+	return href == null ? new LinkText(String(label), label) : new LinkText(isText(label) ? label : label.toString(), href);
+}
+/**
+* A text tree that renders a inline code.  You normally don't need to
+* instantiate this directly; use the {@link code} function instead.
+* @typeParam TContextData The type of the context data.
+*/
+var CodeText = class {
+	type = "inline";
+	#code;
+	/**
+	* Creates a {@link CodeText} tree with a code.
+	* @param code The code to render.
+	*/
+	constructor(code$1) {
+		this.#code = typeof code$1 === "string" ? new PlainText(code$1) : code$1;
+	}
+	async *getHtml(session) {
+		yield "<code>";
+		yield* this.#code.getHtml(session);
+		yield "</code>";
+	}
+	getTags(session) {
+		return this.#code.getTags(session);
+	}
+	getCachedObjects() {
+		return [];
+	}
+};
+/**
+* Applies `<code>` tag to a text.  You can use this function to create
+* a {@link CodeText} tree.
+* @param code The code to render.
+* @returns A {@link CodeText} tree.
+*/
+function code(code$1) {
+	return new CodeText(code$1);
+}
+/**
+* A text tree that renders a custom emoji.  You normally don't need to
+* instantiate this directly; use the {@link customEmoji} function instead.
+* @typeParam TContextData The type of the context data.
+* @since 0.2.0
+*/
+var CustomEmojiText = class {
+	type = "inline";
+	#emoji;
+	/**
+	* Creates a {@link CustomEmojiText} tree with a custom emoji.
+	* @param emoji The custom emoji to render.
+	*/
+	constructor(emoji) {
+		this.#emoji = emoji;
+	}
+	/**
+	* Gets the emoji object.  If the emoji is a deferred emoji, it will
+	* be resolved with the given session.
+	* @param session The bot session.
+	* @returns The emoji object.
+	*/
+	getEmoji(session) {
+		if (typeof this.#emoji === "function") return this.#emoji(session);
+		return this.#emoji;
+	}
+	async *getHtml(session) {
+		const emoji = this.getEmoji(session);
+		if (emoji.name == null) return;
+		yield "​";
+		yield encode(emoji.name.toString());
+		yield "​";
+	}
+	async *getTags(session) {
+		yield this.getEmoji(session);
+	}
+	getCachedObjects() {
+		return [];
+	}
+};
+/**
+* Renders a custom emoji.  You can use this function to create a
+* {@link CustomEmojiText} tree.
+* @param emoji The custom emoji to render. See also {@link Bot.addCustomEmojis}
+*              method.
+* @returns A {@link CustomEmojiText} tree.
+* @since 0.2.0
+*/
+function customEmoji(emoji) {
+	return new CustomEmojiText(emoji);
+}
+/**
+* A text tree that renders a Markdown text.  You normally don't need to
+* instantiate this directly; use the {@link markdown} function instead.
+*/
+var MarkdownText = class {
+	type = "block";
+	#content;
+	#markdownIt;
+	#mentions;
+	#hashtags;
+	#actors;
+	/**
+	* Creates a {@link MarkdownText} tree with a Markdown content.
+	* @param content The Markdown content.
+	* @param options The options for rendering the Markdown content.
+	*/
+	constructor(content, options = {}) {
+		this.#content = content;
+		const md = MarkdownIt({
+			html: false,
+			linkify: options.linkify ?? true
+		});
+		if (options.mentions ?? true) {
+			md.use(mention$1, {
+				link(handle, env$1) {
+					if (env$1.actors == null) return `acct:${handle}`;
+					return env$1.actors[handle] ?? null;
+				},
+				linkAttributes(_handle, _env) {
+					return {
+						translate: "no",
+						class: "h-card u-url mention",
+						target: "_blank"
+					};
+				},
+				label: toFullHandle
+			});
+			const env = {
+				mentions: [],
+				hashtags: [],
+				origin: "http://localhost"
+			};
+			md.render(content, env);
+			this.#mentions = env.mentions;
+		}
+		if (options.hashtags ?? true) {
+			md.use(hashtag$1, {
+				link(hashtag$2, env$1) {
+					const tag = hashtag$2.substring(1).toLowerCase();
+					return new URL(`/tags/${encodeURIComponent(tag)}`, env$1.origin).href;
+				},
+				linkAttributes(_hashtag, _env) {
+					return {
+						class: "mention hashtag",
+						rel: "tag",
+						target: "_blank"
+					};
+				},
+				label(hashtag$2, _env) {
+					const tag = hashtag$2.substring(1);
+					return `#<span>${tag}</span>`;
+				}
+			});
+			const env = {
+				mentions: [],
+				hashtags: [],
+				origin: "http://localhost"
+			};
+			md.render(content, env);
+			this.#hashtags = env.hashtags;
+		}
+		this.#markdownIt = md;
+	}
+	async #getMentionedActors(session) {
+		if (this.#mentions == null) return {};
+		if (this.#actors != null) return this.#actors;
+		const documentLoader = await session.context.getDocumentLoader(session.bot);
+		const objects = await Promise.all(this.#mentions.map((m) => m === session.actorHandle ? session.getActor() : session.context.lookupObject(m, { documentLoader })));
+		const actors = {};
+		for (let i = 0; i < this.#mentions.length; i++) {
+			const object = objects[i];
+			if (object != null) actors[this.#mentions[i]] = object;
+		}
+		this.#actors = actors;
+		return actors;
+	}
+	async *getHtml(session) {
+		if (this.#mentions == null) {
+			yield this.#markdownIt.render(this.#content);
+			return;
+		}
+		const actors = globalThis.Object.fromEntries(globalThis.Object.entries(await this.#getMentionedActors(session)).filter(([_, obj]) => isActor$1(obj)).map(([handle, actor]) => [handle, (actor.url instanceof Link$1 ? actor.url.href?.href : actor.url?.href) ?? actor.id?.href ?? null]).filter(([_, url]) => url != null));
+		const env = {
+			mentions: [],
+			hashtags: [],
+			origin: session.context.origin,
+			actors
+		};
+		yield this.#markdownIt.render(this.#content, env);
+	}
+	async *getTags(session) {
+		if (this.#mentions == null) return;
+		const actors = await this.#getMentionedActors(session);
+		for (const [handle, object] of globalThis.Object.entries(actors)) {
+			if (!isActor$1(object) || object.id == null) continue;
+			yield new Mention$1({
+				name: handle,
+				href: object.id
+			});
+		}
+		if (this.#hashtags != null) for (const hashtag$2 of this.#hashtags) {
+			const tag = hashtag$2.substring(1).toLowerCase();
+			yield new Hashtag({
+				name: `#${tag}`,
+				href: new URL(`/tags/${encodeURIComponent(tag)}`, session.context.origin)
+			});
+		}
+	}
+	getCachedObjects() {
+		return this.#actors == null ? [] : globalThis.Object.values(this.#actors);
+	}
+};
+/**
+* Renders a Markdown text.  You can use this function to create
+* a {@link MarkdownText} tree.  The mentions in the Markdown text
+* will be rendered as links unless the `mentions` option is set to
+* `false`.
+* @param content The Markdown content.
+* @param options The options for rendering the Markdown content.
+* @returns A {@link MarkdownText} tree.
+*/
+function markdown(content, options = {}) {
+	return new MarkdownText(content, options);
+}
+
+//#endregion
+export { CodeText, CustomEmojiText, EmText, HashtagText, LinkText, MarkdownText, MentionText, PlainText, StrongText, TemplatedText, code, customEmoji, em, hashtag, isText, link, markdown, mention, mentions, plainText, strong, text };
+//# sourceMappingURL=text.js.map