spectrum-ts 0.7.0 → 0.9.0

package/dist/chunk-6ZOLTQDN.js

@@ -0,0 +1,141 @@
+import {
+  bufferToStream,
+  readSchema,
+  streamSchema
+} from "./chunk-CZIWNTXP.js";
+
+// src/content/richlink.ts
+import z from "zod";
+
+// src/utils/link-metadata.ts
+import ogs from "open-graph-scraper";
+var DEFAULT_TIMEOUT_MS = 5e3;
+var USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_0) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15 spectrum-ts/richlink";
+var normaliseImageUrl = (raw, base) => {
+  try {
+    return new URL(raw, base).toString();
+  } catch {
+    return;
+  }
+};
+var cleanString = (v) => {
+  if (typeof v !== "string") {
+    return;
+  }
+  const trimmed = v.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+};
+var fetchLinkMetadata = async (url) => {
+  try {
+    const result = await ogs({
+      url,
+      timeout: DEFAULT_TIMEOUT_MS,
+      fetchOptions: { headers: { "User-Agent": USER_AGENT } }
+    });
+    if (result.error) {
+      return {};
+    }
+    const {
+      ogTitle,
+      ogDescription,
+      ogImage,
+      twitterTitle,
+      twitterDescription,
+      twitterImage
+    } = result.result;
+    const title = cleanString(ogTitle) ?? cleanString(twitterTitle);
+    const summary = cleanString(ogDescription) ?? cleanString(twitterDescription);
+    const imageCandidate = ogImage?.[0] ?? twitterImage?.[0];
+    const resolved = imageCandidate ? normaliseImageUrl(imageCandidate.url, url) : void 0;
+    const image = imageCandidate && resolved ? {
+      url: resolved,
+      mimeType: "type" in imageCandidate && typeof imageCandidate.type === "string" ? imageCandidate.type : void 0
+    } : void 0;
+    return { title, summary, image };
+  } catch {
+    return {};
+  }
+};
+var fetchImage = async (url) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: { "User-Agent": USER_AGENT }
+    });
+    if (!res.ok) {
+      throw new Error(`image fetch ${url} returned ${res.status}`);
+    }
+    const data = Buffer.from(await res.arrayBuffer());
+    const mimeType = res.headers.get("content-type") ?? void 0;
+    return { data, mimeType };
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+// src/content/richlink.ts
+var richlinkCoverSchema = z.object({
+  mimeType: z.string().min(1).optional(),
+  read: readSchema,
+  stream: streamSchema
+});
+var optionalStringAccessor = z.function({
+  input: [],
+  output: z.promise(z.string().min(1).optional())
+});
+var coverAccessor = z.function({
+  input: [],
+  output: z.promise(richlinkCoverSchema.optional())
+});
+var richlinkSchema = z.object({
+  type: z.literal("richlink"),
+  url: z.url(),
+  title: optionalStringAccessor,
+  summary: optionalStringAccessor,
+  cover: coverAccessor
+});
+var memoize = (factory) => {
+  let cached;
+  return () => {
+    cached ??= factory();
+    return cached;
+  };
+};
+var buildCover = (image) => {
+  const read = memoize(
+    () => fetchImage(image.url).then((r) => r.data).catch(() => Buffer.alloc(0))
+  );
+  return {
+    mimeType: image.mimeType,
+    read,
+    stream: async () => bufferToStream(await read())
+  };
+};
+var asRichlink = (input) => {
+  const getMetadata = memoize(() => fetchLinkMetadata(input.url));
+  const getCover = memoize(async () => {
+    const { image } = await getMetadata();
+    return image ? buildCover(image) : void 0;
+  });
+  const title = async () => (await getMetadata()).title;
+  const summary = async () => (await getMetadata()).summary;
+  return richlinkSchema.parse({
+    type: "richlink",
+    url: input.url,
+    title,
+    summary,
+    cover: getCover
+  });
+};
+function richlink(url) {
+  return {
+    build: async () => asRichlink({ url })
+  };
+}
+
+export {
+  asRichlink,
+  richlink
+};

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

@@ -553,15 +553,30 @@ 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) {
   const repeater = new Repeater(async (push, stop) => {
-    const emit = (value) => {
-      Promise.resolve(push(value)).catch((error) => {
+    const emit = async (value) => {
+      try {
+        await push(value);
+      } catch (error) {
         stop(error);
-        return void 0;
-      });
+        throw error;
+      }
     };
     const end = (error) => {
       stop(error);
@@ -589,7 +604,7 @@ function mergeStreams(streams) {
     const workers = streams.map(async (source) => {
       try {
         for await (const value of source) {
-          emit(value);
+          await emit(value);
         }
       } catch (error) {
         end(error);
@@ -686,6 +701,8 @@ export {
   contact,
   asCustom,
   custom,
+  asReaction,
+  reaction,
   stream,
   mergeStreams,
   SpectrumCloudError,

package/dist/{chunk-6URE4AYH.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) {
@@ -292,6 +328,29 @@ function createPlatformInstance(def, runtime) {
   const isPlatformUser = (value) => {
     return typeof value === "object" && value !== null && "__platform" in value && value.__platform === def.name;
   };
+  const resolveUserID = async (userID) => {
+    const resolved = await def.user.resolve({
+      input: { userID },
+      client: runtime.client,
+      config: runtime.config
+    });
+    return {
+      ...resolved,
+      __platform: def.name
+    };
+  };
+  const resolveStringUsers = async (args) => {
+    const convertArg = async (arg) => {
+      if (typeof arg === "string") {
+        return await resolveUserID(arg);
+      }
+      if (Array.isArray(arg)) {
+        return await Promise.all(arg.map(convertArg));
+      }
+      return arg;
+    };
+    return await Promise.all(args.map(convertArg));
+  };
   const normalizeSpaceArgs = (args) => {
     if (args.length === 0) {
       return { users: [], params: void 0 };
@@ -334,7 +393,8 @@ function createPlatformInstance(def, runtime) {
       };
     },
     async space(...args) {
-      const { users, params } = normalizeSpaceArgs(args);
+      const convertedArgs = await resolveStringUsers(args);
+      const { users, params } = normalizeSpaceArgs(convertedArgs);
       let parsedParams = params;
       if (params !== void 0 && def.space.params) {
         parsedParams = def.space.params.parse(params);