spectrum-ts 1.4.0 → 1.7.1

package/dist/{chunk-LH4YEBG3.js → chunk-JWWIFSI7.js}

@@ -128,7 +128,7 @@ var mapPhoneType = (prop) => {
   if (types.length > 0) {
     return "other";
   }
-  return void 0;
+  return;
 };
 var mapSimpleType = (prop) => {
   const types = paramTypes(prop);
@@ -141,14 +141,14 @@ var mapSimpleType = (prop) => {
   if (types.length > 0) {
     return "other";
   }
-  return void 0;
+  return;
 };
 var splitStructured = (value) => value.split(";").map((part) => part.trim());
 var extractName = (card) => {
   const fn = propString(card.data.fn);
   const n = propString(card.data.n);
   if (!(fn || n)) {
-    return void 0;
+    return;
   }
   const result = {};
   if (fn) {
@@ -177,7 +177,7 @@ var extractName = (card) => {
 var extractPhones = (card) => {
   const props = asPropertyArray(card.data.tel);
   if (props.length === 0) {
-    return void 0;
+    return;
   }
   return props.map((p) => {
     const entry = { value: p.valueOf().trim() };
@@ -191,7 +191,7 @@ var extractPhones = (card) => {
 var extractEmails = (card) => {
   const props = asPropertyArray(card.data.email);
   if (props.length === 0) {
-    return void 0;
+    return;
   }
   return props.map((p) => {
     const entry = { value: p.valueOf().trim() };
@@ -205,7 +205,7 @@ var extractEmails = (card) => {
 var extractAddresses = (card) => {
   const props = asPropertyArray(card.data.adr);
   if (props.length === 0) {
-    return void 0;
+    return;
   }
   return props.map((p) => {
     const [, , street, city, region, postalCode, country] = splitStructured(
@@ -238,7 +238,7 @@ var extractOrg = (card) => {
   const orgStr = propString(card.data.org);
   const title = propString(card.data.title);
   if (!(orgStr || title)) {
-    return void 0;
+    return;
   }
   const result = {};
   if (orgStr) {
@@ -258,7 +258,7 @@ var extractOrg = (card) => {
 var extractUrls = (card) => {
   const props = asPropertyArray(card.data.url);
   if (props.length === 0) {
-    return void 0;
+    return;
   }
   return props.map((p) => p.valueOf().trim());
 };
@@ -276,7 +276,7 @@ var DATA_URI_PATTERN = /^data:([^;,]+);base64,(.*)$/i;
 var extractPhoto = (card) => {
   const [prop] = asPropertyArray(card.data.photo);
   if (!prop) {
-    return void 0;
+    return;
   }
   const value = prop.valueOf();
   const dataUriMatch = DATA_URI_PATTERN.exec(value);
@@ -362,7 +362,7 @@ var phoneTypeParam = (type) => {
   if (type === "home" || type === "work" || type === "other") {
     return type.toUpperCase();
   }
-  return void 0;
+  return;
 };
 var simpleTypeParam = (type) => type ? type.toUpperCase() : void 0;
 var photoTypeParam = (mimeType) => {
@@ -571,19 +571,96 @@ var resolveContents = (items) => Promise.all(
   items.map((c) => typeof c === "string" ? text(c).build() : c.build())
 );
 
-// src/content/reaction.ts
+// src/content/edit.ts
 import z6 from "zod";
 var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
-var reactionSchema = z6.object({
-  type: z6.literal("reaction"),
-  emoji: z6.string().min(1),
+var isContent = (v) => typeof v === "object" && v !== null && "type" in v && typeof v.type === "string";
+var editSchema = z6.object({
+  type: z6.literal("edit"),
+  content: z6.custom(isContent, {
+    message: "edit content must be a Content value"
+  }),
   target: z6.custom(isMessage, {
+    message: "edit target must be a Message"
+  })
+});
+var asEdit = (input) => editSchema.parse({ type: "edit", ...input });
+function edit(content, target) {
+  return {
+    build: async () => {
+      const [resolved] = await resolveContents([content]);
+      if (!resolved) {
+        throw new Error("edit() requires content");
+      }
+      if (resolved.type === "edit" || resolved.type === "reply" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing") {
+        throw new Error(`edit() cannot wrap "${resolved.type}" content`);
+      }
+      return asEdit({ content: resolved, target });
+    }
+  };
+}
+
+// src/content/reaction.ts
+import z7 from "zod";
+var isMessage2 = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
+var reactionSchema = z7.object({
+  type: z7.literal("reaction"),
+  emoji: z7.string().min(1),
+  target: z7.custom(isMessage2, {
     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 }) };
+  return {
+    build: async () => {
+      if (target.content.type === "reaction") {
+        throw new Error('reaction() cannot target "reaction" content');
+      }
+      return asReaction({ emoji, target });
+    }
+  };
+}
+
+// src/content/reply.ts
+import z8 from "zod";
+var isMessage3 = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
+var isContent2 = (v) => typeof v === "object" && v !== null && "type" in v && typeof v.type === "string";
+var replySchema = z8.object({
+  type: z8.literal("reply"),
+  content: z8.custom(isContent2, {
+    message: "reply content must be a Content value"
+  }),
+  target: z8.custom(isMessage3, {
+    message: "reply target must be a Message"
+  })
+});
+var asReply = (input) => replySchema.parse({ type: "reply", ...input });
+function reply(content, target) {
+  return {
+    build: async () => {
+      const [resolved] = await resolveContents([content]);
+      if (!resolved) {
+        throw new Error("reply() requires content");
+      }
+      if (resolved.type === "reply" || resolved.type === "edit" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing") {
+        throw new Error(`reply() cannot wrap "${resolved.type}" content`);
+      }
+      return asReply({ content: resolved, target });
+    }
+  };
+}
+
+// src/content/typing.ts
+import z9 from "zod";
+var typingSchema = z9.object({
+  type: z9.literal("typing"),
+  state: z9.enum(["start", "stop"])
+});
+function typing(state = "start") {
+  return {
+    build: async () => typingSchema.parse({ type: "typing", state })
+  };
 }
 
 // src/utils/errors.ts
@@ -649,6 +726,28 @@ var supportsAnsiColor = () => {
   }
   return Boolean(process.stderr?.isTTY);
 };
+var FIRE_AND_FORGET_TYPES = /* @__PURE__ */ new Set([
+  "reaction",
+  "typing",
+  "edit"
+]);
+var isFireAndForget = (item) => FIRE_AND_FORGET_TYPES.has(item.type) || item.__fireAndForget === true;
+var RESERVED_SPACE_KEYS = /* @__PURE__ */ new Set([
+  "__platform",
+  "id",
+  "send",
+  "edit",
+  "getMessage",
+  "startTyping",
+  "stopTyping",
+  "responding"
+]);
+var warnReservedAction = (name, platform) => {
+  const body = `[spectrum-ts] ${platform} declared space action "${name}" which collides with a reserved Space key; skipping.`;
+  console.warn(
+    supportsAnsiColor() ? `${ANSI_YELLOW}${body}${ANSI_RESET}` : body
+  );
+};
 var warnUnsupported = (err, fallbackPlatform) => {
   const platform = err.platform ?? fallbackPlatform;
   const subject = err.kind === "content" ? `content type "${err.contentType ?? "unknown"}"` : `action "${err.action ?? "unknown"}"`;
@@ -667,6 +766,9 @@ var findUnsupportedPlatformContent = (content, platform) => {
   if (scopedPlatform && scopedPlatform !== platform) {
     return scopedPlatform;
   }
+  if (content.type === "reply" || content.type === "edit") {
+    return findUnsupportedPlatformContent(content.content, platform);
+  }
   if (content.type !== "group") {
     return;
   }
@@ -744,6 +846,16 @@ var wrapNestedContent = (content, ctx, direction) => {
     }
     return content;
   }
+  if (content.type === "edit") {
+    const target = content.target;
+    if (isRawProviderRecord(target)) {
+      return {
+        ...content,
+        target: wrapProviderMessage(target, ctx, "outbound")
+      };
+    }
+    return content;
+  }
   if (content.type === "group") {
     const items = content.items.map((item) => {
       const raw = item;
@@ -764,29 +876,8 @@ var isRawProviderRecord = (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, store } = params;
+  const { spaceRef, extras, actionCtx, definition, client, config, store } = params;
   let space;
-  async function dispatchReaction(item) {
-    try {
-      if (!definition.actions.reactToMessage) {
-        throw UnsupportedError.action("react", definition.name);
-      }
-      await definition.actions.reactToMessage({
-        space: spaceRef,
-        target: item.target,
-        reaction: item.emoji,
-        client,
-        config,
-        store
-      });
-    } catch (err) {
-      if (err instanceof UnsupportedError) {
-        warnUnsupported(err, definition.name);
-        return;
-      }
-      throw err;
-    }
-  }
   async function dispatchSend(item) {
     let raw;
     try {
@@ -797,8 +888,8 @@ function buildSpace(params) {
       if (platformError) {
         throw platformError;
       }
-      raw = await definition.actions.send({
-        ...typingCtx,
+      raw = await definition.send({
+        ...actionCtx,
         content: item
       });
     } catch (err) {
@@ -809,6 +900,9 @@ function buildSpace(params) {
       throw err;
     }
     if (!raw?.id) {
+      if (isFireAndForget(item)) {
+        return;
+      }
       throw new Error(
         `Platform "${definition.name}" send did not return a message id`
       );
@@ -823,10 +917,6 @@ function buildSpace(params) {
     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);
@@ -838,7 +928,8 @@ function buildSpace(params) {
     return results;
   }
   async function getMessageImpl(id) {
-    if (!definition.actions.getMessage) {
+    const getMessage = definition.actions?.getMessage;
+    if (!getMessage) {
       warnUnsupported(
         UnsupportedError.action("getMessage", definition.name),
         definition.name
@@ -847,7 +938,7 @@ function buildSpace(params) {
     }
     let raw;
     try {
-      raw = await definition.actions.getMessage({
+      raw = await getMessage({
         space: spaceRef,
         messageId: id,
         client,
@@ -870,26 +961,38 @@ function buildSpace(params) {
       "inbound"
     );
   }
+  const platformActions = {};
+  const declaredActions = definition.space.actions;
+  if (declaredActions) {
+    for (const [name, factory] of Object.entries(declaredActions)) {
+      if (RESERVED_SPACE_KEYS.has(name)) {
+        warnReservedAction(name, definition.name);
+        continue;
+      }
+      platformActions[name] = (...args) => space.send(factory(...args));
+    }
+  }
   space = {
     ...extras,
     ...spaceRef,
+    ...platformActions,
     send: sendImpl,
     edit: async (message, newContent) => {
-      await message.edit(newContent);
+      await space.send(edit(newContent, message));
     },
     getMessage: getMessageImpl,
     startTyping: async () => {
-      await definition.actions.startTyping?.(typingCtx);
+      await space.send(typing("start"));
     },
     stopTyping: async () => {
-      await definition.actions.stopTyping?.(typingCtx);
+      await space.send(typing("stop"));
     },
     responding: async (fn) => {
-      await definition.actions.startTyping?.(typingCtx);
+      await space.send(typing("start"));
       try {
         return await fn();
       } finally {
-        await definition.actions.stopTyping?.(typingCtx).catch(() => {
+        await space.send(typing("stop")).catch(() => {
         });
       }
     }
@@ -897,37 +1000,11 @@ function buildSpace(params) {
   return space;
 }
 function buildMessage(params) {
-  const { definition, client, config, spaceRef, space, store } = params;
+  const { definition, space } = params;
   let self;
-  const react = async (reaction2) => {
-    if (!definition.actions.reactToMessage) {
-      warnUnsupported(
-        UnsupportedError.action("react", definition.name),
-        definition.name
-      );
-      return;
-    }
-    if (!self) {
-      throw new Error(
-        "react() called before message construction completed (internal bug)"
-      );
-    }
-    try {
-      await definition.actions.reactToMessage({
-        space: spaceRef,
-        target: self,
-        reaction: reaction2,
-        client,
-        config,
-        store
-      });
-    } catch (err) {
-      if (err instanceof UnsupportedError) {
-        warnUnsupported(err, definition.name);
-        return;
-      }
-      throw err;
-    }
+  const react = async (emoji) => {
+    const target = requireBuiltMessage("react");
+    await space.send(reaction(emoji, target));
   };
   const requireBuiltMessage = (action) => {
     if (!self) {
@@ -937,65 +1014,10 @@ function buildMessage(params) {
     }
     return self;
   };
-  const dispatchReplyItem = async (item, target, replyToMessage) => {
-    let raw;
-    try {
-      const platformError = unsupportedPlatformContentError(
-        item,
-        definition.name
-      );
-      if (platformError) {
-        throw platformError;
-      }
-      raw = await replyToMessage({
-        space: spaceRef,
-        messageId: params.id,
-        target,
-        content: item,
-        client,
-        config,
-        store
-      });
-    } catch (err) {
-      if (err instanceof UnsupportedError) {
-        warnUnsupported(err, definition.name);
-        return;
-      }
-      throw err;
-    }
-    if (!raw?.id) {
-      throw new Error(
-        `Platform "${definition.name}" reply did not return a message id`
-      );
-    }
-    return wrapProviderMessage(
-      raw,
-      { client, config, definition, space, spaceRef, store },
-      "outbound"
-    );
-  };
-  async function reply(...content) {
-    const replyToMessage = definition.actions.replyToMessage;
-    if (!replyToMessage) {
-      warnUnsupported(
-        UnsupportedError.action("reply", definition.name),
-        definition.name
-      );
-      return content.length === 1 ? void 0 : [];
-    }
-    const resolved = await resolveContents(content);
+  async function reply2(...content) {
     const target = requireBuiltMessage("reply");
-    const results = [];
-    for (const item of resolved) {
-      const sent = await dispatchReplyItem(item, target, replyToMessage);
-      if (sent) {
-        results.push(sent);
-      }
-    }
-    if (content.length === 1) {
-      return results[0];
-    }
-    return results;
+    const wrapped = content.map((c) => reply(c, target));
+    return space.send(...wrapped);
   }
   const senderWithPlatform = params.sender === void 0 ? void 0 : { ...params.sender, __platform: definition.name };
   if (params.direction === "outbound") {
@@ -1006,43 +1028,10 @@ function buildMessage(params) {
       direction: "outbound",
       platform: definition.name,
       react,
-      reply,
+      reply: reply2,
       edit: async (newContent) => {
-        if (!definition.actions.editMessage) {
-          warnUnsupported(
-            UnsupportedError.action("edit", definition.name),
-            definition.name
-          );
-          return;
-        }
-        const [resolved] = await resolveContents([newContent]);
-        if (!resolved) {
-          return;
-        }
-        const platformError = unsupportedPlatformContentError(
-          resolved,
-          definition.name
-        );
-        if (platformError) {
-          warnUnsupported(platformError, definition.name);
-          return;
-        }
-        try {
-          await definition.actions.editMessage({
-            space: spaceRef,
-            messageId: params.id,
-            content: resolved,
-            client,
-            config,
-            store
-          });
-        } catch (err) {
-          if (err instanceof UnsupportedError) {
-            warnUnsupported(err, definition.name);
-            return;
-          }
-          throw err;
-        }
+        const target = requireBuiltMessage("edit");
+        await space.send(edit(newContent, target));
       },
       sender: senderWithPlatform,
       space,
@@ -1058,7 +1047,7 @@ function buildMessage(params) {
     direction: "inbound",
     platform: definition.name,
     react,
-    reply,
+    reply: reply2,
     sender: senderWithPlatform,
     space,
     timestamp: params.timestamp
@@ -1069,9 +1058,7 @@ function buildMessage(params) {
 
 // src/platform/define.ts
 function createPlatformInstance(def, runtime) {
-  const isPlatformUser = (value) => {
-    return typeof value === "object" && value !== null && "__platform" in value && value.__platform === def.name;
-  };
+  const isPlatformUser = (value) => typeof value === "object" && value !== null && "__platform" in value && value.__platform === def.name;
   const resolveUserID = async (userID) => {
     const resolved = await def.user.resolve({
       input: { userID },
@@ -1157,7 +1144,7 @@ function createPlatformInstance(def, runtime) {
         id: parsedSpace.id,
         __platform: def.name
       };
-      const typingCtx = {
+      const actionCtx = {
         space: spaceRef,
         client: runtime.client,
         config: runtime.config,
@@ -1166,7 +1153,7 @@ function createPlatformInstance(def, runtime) {
       return buildSpace({
         spaceRef,
         extras: parsedSpace,
-        typingCtx,
+        actionCtx,
         definition: def,
         client: runtime.client,
         config: runtime.config,
@@ -1175,11 +1162,9 @@ function createPlatformInstance(def, runtime) {
     }
   };
   const eventProperties = {};
-  for (const eventName of Object.keys(def.events)) {
-    if (eventName === "messages") {
-      continue;
-    }
-    const producer = def.events[eventName];
+  const customEvents = def.events ?? {};
+  for (const eventName of Object.keys(customEvents)) {
+    const producer = customEvents[eventName];
     if (producer) {
       eventProperties[eventName] = producer({
         client: runtime.client,
@@ -1290,9 +1275,12 @@ export {
   asText,
   text,
   resolveContents,
+  edit,
   reactionSchema,
   asReaction,
   reaction,
+  reply,
+  typing,
   UnsupportedError,
   wrapProviderMessage,
   buildSpace,

package/dist/{chunk-66GJ45ZZ.js → chunk-VO43HJ5B.js}

@@ -3,7 +3,7 @@ import {
   readSchema,
   resolveContents,
   streamSchema
-} from "./chunk-LH4YEBG3.js";
+} from "./chunk-JWWIFSI7.js";
 
 // src/content/group.ts
 import z from "zod";

package/dist/{chunk-B4MHPWPZ.js → chunk-VVXMZYDH.js}

@@ -2,7 +2,7 @@ import {
   bufferToStream,
   readSchema,
   streamSchema
-} from "./chunk-LH4YEBG3.js";
+} from "./chunk-JWWIFSI7.js";
 
 // src/content/voice.ts
 import { createReadStream } from "fs";
@@ -29,7 +29,7 @@ var resolveVoiceName = (input, name) => {
   if (typeof input === "string") {
     return basename(input);
   }
-  return void 0;
+  return;
 };
 var resolveVoiceMimeType = (name, mimeType) => {
   if (mimeType) {

package/dist/{chunk-FF2R4EP3.js → chunk-WFIUWFE4.js}

@@ -55,6 +55,7 @@ function poll(title, ...rest) {
 
 // src/utils/stream.ts
 import { Repeater } from "@repeaterjs/repeater";
+var ignoreCleanupError = () => void 0;
 function stream(setup) {
   const repeater = new Repeater(async (push, stop) => {
     const emit = async (value) => {
@@ -77,7 +78,7 @@ function stream(setup) {
   });
   return Object.assign(repeater, {
     close: async () => {
-      await repeater.return(void 0);
+      await repeater.return(void 0).catch(ignoreCleanupError);
     }
   });
 }
@@ -104,7 +105,7 @@ function mergeStreams(streams) {
     });
     return async () => {
       await Promise.allSettled(streams.map((source) => source.close()));
-      await Promise.allSettled(workers);
+      await Promise.allSettled(workers).catch(ignoreCleanupError);
     };
   });
 }
@@ -175,7 +176,7 @@ function broadcast(source) {
       try {
         await source.close();
         if (pumpPromise) {
-          await pumpPromise;
+          await pumpPromise.catch(ignoreCleanupError);
         }
       } finally {
         if (!terminated) {