spectrum-ts 0.8.0 → 0.9.1

package/dist/{chunk-H5XYVRHM.js → chunk-HU2EOF3K.js}

@@ -2,10 +2,38 @@ import {
   bufferToStream,
   readSchema,
   streamSchema
-} from "./chunk-ZNUORCLB.js";
+} from "./chunk-OIXH5S65.js";
+import {
+  resolveContents
+} from "./chunk-U6WCQVVX.js";
 
-// src/content/richlink.ts
+// src/content/group.ts
 import z from "zod";
+var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
+var groupSchema = z.object({
+  type: z.literal("group"),
+  items: z.array(z.custom(isMessage)).min(2)
+});
+var asGroup = (input) => groupSchema.parse({ type: "group", items: input.items });
+var stubOutboundMessage = (content) => ({ id: "", content });
+function group(...items) {
+  return {
+    build: async () => {
+      const resolved = await resolveContents(items);
+      const members = [];
+      for (const item of resolved) {
+        if (item.type === "group" || item.type === "reaction") {
+          throw new Error(`group() cannot contain "${item.type}" items`);
+        }
+        members.push(stubOutboundMessage(item));
+      }
+      return asGroup({ items: members });
+    }
+  };
+}
+
+// src/content/richlink.ts
+import z2 from "zod";
 
 // src/utils/link-metadata.ts
 import ogs from "open-graph-scraper";
@@ -76,22 +104,22 @@ var fetchImage = async (url) => {
 };
 
 // src/content/richlink.ts
-var richlinkCoverSchema = z.object({
-  mimeType: z.string().min(1).optional(),
+var richlinkCoverSchema = z2.object({
+  mimeType: z2.string().min(1).optional(),
   read: readSchema,
   stream: streamSchema
 });
-var optionalStringAccessor = z.function({
+var optionalStringAccessor = z2.function({
   input: [],
-  output: z.promise(z.string().min(1).optional())
+  output: z2.promise(z2.string().min(1).optional())
 });
-var coverAccessor = z.function({
+var coverAccessor = z2.function({
   input: [],
-  output: z.promise(richlinkCoverSchema.optional())
+  output: z2.promise(richlinkCoverSchema.optional())
 });
-var richlinkSchema = z.object({
-  type: z.literal("richlink"),
-  url: z.url(),
+var richlinkSchema = z2.object({
+  type: z2.literal("richlink"),
+  url: z2.url(),
   title: optionalStringAccessor,
   summary: optionalStringAccessor,
   cover: coverAccessor
@@ -136,6 +164,8 @@ function richlink(url) {
 }
 
 export {
+  asGroup,
+  group,
   asRichlink,
   richlink
 };

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

@@ -553,6 +553,21 @@ function custom(raw) {
   };
 }
 
+// src/content/reaction.ts
+import z5 from "zod";
+var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
+var reactionSchema = z5.object({
+  type: z5.literal("reaction"),
+  emoji: z5.string().min(1),
+  target: z5.custom(isMessage, {
+    message: "reaction target must be a Message"
+  })
+});
+var asReaction = (input) => reactionSchema.parse({ type: "reaction", ...input });
+function reaction(emoji, target) {
+  return { build: async () => asReaction({ emoji, target }) };
+}
+
 // src/utils/stream.ts
 import { Repeater } from "@repeaterjs/repeater";
 function stream(setup) {
@@ -688,6 +703,8 @@ export {
   contact,
   asCustom,
   custom,
+  asReaction,
+  reaction,
   stream,
   mergeStreams,
   SpectrumCloudError,

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

@@ -88,37 +88,117 @@ var warnUnsupported = (err, fallbackPlatform) => {
     supportsAnsiColor() ? `${ANSI_YELLOW}${body}${ANSI_RESET}` : body
   );
 };
+var providerMessageCoreKeys = /* @__PURE__ */ new Set([
+  "content",
+  "id",
+  "sender",
+  "space",
+  "timestamp"
+]);
+var extractExtras = (raw, definition) => {
+  const entries = Object.entries(raw).filter(
+    ([key]) => !providerMessageCoreKeys.has(key)
+  );
+  const extra = Object.fromEntries(entries);
+  return definition.message?.schema ? definition.message.schema.parse(extra) : extra;
+};
+function wrapProviderMessage(raw, ctx) {
+  const wrappedContent = wrapNestedContent(raw.content, ctx);
+  return buildMessage({
+    id: raw.id,
+    content: wrappedContent,
+    sender: raw.sender,
+    timestamp: raw.timestamp ?? /* @__PURE__ */ new Date(),
+    extras: extractExtras(raw, ctx.definition),
+    spaceRef: ctx.spaceRef,
+    space: ctx.space,
+    definition: ctx.definition,
+    client: ctx.client,
+    config: ctx.config,
+    direction: "inbound"
+  });
+}
+var wrapNestedContent = (content, ctx) => {
+  if (content.type === "reaction") {
+    const target = content.target;
+    if (isRawProviderRecord(target)) {
+      return {
+        ...content,
+        target: wrapProviderMessage(target, ctx)
+      };
+    }
+    return content;
+  }
+  if (content.type === "group") {
+    const items = content.items.map((item) => {
+      const raw = item;
+      return isRawProviderRecord(raw) ? wrapProviderMessage(raw, ctx) : item;
+    });
+    return { ...content, items };
+  }
+  return content;
+};
+var isRawProviderRecord = (v) => {
+  if (typeof v !== "object" || v === null) {
+    return false;
+  }
+  const record = v;
+  return "id" in record && "content" in record && typeof record.react !== "function" && typeof record.reply !== "function";
+};
 function buildSpace(params) {
   const { spaceRef, extras, typingCtx, definition, client, config } = params;
   let space;
-  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;
+  async function dispatchReaction(item) {
+    try {
+      if (!definition.actions.reactToMessage) {
+        throw UnsupportedError.action("react", definition.name);
       }
-      if (!sendResult?.id) {
-        throw new Error(
-          `Platform "${definition.name}" send did not return a message id`
-        );
+      await definition.actions.reactToMessage({
+        space: spaceRef,
+        target: item.target,
+        reaction: item.emoji,
+        client,
+        config
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
       }
-      results.push(
-        buildMessage({
-          id: sendResult.id,
-          content: item,
-          sender: sendResult.sender,
-          timestamp: sendResult.timestamp ?? /* @__PURE__ */ new Date(),
+      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`
+      );
+    }
+    const outboundContent = item.type === "group" && sendResult.groupMembers ? {
+      ...item,
+      items: item.items.map((stub, idx) => {
+        const member = sendResult?.groupMembers?.[idx];
+        if (!member?.id) {
+          return stub;
+        }
+        return buildMessage({
+          id: member.id,
+          content: stub.content,
+          sender: member.sender,
+          timestamp: member.timestamp ?? /* @__PURE__ */ new Date(),
           extras: {},
           spaceRef,
           space,
@@ -126,14 +206,75 @@ function buildSpace(params) {
           client,
           config,
           direction: "outbound"
-        })
-      );
+        });
+      })
+    } : item;
+    return buildMessage({
+      id: sendResult.id,
+      content: outboundContent,
+      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) {
+      if (item.type === "reaction") {
+        await dispatchReaction(item);
+        continue;
+      }
+      const sent = await dispatchSend(item);
+      if (sent) {
+        results.push(sent);
+      }
     }
     if (content.length === 1) {
       return results[0];
     }
     return results;
   }
+  async function getMessageImpl(id) {
+    if (!definition.actions.getMessage) {
+      warnUnsupported(
+        UnsupportedError.action("getMessage", definition.name),
+        definition.name
+      );
+      return;
+    }
+    let raw;
+    try {
+      raw = await definition.actions.getMessage({
+        space: spaceRef,
+        messageId: id,
+        client,
+        config
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
+      }
+      throw err;
+    }
+    if (!raw) {
+      return;
+    }
+    return wrapProviderMessage(raw, {
+      client,
+      config,
+      definition,
+      space,
+      spaceRef
+    });
+  }
   space = {
     ...extras,
     ...spaceRef,
@@ -141,6 +282,7 @@ function buildSpace(params) {
     edit: async (message, newContent) => {
       await message.edit(newContent);
     },
+    getMessage: getMessageImpl,
     startTyping: async () => {
       await definition.actions.startTyping?.(typingCtx);
     },
@@ -161,6 +303,7 @@ function buildSpace(params) {
 }
 function buildMessage(params) {
   const { definition, client, config, spaceRef, space } = params;
+  let self;
   const react = async (reaction) => {
     if (!definition.actions.reactToMessage) {
       warnUnsupported(
@@ -169,13 +312,26 @@ function buildMessage(params) {
       );
       return;
     }
-    await definition.actions.reactToMessage({
-      space: spaceRef,
-      messageId: params.id,
-      reaction,
-      client,
-      config
-    });
+    if (!self) {
+      throw new Error(
+        "react() called before message construction completed (internal bug)"
+      );
+    }
+    try {
+      await definition.actions.reactToMessage({
+        space: spaceRef,
+        target: self,
+        reaction,
+        client,
+        config
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
+      }
+      throw err;
+    }
   };
   async function reply(...content) {
     if (!definition.actions.replyToMessage) {
@@ -232,7 +388,7 @@ function buildMessage(params) {
   }
   const senderWithPlatform = params.sender === void 0 ? void 0 : { ...params.sender, __platform: definition.name };
   if (params.direction === "outbound") {
-    return {
+    const outbound = {
       ...params.extras,
       id: params.id,
       content: params.content,
@@ -272,8 +428,10 @@ function buildMessage(params) {
       space,
       timestamp: params.timestamp
     };
+    self = outbound;
+    return outbound;
   }
-  return {
+  const inbound = {
     ...params.extras,
     id: params.id,
     content: params.content,
@@ -285,6 +443,8 @@ function buildMessage(params) {
     space,
     timestamp: params.timestamp
   };
+  self = inbound;
+  return inbound;
 }
 
 // src/platform/define.ts
@@ -471,7 +631,7 @@ export {
   text,
   resolveContents,
   UnsupportedError,
+  wrapProviderMessage,
   buildSpace,
-  buildMessage,
   definePlatform
 };