Quotes

Author: dahlia

CHANGES.md

@@ -34,6 +34,11 @@ To be released.
      -  Added `ReactionEventHandler` type.
      -  Added `UndoneReactionEventHandler` type.
 
+ -  Added quote support.
+
+     -  Added `SessionPublishOptions.quoteTarget` option.
+     -  Added `Message.quoteTarget` property.
+
  -  Added `SessionGetOutboxOptions` interface.
 
 

docs/concepts/message.md

@@ -209,6 +209,23 @@ await session.publish(text`你好，世界！`, {
 
 [BCP 47]: https://tools.ietf.org/html/bcp47
 
+### Quoting
+
+*This API is available since BotKit 0.2.0.*
+
+You can quote a message by providing `~SessionPublishOptions.quoteTarget`
+option.  The value of the option has to be a `Message` object that you want
+to quote.  For example:
+
+~~~~ typescript
+bot.onMention = async (session, message) => {
+  await session.publish(
+    text`This message quotes the message.`,
+    { quoteTarget: message },  // [!code highlight]
+  );
+};
+~~~~
+
 
 Extracting information from a message
 -------------------------------------
@@ -392,6 +409,26 @@ object.
 
 [`Temporal.Instant`]: https://tc39.es/proposal-temporal/docs/instant.html
 
+### Quotes
+
+*This API is available since BotKit 0.2.0.*
+
+You can get the message that is quoted in the message through
+the `~Message.quoteTarget` property.  It is either another `Message` object
+or `undefined` if the message is not a quote.
+
+Since the quoted message itself can be a quote, you can traverse the
+conversation by following the `~Message.quoteTarget` property recursively:
+
+~~~~ typescript
+let quote: Message<MessageClass, void> | undefined = message.quoteTarget;
+while (quote != null) {
+  console.log(quote);
+  quote = quote.quoteTarget;
+}
+~~~~
+
+
 ### Want more?
 
 If you want more data from the message, you can get the raw object of

src/message-impl.test.ts

@@ -211,6 +211,7 @@ Deno.test("AuthorizedMessageImpl.delete()", async () => {
     session,
     {},
     undefined,
+    undefined,
     true,
   );
   await repository.addMessage(

src/message-impl.ts

@@ -27,7 +27,7 @@ import {
   Hashtag,
   isActor,
   Like as RawLike,
-  type Link,
+  Link,
   Mention,
   Note,
   type Object,
@@ -39,6 +39,7 @@ import {
 } from "@fedify/fedify/vocab";
 import type { LanguageTag } from "@phensley/language-tag";
 import { unescape } from "@std/html/entities";
+import { parseMediaType } from "@std/media-types/parse-media-type";
 import { generate as uuidv7 } from "@std/uuid/unstable-v7";
 import { FilterXSS, getDefaultWhiteList } from "xss";
 import type { DeferredCustomEmoji, Emoji } from "./emoji.ts";
@@ -90,6 +91,7 @@ export class MessageImpl<T extends MessageClass, TContextData>
   text: string;
   html: string;
   readonly replyTarget?: Message<MessageClass, TContextData> | undefined;
+  readonly quoteTarget?: Message<MessageClass, TContextData> | undefined;
   mentions: readonly Actor[];
   hashtags: readonly Hashtag[];
   readonly attachments: readonly Document[];
@@ -112,6 +114,7 @@ export class MessageImpl<T extends MessageClass, TContextData>
     this.text = message.text;
     this.html = message.html;
     this.replyTarget = message.replyTarget;
+    this.quoteTarget = message.quoteTarget;
     this.mentions = message.mentions;
     this.hashtags = message.hashtags;
     this.attachments = message.attachments;
@@ -121,17 +124,17 @@ export class MessageImpl<T extends MessageClass, TContextData>
 
   reply(
     text: Text<"block", TContextData>,
-    options?: SessionPublishOptions,
+    options?: SessionPublishOptions<TContextData>,
   ): Promise<AuthorizedMessage<Note, TContextData>>;
   reply<T extends MessageClass>(
     text: Text<"block", TContextData>,
-    options?: SessionPublishOptionsWithClass<T> | undefined,
+    options?: SessionPublishOptionsWithClass<T, TContextData> | undefined,
   ): Promise<AuthorizedMessage<T, TContextData>>;
   reply(
     text: Text<"block", TContextData>,
     options?:
-      | SessionPublishOptions
-      | SessionPublishOptionsWithClass<MessageClass>,
+      | SessionPublishOptions<TContextData>
+      | SessionPublishOptionsWithClass<MessageClass, TContextData>,
   ): Promise<AuthorizedMessage<MessageClass, TContextData>> {
     return this.session.publish(text, {
       visibility: this.visibility === "unknown" ? "direct" : this.visibility,
@@ -544,20 +547,23 @@ export async function createMessage<T extends MessageClass, TContextData>(
   session: SessionImpl<TContextData>,
   cachedObjects: Record<string, Object>,
   replyTarget?: Message<MessageClass, TContextData>,
+  quote?: Message<MessageClass, TContextData>,
   authorized?: true,
 ): Promise<AuthorizedMessage<T, TContextData>>;
 export async function createMessage<T extends MessageClass, TContextData>(
   raw: T,
   session: SessionImpl<TContextData>,
   cachedObjects: Record<string, Object>,
   replyTarget?: Message<MessageClass, TContextData>,
+  quote?: Message<MessageClass, TContextData>,
   authorized?: boolean,
 ): Promise<Message<T, TContextData>>;
 export async function createMessage<T extends MessageClass, TContextData>(
   raw: T,
   session: SessionImpl<TContextData>,
   cachedObjects: Record<string, Object>,
   replyTarget?: Message<MessageClass, TContextData>,
+  quoteTarget?: Message<MessageClass, TContextData>,
   authorized: boolean = false,
 ): Promise<Message<T, TContextData>> {
   if (raw.id == null) throw new TypeError("The raw.id is required.");
@@ -582,6 +588,7 @@ export async function createMessage<T extends MessageClass, TContextData>(
   const mentions: Actor[] = [];
   const mentionedActorIds = new Set<string>();
   const hashtags: Hashtag[] = [];
+  const quoteLinks: Link[] = [];
   for await (const tag of raw.getTags(options)) {
     if (tag instanceof Mention && tag.href != null) {
       const obj = tag.href.href === session.actorId?.href
@@ -593,6 +600,18 @@ export async function createMessage<T extends MessageClass, TContextData>(
       mentionedActorIds.add(tag.href.href);
     } else if (tag instanceof Hashtag) {
       hashtags.push(tag);
+    } else if (tag instanceof Link) {
+      const mediaType = tag.mediaType == null
+        ? null
+        : parseMediaType(tag.mediaType);
+      if (
+        tag.rel === "https://misskey-hub.net/ns#_misskey_quote" ||
+        mediaType?.[0] === "application/activity+json" ||
+        mediaType?.[0] === "application/ld+json" &&
+          mediaType[1]?.profile === "https://www.w3.org/ns/activitystreams"
+      ) {
+        quoteLinks.push(tag);
+      }
     }
   }
   const attachments: Document[] = [];
@@ -612,14 +631,46 @@ export async function createMessage<T extends MessageClass, TContextData>(
         session.context,
         parsed.values.id,
       );
-    } else rt = await raw.getReplyTarget(options);
+    } else {
+      rt = await raw.getReplyTarget(options);
+    }
     if (
       rt instanceof Article || rt instanceof ChatMessage ||
       rt instanceof Note || rt instanceof Question
     ) {
       replyTarget = await createMessage(rt, session, cachedObjects);
     }
   }
+  if (quoteTarget == null) {
+    let quoteUrl: URL | null = null;
+    for (const quoteLink of quoteLinks) {
+      if (quoteLink.href == null) continue;
+      quoteUrl = quoteLink.href;
+      break;
+    }
+    if (quoteUrl == null) quoteUrl = raw.quoteUrl;
+    let qt: Object | null = null;
+    const parsed = session.context.parseUri(quoteUrl);
+    // @ts-ignore: The `class` property satisfies the `MessageClass` type.
+    if (parsed?.type === "object" && messageClasses.includes(parsed.class)) {
+      // @ts-ignore: The `class` property satisfies the `MessageClass` type.
+      // deno-lint-ignore no-explicit-any
+      const cls: new (values: any) => T = parsed.class;
+      qt = await session.bot.dispatchMessage(
+        cls,
+        session.context,
+        parsed.values.id,
+      );
+    } else if (quoteUrl != null) {
+      qt = await session.context.lookupObject(quoteUrl, options);
+    }
+    if (
+      qt instanceof Article || qt instanceof ChatMessage ||
+      qt instanceof Note || qt instanceof Question
+    ) {
+      quoteTarget = await createMessage(qt, session, cachedObjects);
+    }
+  }
   return new (authorized ? AuthorizedMessageImpl : MessageImpl)(session, {
     raw,
     id: raw.id,
@@ -636,6 +687,7 @@ export async function createMessage<T extends MessageClass, TContextData>(
     text: unescape(text),
     html,
     replyTarget,
+    quoteTarget,
     mentions,
     hashtags,
     attachments,

src/message.ts

@@ -146,6 +146,12 @@ export interface Message<T extends MessageClass, TContextData> {
    */
   readonly attachments: readonly Document[];
 
+  /**
+   * The message quoted by this message, if any.
+   * @since 0.2.0
+   */
+  readonly quoteTarget?: Message<MessageClass, TContextData>;
+
   /**
    * The published time of the message.
    */
@@ -164,7 +170,7 @@ export interface Message<T extends MessageClass, TContextData> {
    */
   reply(
     text: Text<"block", TContextData>,
-    options?: SessionPublishOptions,
+    options?: SessionPublishOptions<TContextData>,
   ): Promise<AuthorizedMessage<Note, TContextData>>;
 
   /**
@@ -176,7 +182,7 @@ export interface Message<T extends MessageClass, TContextData> {
    */
   reply<T extends MessageClass>(
     text: Text<"block", TContextData>,
-    options?: SessionPublishOptionsWithClass<T>,
+    options?: SessionPublishOptionsWithClass<T, TContextData>,
   ): Promise<AuthorizedMessage<T, TContextData>>;
 
   /**

src/session-impl.test.ts

@@ -30,6 +30,7 @@ import { assertFalse } from "@std/assert/false";
 import { assertInstanceOf } from "@std/assert/instance-of";
 import { assertRejects } from "@std/assert/rejects";
 import { BotImpl } from "./bot-impl.ts";
+import { createMessage } from "./message-impl.ts";
 import { MemoryRepository, type Uuid } from "./repository.ts";
 import { SessionImpl } from "./session-impl.ts";
 import { mention, text } from "./text.ts";
@@ -386,6 +387,71 @@ Deno.test("SessionImpl.publish()", async (t) => {
     assertEquals(directMsg.visibility, "direct");
     // assertEquals(directMsg.mentions, [mentioned]); // FIXME
   });
+
+  ctx.sentActivities = [];
+
+  await t.step("quote", async () => {
+    const originalAuthor = new Person({
+      id: new URL("https://example.com/ap/actor/john"),
+      preferredUsername: "john",
+    });
+    const originalPost = new Note({
+      id: new URL(
+        "https://example.com/ap/note/c1c792ce-a0be-4685-b396-e59e5ef8c788",
+      ),
+      content: "<p>Hello, world!</p>",
+      attribution: originalAuthor,
+      to: new URL("https://example.com/ap/actor/john/followers"),
+      cc: PUBLIC_COLLECTION,
+    });
+    const originalMsg = await createMessage<Note, void>(
+      originalPost,
+      session,
+      {},
+    );
+    const quote = await session.publish(text`Check this out!`, {
+      quoteTarget: originalMsg,
+    });
+    assertEquals(ctx.sentActivities.length, 2);
+    const { recipients, activity } = ctx.sentActivities[0];
+    assertEquals(recipients, "followers");
+    assertInstanceOf(activity, Create);
+    assertEquals(activity.actorId, ctx.getActorUri(bot.identifier));
+    assertEquals(activity.toIds, [PUBLIC_COLLECTION]);
+    assertEquals(activity.ccIds, [ctx.getFollowersUri(bot.identifier)]);
+    const object = await activity.getObject(ctx);
+    const { recipients: recipients2, activity: activity2 } =
+      ctx.sentActivities[1];
+    assertEquals(recipients2, [originalAuthor]);
+    assertInstanceOf(activity2, Create);
+    assertEquals(activity2.actorId, ctx.getActorUri(bot.identifier));
+    assertEquals(activity2.toIds, [PUBLIC_COLLECTION]);
+    assertEquals(activity2.ccIds, [ctx.getFollowersUri(bot.identifier)]);
+    assertInstanceOf(object, Note);
+    assertEquals(object.attributionId, ctx.getActorUri(bot.identifier));
+    assertEquals(object.toIds, [PUBLIC_COLLECTION]);
+    assertEquals(object.ccIds, [ctx.getFollowersUri(bot.identifier)]);
+    assertEquals(
+      object.content,
+      `<p>Check this out!</p>
+
+<p class="quote-inline"><br>RE: <a href="${originalMsg.id.href}">${originalMsg.id.href}</a></p>`,
+    );
+    assertEquals(object.quoteUrl, originalMsg.id);
+    assertEquals(quote.id, object.id);
+    assertEquals(
+      quote.text,
+      `Check this out!\n\nRE: ${originalMsg.id.href}`,
+    );
+    assertEquals(
+      quote.html,
+      `<p>Check this out!</p>
+
+<p><br>RE: <a href="${originalMsg.id.href}">${originalMsg.id.href}</a></p>`,
+    );
+    assertEquals(quote.visibility, "public");
+    assertEquals(quote.quoteTarget?.id, originalMsg.id);
+  });
 });
 
 Deno.test("SessionImpl.getOutbox()", async (t) => {