spectrum-ts 0.9.1 → 1.1.0

package/dist/{chunk-U6WCQVVX.js → chunk-XMAI2AAN.js}

@@ -1,8 +1,563 @@
-// src/content/text.ts
+// 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 z2 from "zod";
+
+// src/utils/io.ts
 import z from "zod";
-var textSchema = z.object({
-  type: z.literal("text"),
-  text: z.string().nonempty()
+var readSchema = z.function({
+  input: [],
+  output: z.promise(z.instanceof(Buffer))
+});
+var streamSchema = z.function({
+  input: [],
+  output: z.promise(z.instanceof(ReadableStream))
+});
+var bufferToStream = (buf) => new ReadableStream({
+  start(controller) {
+    controller.enqueue(buf);
+    controller.close();
+  }
+});
+
+// src/content/attachment.ts
+var DEFAULT_ATTACHMENT_NAME = "attachment";
+var attachmentSchema = z2.object({
+  type: z2.literal("attachment"),
+  name: z2.string().nonempty(),
+  mimeType: z2.string().nonempty(),
+  size: z2.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 asAttachment = (input) => {
+  let cached;
+  const read = () => {
+    cached ??= input.read().catch((err) => {
+      cached = void 0;
+      throw err;
+    });
+    return cached;
+  };
+  const stream = input.stream ?? (async () => bufferToStream(await read()));
+  return attachmentSchema.parse({
+    type: "attachment",
+    name: input.name,
+    mimeType: input.mimeType,
+    size: input.size,
+    read,
+    stream
+  });
+};
+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/utils/vcard.ts
+import vCard from "vcf";
+var asPropertyArray = (prop) => {
+  if (!prop) {
+    return [];
+  }
+  const arr = Array.isArray(prop) ? prop : [prop];
+  return arr;
+};
+var propString = (prop) => {
+  const [first] = asPropertyArray(prop);
+  const value = first?.valueOf().trim();
+  return value ? value : void 0;
+};
+var paramTypes = (prop) => {
+  const { type } = prop;
+  if (!type) {
+    return [];
+  }
+  return (Array.isArray(type) ? type : [type]).map((t) => t.toLowerCase());
+};
+var mapPhoneType = (prop) => {
+  const types = paramTypes(prop);
+  if (types.some((t) => t === "cell" || t === "mobile" || t === "iphone")) {
+    return "mobile";
+  }
+  if (types.includes("home")) {
+    return "home";
+  }
+  if (types.includes("work")) {
+    return "work";
+  }
+  if (types.length > 0) {
+    return "other";
+  }
+  return void 0;
+};
+var mapSimpleType = (prop) => {
+  const types = paramTypes(prop);
+  if (types.includes("home")) {
+    return "home";
+  }
+  if (types.includes("work")) {
+    return "work";
+  }
+  if (types.length > 0) {
+    return "other";
+  }
+  return void 0;
+};
+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;
+  }
+  const result = {};
+  if (fn) {
+    result.formatted = fn;
+  }
+  if (n) {
+    const [last, first, middle, prefix, suffix] = splitStructured(n);
+    if (first) {
+      result.first = first;
+    }
+    if (last) {
+      result.last = last;
+    }
+    if (middle) {
+      result.middle = middle;
+    }
+    if (prefix) {
+      result.prefix = prefix;
+    }
+    if (suffix) {
+      result.suffix = suffix;
+    }
+  }
+  return result;
+};
+var extractPhones = (card) => {
+  const props = asPropertyArray(card.data.tel);
+  if (props.length === 0) {
+    return void 0;
+  }
+  return props.map((p) => {
+    const entry = { value: p.valueOf().trim() };
+    const type = mapPhoneType(p);
+    if (type) {
+      entry.type = type;
+    }
+    return entry;
+  });
+};
+var extractEmails = (card) => {
+  const props = asPropertyArray(card.data.email);
+  if (props.length === 0) {
+    return void 0;
+  }
+  return props.map((p) => {
+    const entry = { value: p.valueOf().trim() };
+    const type = mapSimpleType(p);
+    if (type) {
+      entry.type = type;
+    }
+    return entry;
+  });
+};
+var extractAddresses = (card) => {
+  const props = asPropertyArray(card.data.adr);
+  if (props.length === 0) {
+    return void 0;
+  }
+  return props.map((p) => {
+    const [, , street, city, region, postalCode, country] = splitStructured(
+      p.valueOf()
+    );
+    const entry = {};
+    if (street) {
+      entry.street = street;
+    }
+    if (city) {
+      entry.city = city;
+    }
+    if (region) {
+      entry.region = region;
+    }
+    if (postalCode) {
+      entry.postalCode = postalCode;
+    }
+    if (country) {
+      entry.country = country;
+    }
+    const type = mapSimpleType(p);
+    if (type) {
+      entry.type = type;
+    }
+    return entry;
+  });
+};
+var extractOrg = (card) => {
+  const orgStr = propString(card.data.org);
+  const title = propString(card.data.title);
+  if (!(orgStr || title)) {
+    return void 0;
+  }
+  const result = {};
+  if (orgStr) {
+    const [name, department] = splitStructured(orgStr);
+    if (name) {
+      result.name = name;
+    }
+    if (department) {
+      result.department = department;
+    }
+  }
+  if (title) {
+    result.title = title;
+  }
+  return result;
+};
+var extractUrls = (card) => {
+  const props = asPropertyArray(card.data.url);
+  if (props.length === 0) {
+    return void 0;
+  }
+  return props.map((p) => p.valueOf().trim());
+};
+var photoMimeFromType = (type) => {
+  if (!type) {
+    return "image/jpeg";
+  }
+  const lower = type.toLowerCase();
+  if (lower.startsWith("image/")) {
+    return lower;
+  }
+  return `image/${lower}`;
+};
+var DATA_URI_PATTERN = /^data:([^;,]+);base64,(.*)$/i;
+var extractPhoto = (card) => {
+  const [prop] = asPropertyArray(card.data.photo);
+  if (!prop) {
+    return void 0;
+  }
+  const value = prop.valueOf();
+  const dataUriMatch = DATA_URI_PATTERN.exec(value);
+  if (dataUriMatch) {
+    const [, mimeType, base64] = dataUriMatch;
+    const buf2 = Buffer.from(base64 ?? "", "base64");
+    return {
+      mimeType: mimeType ?? "image/jpeg",
+      read: async () => buf2
+    };
+  }
+  const type = Array.isArray(prop.type) ? prop.type[0] : prop.type;
+  const buf = Buffer.from(value, "base64");
+  return {
+    mimeType: photoMimeFromType(type),
+    read: async () => buf
+  };
+};
+var normalizeVCardInput = (vcf) => {
+  const withoutBom = vcf.charCodeAt(0) === 65279 ? vcf.slice(1) : vcf;
+  return withoutBom.replace(/\r\n|\r|\n/g, "\r\n");
+};
+var fromVCard = (vcf) => {
+  const [card] = vCard.parse(normalizeVCardInput(vcf));
+  if (!card) {
+    throw new Error("Invalid vCard: no cards parsed");
+  }
+  const input = { raw: vcf };
+  const name = extractName(card);
+  if (name) {
+    input.name = name;
+  }
+  const phones = extractPhones(card);
+  if (phones) {
+    input.phones = phones;
+  }
+  const emails = extractEmails(card);
+  if (emails) {
+    input.emails = emails;
+  }
+  const addresses = extractAddresses(card);
+  if (addresses) {
+    input.addresses = addresses;
+  }
+  const org = extractOrg(card);
+  if (org) {
+    input.org = org;
+  }
+  const urls = extractUrls(card);
+  if (urls) {
+    input.urls = urls;
+  }
+  const birthday = propString(card.data.bday);
+  if (birthday) {
+    input.birthday = birthday;
+  }
+  const note = propString(card.data.note);
+  if (note) {
+    input.note = note;
+  }
+  const photo = extractPhoto(card);
+  if (photo) {
+    input.photo = photo;
+  }
+  return input;
+};
+var formattedNameFor = (name) => {
+  if (name?.formatted) {
+    return name.formatted;
+  }
+  const parts = [name?.first, name?.middle, name?.last].filter(
+    (p) => Boolean(p)
+  );
+  if (parts.length > 0) {
+    return parts.join(" ");
+  }
+  return "Unknown";
+};
+var phoneTypeParam = (type) => {
+  if (type === "mobile") {
+    return "CELL";
+  }
+  if (type === "home" || type === "work" || type === "other") {
+    return type.toUpperCase();
+  }
+  return void 0;
+};
+var simpleTypeParam = (type) => type ? type.toUpperCase() : void 0;
+var photoTypeParam = (mimeType) => {
+  const sub = mimeType.split("/")[1] ?? "jpeg";
+  return sub.toUpperCase();
+};
+var writeName = (card, name) => {
+  card.set("fn", formattedNameFor(name));
+  if (!name) {
+    return;
+  }
+  if (name.first || name.last || name.middle || name.prefix || name.suffix) {
+    card.set(
+      "n",
+      [
+        name.last ?? "",
+        name.first ?? "",
+        name.middle ?? "",
+        name.prefix ?? "",
+        name.suffix ?? ""
+      ].join(";")
+    );
+  }
+};
+var writePhones = (card, phones) => {
+  for (const phone of phones ?? []) {
+    const type = phoneTypeParam(phone.type);
+    card.add("tel", phone.value, type ? { type } : void 0);
+  }
+};
+var writeEmails = (card, emails) => {
+  for (const email of emails ?? []) {
+    const type = simpleTypeParam(email.type);
+    card.add("email", email.value, type ? { type } : void 0);
+  }
+};
+var writeAddresses = (card, addresses) => {
+  for (const addr of addresses ?? []) {
+    const value = [
+      "",
+      "",
+      addr.street ?? "",
+      addr.city ?? "",
+      addr.region ?? "",
+      addr.postalCode ?? "",
+      addr.country ?? ""
+    ].join(";");
+    const type = simpleTypeParam(addr.type);
+    card.add("adr", value, type ? { type } : void 0);
+  }
+};
+var writeOrg = (card, org) => {
+  if (!org) {
+    return;
+  }
+  if (org.name || org.department) {
+    card.set("org", [org.name ?? "", org.department ?? ""].join(";"));
+  }
+  if (org.title) {
+    card.set("title", org.title);
+  }
+};
+var writeUrls = (card, urls) => {
+  for (const url of urls ?? []) {
+    card.add("url", url);
+  }
+};
+var writePhoto = async (card, photo) => {
+  if (!photo) {
+    return;
+  }
+  const buf = await photo.read();
+  card.set("photo", buf.toString("base64"), {
+    encoding: "b",
+    type: photoTypeParam(photo.mimeType)
+  });
+};
+var toVCard = async (contact2) => {
+  if (typeof contact2.raw === "string" && contact2.raw.startsWith("BEGIN:VCARD")) {
+    return contact2.raw;
+  }
+  const card = new vCard();
+  writeName(card, contact2.name);
+  writePhones(card, contact2.phones);
+  writeEmails(card, contact2.emails);
+  writeAddresses(card, contact2.addresses);
+  writeOrg(card, contact2.org);
+  writeUrls(card, contact2.urls);
+  if (contact2.birthday) {
+    card.set("bday", contact2.birthday);
+  }
+  if (contact2.note) {
+    card.set("note", contact2.note);
+  }
+  await writePhoto(card, contact2.photo);
+  return card.toString();
+};
+
+// src/content/contact.ts
+import vCard2 from "vcf";
+import z3 from "zod";
+var userRefSchema = z3.object({
+  __platform: z3.string(),
+  id: z3.string()
+});
+var nameSchema = z3.object({
+  formatted: z3.string().optional(),
+  first: z3.string().optional(),
+  last: z3.string().optional(),
+  middle: z3.string().optional(),
+  prefix: z3.string().optional(),
+  suffix: z3.string().optional()
+});
+var phoneTypeSchema = z3.enum(["mobile", "home", "work", "other"]);
+var emailTypeSchema = z3.enum(["home", "work", "other"]);
+var addressTypeSchema = z3.enum(["home", "work", "other"]);
+var phoneSchema = z3.object({
+  value: z3.string(),
+  type: phoneTypeSchema.optional()
+});
+var emailSchema = z3.object({
+  value: z3.string(),
+  type: emailTypeSchema.optional()
+});
+var addressSchema = z3.object({
+  street: z3.string().optional(),
+  city: z3.string().optional(),
+  region: z3.string().optional(),
+  postalCode: z3.string().optional(),
+  country: z3.string().optional(),
+  type: addressTypeSchema.optional()
+});
+var orgSchema = z3.object({
+  name: z3.string().optional(),
+  title: z3.string().optional(),
+  department: z3.string().optional()
+});
+var photoSchema = z3.object({
+  mimeType: z3.string(),
+  read: readSchema
+});
+var contactSchema = z3.object({
+  type: z3.literal("contact"),
+  user: userRefSchema.optional(),
+  name: nameSchema.optional(),
+  phones: z3.array(phoneSchema).optional(),
+  emails: z3.array(emailSchema).optional(),
+  addresses: z3.array(addressSchema).optional(),
+  org: orgSchema.optional(),
+  urls: z3.array(z3.string()).optional(),
+  birthday: z3.string().optional(),
+  note: z3.string().optional(),
+  photo: photoSchema.optional(),
+  raw: z3.unknown().optional()
+});
+var asContact = (input) => contactSchema.parse({ type: "contact", ...input });
+var isUser = (value) => typeof value === "object" && value !== null && "__platform" in value && "id" in value && typeof value.__platform === "string" && typeof value.id === "string";
+function contact(input, details) {
+  return {
+    build: async () => {
+      if (typeof input === "string") {
+        return asContact(fromVCard(input));
+      }
+      if (input instanceof vCard2) {
+        return asContact(fromVCard(input.toString()));
+      }
+      if (isUser(input)) {
+        return asContact({
+          user: { __platform: input.__platform, id: input.id },
+          ...details
+        });
+      }
+      return asContact(input);
+    }
+  };
+}
+
+// src/content/custom.ts
+import z4 from "zod";
+var customSchema = z4.object({
+  type: z4.literal("custom"),
+  raw: z4.unknown()
+});
+var asCustom = (raw) => customSchema.parse({ type: "custom", raw });
+function custom(raw) {
+  return {
+    build: async () => asCustom(raw)
+  };
+}
+
+// src/content/text.ts
+import z5 from "zod";
+var textSchema = z5.object({
+  type: z5.literal("text"),
+  text: z5.string().nonempty()
 });
 var asText = (text2) => textSchema.parse({ type: "text", text: text2 });
 function text(text2) {
@@ -16,6 +571,21 @@ var resolveContents = (items) => Promise.all(
   items.map((c) => typeof c === "string" ? text(c).build() : c.build())
 );
 
+// src/content/reaction.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),
+  target: z6.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/errors.ts
 var composeMessage = (opts) => {
   const platform = opts.platform ?? "platform";
@@ -304,7 +874,7 @@ function buildSpace(params) {
 function buildMessage(params) {
   const { definition, client, config, spaceRef, space } = params;
   let self;
-  const react = async (reaction) => {
+  const react = async (reaction2) => {
     if (!definition.actions.reactToMessage) {
       warnUnsupported(
         UnsupportedError.action("react", definition.name),
@@ -321,7 +891,7 @@ function buildMessage(params) {
       await definition.actions.reactToMessage({
         space: spaceRef,
         target: self,
-        reaction,
+        reaction: reaction2,
         client,
         config
       });
@@ -627,9 +1197,23 @@ function definePlatform(name, def) {
 }
 
 export {
+  readSchema,
+  streamSchema,
+  bufferToStream,
+  asAttachment,
+  attachment,
+  fromVCard,
+  toVCard,
+  asContact,
+  contact,
+  asCustom,
+  custom,
   asText,
   text,
   resolveContents,
+  reactionSchema,
+  asReaction,
+  reaction,
   UnsupportedError,
   wrapProviderMessage,
   buildSpace,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as ContentBuilder, U as User, M as Message, a as ContentInput, b as Content, P as ProviderMessage, c as PlatformDef, d as Platform, e as PlatformProviderConfig, S as SpectrumLike, f as CustomEventStreams, g as Space, I as InboundMessage, O as OutboundMessage } from './types-D5KhSXLy.js';
-export { A as AnyPlatformDef, E as EventProducer, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage } from './types-D5KhSXLy.js';
+import { C as ContentBuilder, U as User, M as Message, a as ContentInput, b as Content, P as ProviderMessage, c as PlatformDef, d as Platform, e as PlatformProviderConfig, S as SpectrumLike, f as CustomEventStreams, g as Space, I as InboundMessage, O as OutboundMessage } from './types-DJQLFwWW.js';
+export { A as AnyPlatformDef, E as EventProducer, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage } from './types-DJQLFwWW.js';
 import vCard from 'vcf';
 import z__default from 'zod';
 export { M as ManagedStream, m as mergeStreams, s as stream } from './stream-B55k7W8-.js';
@@ -138,6 +138,41 @@ declare const groupSchema: z__default.ZodObject<{
 type Group = z__default.infer<typeof groupSchema>;
 declare function group(...items: [ContentInput, ContentInput, ...ContentInput[]]): ContentBuilder;
 
+declare const pollChoiceSchema: z__default.ZodObject<{
+    title: z__default.ZodString;
+}, z__default.core.$strip>;
+declare const pollSchema: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"poll">;
+    title: z__default.ZodString;
+    options: z__default.ZodArray<z__default.ZodObject<{
+        title: z__default.ZodString;
+    }, z__default.core.$strip>>;
+}, z__default.core.$strip>;
+declare const pollOptionSchema: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"poll_option">;
+    option: z__default.ZodObject<{
+        title: z__default.ZodString;
+    }, z__default.core.$strip>;
+    poll: z__default.ZodObject<{
+        type: z__default.ZodLiteral<"poll">;
+        title: z__default.ZodString;
+        options: z__default.ZodArray<z__default.ZodObject<{
+            title: z__default.ZodString;
+        }, z__default.core.$strip>>;
+    }, z__default.core.$strip>;
+    selected: z__default.ZodBoolean;
+    title: z__default.ZodString;
+}, z__default.core.$strip>;
+type Poll = z__default.infer<typeof pollSchema>;
+type PollChoice = z__default.infer<typeof pollChoiceSchema>;
+type PollOption = z__default.infer<typeof pollOptionSchema>;
+type PollChoiceInput = string | {
+    title: string;
+};
+declare const option: (title: string) => PollChoice;
+declare function poll(title: string, options: PollChoiceInput[]): ContentBuilder;
+declare function poll(title: string, ...options: PollChoiceInput[]): ContentBuilder;
+
 declare const reactionSchema: z__default.ZodObject<{
     type: z__default.ZodLiteral<"reaction">;
     emoji: z__default.ZodString;
@@ -2234,4 +2269,4 @@ declare class UnsupportedError extends Error {
 declare const fromVCard: (vcf: string) => ContactInput;
 declare const toVCard: (contact: Contact) => Promise<string>;
 
-export { type CloudPlatform, type Contact, type ContactAddress, type ContactDetails, type ContactEmail, type ContactInput, type ContactName, type ContactOrg, type ContactPhone, Content, ContentBuilder, ContentInput, type DedicatedTokenData, Emoji, type EmojiKey, type Group, type ImessageInfoData, Message, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type Reaction, type Richlink, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, UnsupportedError, type UnsupportedKind, User, type Voice, attachment, cloud, contact, custom, definePlatform, fromVCard, group, reaction, resolveContents, richlink, text, toVCard, voice };
+export { type CloudPlatform, type Contact, type ContactAddress, type ContactDetails, type ContactEmail, type ContactInput, type ContactName, type ContactOrg, type ContactPhone, Content, ContentBuilder, ContentInput, type DedicatedTokenData, Emoji, type EmojiKey, type Group, type ImessageInfoData, Message, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type Poll, type PollChoice, type PollChoiceInput, type PollOption, type Reaction, type Richlink, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, UnsupportedError, type UnsupportedKind, User, type Voice, attachment, cloud, contact, custom, definePlatform, fromVCard, group, option, poll, reaction, resolveContents, richlink, text, toVCard, voice };