spectrum-ts 0.4.0 → 0.5.0

package/dist/providers/whatsapp-business/index.js

@@ -1,8 +1,9 @@
 import {
   asAttachment,
+  asContact,
   asCustom,
   stream
-} from "../../chunk-5XW4CAWS.js";
+} from "../../chunk-UZWRB3FZ.js";
 import {
   asText,
   definePlatform
@@ -14,13 +15,152 @@ import {
 } from "@photon-ai/whatsapp-business";
 
 // src/providers/whatsapp-business/messages.ts
-var toMessage = (client, msg) => ({
-  id: msg.id,
-  content: mapContent(client, msg.content),
-  sender: { id: msg.from },
-  space: { id: msg.from },
-  timestamp: msg.timestamp
-});
+import { extension as mimeExtension } from "mime-types";
+var mapWaPhoneType = (type) => {
+  if (!type) {
+    return void 0;
+  }
+  const upper = type.toUpperCase();
+  if (upper === "CELL" || upper === "MOBILE" || upper === "IPHONE") {
+    return "mobile";
+  }
+  if (upper === "HOME") {
+    return "home";
+  }
+  if (upper === "WORK" || upper === "BUSINESS") {
+    return "work";
+  }
+  return "other";
+};
+var mapWaSimpleType = (type) => {
+  if (!type) {
+    return void 0;
+  }
+  const upper = type.toUpperCase();
+  if (upper === "HOME") {
+    return "home";
+  }
+  if (upper === "WORK" || upper === "BUSINESS") {
+    return "work";
+  }
+  return "other";
+};
+var waNameToSpectrum = (name) => {
+  const result = { formatted: name.formattedName };
+  if (name.firstName) {
+    result.first = name.firstName;
+  }
+  if (name.lastName) {
+    result.last = name.lastName;
+  }
+  if (name.middleName) {
+    result.middle = name.middleName;
+  }
+  if (name.prefix) {
+    result.prefix = name.prefix;
+  }
+  if (name.suffix) {
+    result.suffix = name.suffix;
+  }
+  return result;
+};
+var waPhoneToSpectrum = (phone) => {
+  const entry = { value: phone.phone };
+  const type = mapWaPhoneType(phone.type);
+  if (type) {
+    entry.type = type;
+  }
+  return entry;
+};
+var waEmailToSpectrum = (email) => {
+  const entry = { value: email.email };
+  const type = mapWaSimpleType(email.type);
+  if (type) {
+    entry.type = type;
+  }
+  return entry;
+};
+var waAddressToSpectrum = (address) => {
+  const entry = {};
+  if (address.street) {
+    entry.street = address.street;
+  }
+  if (address.city) {
+    entry.city = address.city;
+  }
+  if (address.state) {
+    entry.region = address.state;
+  }
+  if (address.zip) {
+    entry.postalCode = address.zip;
+  }
+  if (address.country) {
+    entry.country = address.country;
+  }
+  const type = mapWaSimpleType(address.type);
+  if (type) {
+    entry.type = type;
+  }
+  return entry;
+};
+var waOrgToSpectrum = (org) => {
+  const entry = {};
+  if (org.company) {
+    entry.name = org.company;
+  }
+  if (org.title) {
+    entry.title = org.title;
+  }
+  if (org.department) {
+    entry.department = org.department;
+  }
+  return entry;
+};
+var waContactToSpectrum = (card) => {
+  const input = { raw: card };
+  input.name = waNameToSpectrum(card.name);
+  if (card.phones.length > 0) {
+    input.phones = card.phones.map(waPhoneToSpectrum);
+  }
+  if (card.emails.length > 0) {
+    input.emails = card.emails.map(waEmailToSpectrum);
+  }
+  if (card.addresses.length > 0) {
+    input.addresses = card.addresses.map(waAddressToSpectrum);
+  }
+  if (card.org) {
+    input.org = waOrgToSpectrum(card.org);
+  }
+  if (card.urls.length > 0) {
+    input.urls = card.urls.map((u) => u.url);
+  }
+  if (card.birthday) {
+    input.birthday = card.birthday;
+  }
+  return asContact(input);
+};
+var toMessages = (client, msg) => {
+  const base = {
+    sender: { id: msg.from },
+    space: { id: msg.from },
+    timestamp: msg.timestamp
+  };
+  if (msg.content.type === "contacts") {
+    const multi = msg.content.contacts.length > 1;
+    return msg.content.contacts.map((card, index) => ({
+      ...base,
+      id: multi ? `${msg.id}:${index}` : msg.id,
+      content: waContactToSpectrum(card)
+    }));
+  }
+  return [
+    {
+      ...base,
+      id: msg.id,
+      content: mapContent(client, msg.content)
+    }
+  ];
+};
 var mapContent = (client, content) => {
   switch (content.type) {
     case "text":
@@ -34,11 +174,6 @@ var mapContent = (client, content) => {
       return asCustom({ whatsapp_type: "sticker", ...content.sticker });
     case "location":
       return asCustom({ whatsapp_type: "location", ...content.location });
-    case "contacts":
-      return asCustom({
-        whatsapp_type: "contacts",
-        contacts: content.contacts
-      });
     case "reaction":
       return asCustom({ whatsapp_type: "reaction", ...content.reaction });
     case "interactive":
@@ -85,6 +220,74 @@ var mimeToMediaType = (mimeType) => {
   }
   return "document";
 };
+var voiceFilename = (content) => {
+  if (content.name) {
+    return content.name;
+  }
+  const ext = mimeExtension(content.mimeType);
+  return ext ? `voice.${ext}` : "voice";
+};
+var spectrumPhoneTypeToWa = (type) => {
+  if (type === "mobile") {
+    return "CELL";
+  }
+  if (type === "home" || type === "work" || type === "other") {
+    return type.toUpperCase();
+  }
+  return void 0;
+};
+var spectrumSimpleTypeToWa = (type) => type ? type.toUpperCase() : void 0;
+var spectrumNameToWa = (name) => ({
+  formattedName: name?.formatted ?? ([name?.first, name?.middle, name?.last].filter((p) => Boolean(p)).join(" ") || "Unknown"),
+  firstName: name?.first,
+  lastName: name?.last,
+  middleName: name?.middle,
+  prefix: name?.prefix,
+  suffix: name?.suffix
+});
+var isWhatsAppContactCard = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const raw = value;
+  const name = raw.name;
+  if (!name || typeof name !== "object" || typeof name.formattedName !== "string") {
+    return false;
+  }
+  return Array.isArray(raw.phones) && Array.isArray(raw.emails) && Array.isArray(raw.addresses) && Array.isArray(raw.urls);
+};
+var contactToWa = (contact) => {
+  if (isWhatsAppContactCard(contact.raw)) {
+    return contact.raw;
+  }
+  const card = {
+    name: spectrumNameToWa(contact.name),
+    phones: (contact.phones ?? []).map((p) => ({
+      phone: p.value,
+      type: spectrumPhoneTypeToWa(p.type)
+    })),
+    emails: (contact.emails ?? []).map((e) => ({
+      email: e.value,
+      type: spectrumSimpleTypeToWa(e.type)
+    })),
+    addresses: (contact.addresses ?? []).map((a) => ({
+      street: a.street,
+      city: a.city,
+      state: a.region,
+      zip: a.postalCode,
+      country: a.country,
+      type: spectrumSimpleTypeToWa(a.type)
+    })),
+    urls: (contact.urls ?? []).map((url) => ({ url })),
+    org: contact.org?.name || contact.org?.department || contact.org?.title ? {
+      company: contact.org.name,
+      department: contact.org.department,
+      title: contact.org.title
+    } : void 0,
+    birthday: contact.birthday
+  };
+  return card;
+};
 var messages = (client) => {
   const eventStream = client.events.subscribe().filter(
     (e) => e.type === "message"
@@ -93,7 +296,9 @@ var messages = (client) => {
     (async () => {
       try {
         for await (const event of eventStream) {
-          emit(toMessage(client, event.message));
+          for (const m of toMessages(client, event.message)) {
+            emit(m);
+          }
         }
         end();
       } catch (e) {
@@ -122,6 +327,24 @@ var send = async (client, spaceId, content) => {
       });
       break;
     }
+    case "contact":
+      await client.messages.send({
+        to: spaceId,
+        contacts: [contactToWa(content)]
+      });
+      break;
+    case "voice": {
+      const { mediaId } = await client.media.upload({
+        file: await content.read(),
+        mimeType: content.mimeType,
+        filename: voiceFilename(content)
+      });
+      await client.messages.send({
+        to: spaceId,
+        audio: { id: mediaId }
+      });
+      break;
+    }
     default:
       break;
   }
@@ -156,6 +379,26 @@ var replyToMessage = async (client, spaceId, messageId, content) => {
       });
       break;
     }
+    case "contact":
+      await client.messages.send({
+        to: spaceId,
+        replyTo: messageId,
+        contacts: [contactToWa(content)]
+      });
+      break;
+    case "voice": {
+      const { mediaId } = await client.media.upload({
+        file: await content.read(),
+        mimeType: content.mimeType,
+        filename: voiceFilename(content)
+      });
+      await client.messages.send({
+        to: spaceId,
+        replyTo: messageId,
+        audio: { id: mediaId }
+      });
+      break;
+    }
     default:
       break;
   }

package/dist/{types-BdWMydUJ.d.ts → types-CfiD_00g.d.ts}

@@ -14,6 +14,70 @@ declare const contentSchema: z__default.ZodDiscriminatedUnion<[z__default.ZodObj
     size: z__default.ZodOptional<z__default.ZodNumber>;
     read: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
     stream: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
+}, z__default.core.$strip>, z__default.ZodObject<{
+    type: z__default.ZodLiteral<"contact">;
+    user: z__default.ZodOptional<z__default.ZodObject<{
+        __platform: z__default.ZodString;
+        id: z__default.ZodString;
+    }, z__default.core.$strip>>;
+    name: z__default.ZodOptional<z__default.ZodObject<{
+        formatted: z__default.ZodOptional<z__default.ZodString>;
+        first: z__default.ZodOptional<z__default.ZodString>;
+        last: z__default.ZodOptional<z__default.ZodString>;
+        middle: z__default.ZodOptional<z__default.ZodString>;
+        prefix: z__default.ZodOptional<z__default.ZodString>;
+        suffix: z__default.ZodOptional<z__default.ZodString>;
+    }, z__default.core.$strip>>;
+    phones: z__default.ZodOptional<z__default.ZodArray<z__default.ZodObject<{
+        value: z__default.ZodString;
+        type: z__default.ZodOptional<z__default.ZodEnum<{
+            mobile: "mobile";
+            home: "home";
+            work: "work";
+            other: "other";
+        }>>;
+    }, z__default.core.$strip>>>;
+    emails: z__default.ZodOptional<z__default.ZodArray<z__default.ZodObject<{
+        value: z__default.ZodString;
+        type: z__default.ZodOptional<z__default.ZodEnum<{
+            home: "home";
+            work: "work";
+            other: "other";
+        }>>;
+    }, z__default.core.$strip>>>;
+    addresses: z__default.ZodOptional<z__default.ZodArray<z__default.ZodObject<{
+        street: z__default.ZodOptional<z__default.ZodString>;
+        city: z__default.ZodOptional<z__default.ZodString>;
+        region: z__default.ZodOptional<z__default.ZodString>;
+        postalCode: z__default.ZodOptional<z__default.ZodString>;
+        country: z__default.ZodOptional<z__default.ZodString>;
+        type: z__default.ZodOptional<z__default.ZodEnum<{
+            home: "home";
+            work: "work";
+            other: "other";
+        }>>;
+    }, z__default.core.$strip>>>;
+    org: z__default.ZodOptional<z__default.ZodObject<{
+        name: z__default.ZodOptional<z__default.ZodString>;
+        title: z__default.ZodOptional<z__default.ZodString>;
+        department: z__default.ZodOptional<z__default.ZodString>;
+    }, z__default.core.$strip>>;
+    urls: z__default.ZodOptional<z__default.ZodArray<z__default.ZodString>>;
+    birthday: z__default.ZodOptional<z__default.ZodString>;
+    note: z__default.ZodOptional<z__default.ZodString>;
+    photo: z__default.ZodOptional<z__default.ZodObject<{
+        mimeType: z__default.ZodString;
+        read: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
+    }, z__default.core.$strip>>;
+    raw: z__default.ZodOptional<z__default.ZodUnknown>;
+}, z__default.core.$strip>, z__default.ZodObject<{
+    type: z__default.ZodLiteral<"voice">;
+    name: z__default.ZodOptional<z__default.ZodString>;
+    mimeType: z__default.ZodString;
+    duration: z__default.ZodOptional<z__default.ZodNumber>;
+    size: z__default.ZodOptional<z__default.ZodNumber>;
+    read: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
+    stream: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
 }, z__default.core.$strip>], "type">;
 type Content = z__default.infer<typeof contentSchema>;
 interface ContentBuilder {
@@ -21,6 +85,11 @@ interface ContentBuilder {
 }
 type ContentInput = string | ContentBuilder;
 
+interface User {
+    readonly __platform: string;
+    readonly id: string;
+}
+
 interface Space<_Def = unknown> {
     readonly __platform: string;
     readonly id: string;
@@ -30,11 +99,6 @@ interface Space<_Def = unknown> {
     stopTyping(): Promise<void>;
 }
 
-interface User {
-    readonly __platform: string;
-    readonly id: string;
-}
-
 interface Message<TPlatform extends string = string, TSender extends User = User, TSpace extends Space = Space> {
     content: Content;
     readonly id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectrum-ts",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -20,16 +20,23 @@
   },
   "dependencies": {
     "@photon-ai/advanced-imessage": "^0.4.3",
-    "@photon-ai/whatsapp-business": "^0.1.1",
     "@photon-ai/imessage-kit": "^3.0.0-rc.2",
+    "@photon-ai/whatsapp-business": "^0.1.1",
     "@repeaterjs/repeater": "^3.0.6",
     "better-grpc": "^0.3.2",
     "mime-types": "^3.0.1",
     "type-fest": "^5.4.1",
+    "vcf": "^2.1.2",
     "zod": "^4.2.1"
   },
   "peerDependencies": {
+    "ffmpeg-static": "^5",
     "typescript": "^5"
   },
+  "peerDependenciesMeta": {
+    "ffmpeg-static": {
+      "optional": true
+    }
+  },
   "license": "MIT"
 }

package/dist/chunk-5XW4CAWS.js

@@ -1,165 +0,0 @@
-// src/content/attachment.ts
-import { createReadStream } from "fs";
-import { readFile, stat } from "fs/promises";
-import { basename } from "path";
-import { Readable } from "stream";
-import { lookup as lookupMimeType } from "mime-types";
-import z from "zod";
-var DEFAULT_ATTACHMENT_NAME = "attachment";
-var readSchema = z.function({
-  input: [],
-  output: z.promise(z.instanceof(Buffer))
-});
-var streamSchema = z.function({
-  input: [],
-  output: z.promise(z.instanceof(ReadableStream))
-});
-var attachmentSchema = z.object({
-  type: z.literal("attachment"),
-  name: z.string().nonempty(),
-  mimeType: z.string().nonempty(),
-  size: z.number().int().nonnegative().optional(),
-  read: readSchema,
-  stream: streamSchema
-});
-var resolveAttachmentName = (input, name) => name || (typeof input === "string" ? basename(input) : DEFAULT_ATTACHMENT_NAME);
-var resolveAttachmentMimeType = (name, mimeType) => {
-  if (mimeType) {
-    return mimeType;
-  }
-  const resolvedMimeType = lookupMimeType(name);
-  if (!resolvedMimeType) {
-    throw new Error(
-      `Unable to resolve MIME type for attachment "${name}". Pass options.mimeType explicitly.`
-    );
-  }
-  return resolvedMimeType;
-};
-var bufferToStream = (buf) => new ReadableStream({
-  start(controller) {
-    controller.enqueue(buf);
-    controller.close();
-  }
-});
-var asAttachment = (input) => {
-  let cached;
-  const read = () => {
-    cached ??= input.read().catch((err) => {
-      cached = void 0;
-      throw err;
-    });
-    return cached;
-  };
-  const stream2 = input.stream ?? (async () => bufferToStream(await read()));
-  return attachmentSchema.parse({
-    type: "attachment",
-    name: input.name,
-    mimeType: input.mimeType,
-    size: input.size,
-    read,
-    stream: stream2
-  });
-};
-function attachment(input, options) {
-  return {
-    build: async () => {
-      const name = resolveAttachmentName(input, options?.name);
-      const mimeType = resolveAttachmentMimeType(name, options?.mimeType);
-      if (typeof input === "string") {
-        const stats = await stat(input);
-        return asAttachment({
-          name,
-          mimeType,
-          size: stats.size,
-          read: () => readFile(input),
-          stream: async () => Readable.toWeb(
-            createReadStream(input)
-          )
-        });
-      }
-      return asAttachment({
-        name,
-        mimeType,
-        size: input.byteLength,
-        read: async () => input,
-        stream: async () => bufferToStream(input)
-      });
-    }
-  };
-}
-
-// src/content/custom.ts
-import z2 from "zod";
-var customSchema = z2.object({
-  type: z2.literal("custom"),
-  raw: z2.unknown()
-});
-var asCustom = (raw) => customSchema.parse({ type: "custom", raw });
-function custom(raw) {
-  return {
-    build: async () => asCustom(raw)
-  };
-}
-
-// 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) => {
-        stop(error);
-        return void 0;
-      });
-    };
-    const end = (error) => {
-      stop(error);
-    };
-    const cleanup = await setup(emit, end);
-    try {
-      await stop;
-    } finally {
-      await cleanup?.();
-    }
-  });
-  return Object.assign(repeater, {
-    close: async () => {
-      await repeater.return(void 0);
-    }
-  });
-}
-function mergeStreams(streams) {
-  return stream((emit, end) => {
-    if (streams.length === 0) {
-      end();
-      return;
-    }
-    let openStreams = streams.length;
-    const workers = streams.map(async (source) => {
-      try {
-        for await (const value of source) {
-          emit(value);
-        }
-      } catch (error) {
-        end(error);
-      } finally {
-        openStreams -= 1;
-        if (openStreams === 0) {
-          end();
-        }
-      }
-    });
-    return async () => {
-      await Promise.allSettled(streams.map((source) => source.close()));
-      await Promise.allSettled(workers);
-    };
-  });
-}
-
-export {
-  asAttachment,
-  attachment,
-  asCustom,
-  custom,
-  stream,
-  mergeStreams
-};