spectrum-ts 0.8.0 → 0.9.0

package/dist/{chunk-H5XYVRHM.js → chunk-6ZOLTQDN.js}

@@ -2,7 +2,7 @@ import {
   bufferToStream,
   readSchema,
   streamSchema
-} from "./chunk-ZNUORCLB.js";
+} from "./chunk-CZIWNTXP.js";
 
 // src/content/richlink.ts
 import z from "zod";

package/dist/{chunk-ZNUORCLB.js → chunk-CZIWNTXP.js}

@@ -553,6 +553,19 @@ function custom(raw) {
   };
 }
 
+// src/content/reaction.ts
+import z5 from "zod";
+var reactionSchema = z5.object({
+  type: z5.literal("reaction"),
+  emoji: z5.string().min(1),
+  target: z5.string().min(1)
+});
+var asReaction = (input) => reactionSchema.parse({ type: "reaction", ...input });
+function reaction(emoji, target) {
+  const targetId = typeof target === "string" ? target : target.id;
+  return { build: async () => asReaction({ emoji, target: targetId }) };
+}
+
 // src/utils/stream.ts
 import { Repeater } from "@repeaterjs/repeater";
 function stream(setup) {
@@ -688,6 +701,8 @@ export {
   contact,
   asCustom,
   custom,
+  asReaction,
+  reaction,
   stream,
   mergeStreams,
   SpectrumCloudError,

package/dist/{chunk-4O6MQC5Z.js → chunk-PLJI5FTO.js}

@@ -91,43 +91,71 @@ var warnUnsupported = (err, fallbackPlatform) => {
 function buildSpace(params) {
   const { spaceRef, extras, typingCtx, definition, client, config } = params;
   let space;
+  async function dispatchReaction(item) {
+    try {
+      if (!definition.actions.reactToMessage) {
+        throw UnsupportedError.action("react", definition.name);
+      }
+      await definition.actions.reactToMessage({
+        space: spaceRef,
+        messageId: item.target,
+        reaction: item.emoji,
+        client,
+        config
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
+      }
+      throw err;
+    }
+  }
+  async function dispatchSend(item) {
+    let sendResult;
+    try {
+      sendResult = await definition.actions.send({
+        ...typingCtx,
+        content: item
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
+      }
+      throw err;
+    }
+    if (!sendResult?.id) {
+      throw new Error(
+        `Platform "${definition.name}" send did not return a message id`
+      );
+    }
+    return buildMessage({
+      id: sendResult.id,
+      content: item,
+      sender: sendResult.sender,
+      timestamp: sendResult.timestamp ?? /* @__PURE__ */ new Date(),
+      extras: {},
+      spaceRef,
+      space,
+      definition,
+      client,
+      config,
+      direction: "outbound"
+    });
+  }
   async function sendImpl(...content) {
     const resolved = await resolveContents(content);
     const results = [];
     for (const item of resolved) {
-      let sendResult;
-      try {
-        sendResult = await definition.actions.send({
-          ...typingCtx,
-          content: item
-        });
-      } catch (err) {
-        if (err instanceof UnsupportedError) {
-          warnUnsupported(err, definition.name);
-          continue;
-        }
-        throw err;
+      if (item.type === "reaction") {
+        await dispatchReaction(item);
+        continue;
       }
-      if (!sendResult?.id) {
-        throw new Error(
-          `Platform "${definition.name}" send did not return a message id`
-        );
+      const sent = await dispatchSend(item);
+      if (sent) {
+        results.push(sent);
       }
-      results.push(
-        buildMessage({
-          id: sendResult.id,
-          content: item,
-          sender: sendResult.sender,
-          timestamp: sendResult.timestamp ?? /* @__PURE__ */ new Date(),
-          extras: {},
-          spaceRef,
-          space,
-          definition,
-          client,
-          config,
-          direction: "outbound"
-        })
-      );
     }
     if (content.length === 1) {
       return results[0];
@@ -169,13 +197,21 @@ function buildMessage(params) {
       );
       return;
     }
-    await definition.actions.reactToMessage({
-      space: spaceRef,
-      messageId: params.id,
-      reaction,
-      client,
-      config
-    });
+    try {
+      await definition.actions.reactToMessage({
+        space: spaceRef,
+        messageId: params.id,
+        reaction,
+        client,
+        config
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
+      }
+      throw err;
+    }
   };
   async function reply(...content) {
     if (!definition.actions.replyToMessage) {