spectrum-ts 0.4.0 → 0.6.0

package/dist/chunk-XZTTLPHE.js

@@ -0,0 +1,341 @@
+// src/content/text.ts
+import z from "zod";
+var textSchema = z.object({
+  type: z.literal("text"),
+  text: z.string().nonempty()
+});
+var asText = (text2) => textSchema.parse({ type: "text", text: text2 });
+function text(text2) {
+  return {
+    build: async () => asText(text2)
+  };
+}
+
+// src/content/resolve.ts
+var resolveContents = (items) => Promise.all(
+  items.map((c) => typeof c === "string" ? text(c).build() : c.build())
+);
+
+// src/platform/build.ts
+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) {
+      const sendResult = await definition.actions.send({
+        ...typingCtx,
+        content: item
+      });
+      if (!sendResult?.id) {
+        throw new Error(
+          `Platform "${definition.name}" send did not return a message id`
+        );
+      }
+      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"
+        })
+      );
+    }
+    return content.length === 1 && results[0] ? results[0] : results;
+  }
+  space = {
+    ...extras,
+    ...spaceRef,
+    send: sendImpl,
+    edit: async (message, newContent) => {
+      await message.edit(newContent);
+    },
+    startTyping: async () => {
+      await definition.actions.startTyping?.(typingCtx);
+    },
+    stopTyping: async () => {
+      await definition.actions.stopTyping?.(typingCtx);
+    },
+    responding: async (fn) => {
+      await definition.actions.startTyping?.(typingCtx);
+      try {
+        return await fn();
+      } finally {
+        await definition.actions.stopTyping?.(typingCtx).catch(() => {
+        });
+      }
+    }
+  };
+  return space;
+}
+function buildMessage(params) {
+  const { definition, client, config, spaceRef, space } = params;
+  const react = async (reaction) => {
+    if (!definition.actions.reactToMessage) {
+      return;
+    }
+    await definition.actions.reactToMessage({
+      space: spaceRef,
+      messageId: params.id,
+      reaction,
+      client,
+      config
+    });
+  };
+  async function reply(...content) {
+    if (!definition.actions.replyToMessage) {
+      throw new Error(
+        `Platform "${definition.name}" does not support replying to messages`
+      );
+    }
+    const resolved = await resolveContents(content);
+    const results = [];
+    for (const item of resolved) {
+      const sendResult = await definition.actions.replyToMessage({
+        space: spaceRef,
+        messageId: params.id,
+        content: item,
+        client,
+        config
+      });
+      if (!sendResult?.id) {
+        throw new Error(
+          `Platform "${definition.name}" reply did not return a message id`
+        );
+      }
+      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"
+        })
+      );
+    }
+    return content.length === 1 && results[0] ? results[0] : results;
+  }
+  const senderWithPlatform = params.sender === void 0 ? void 0 : { ...params.sender, __platform: definition.name };
+  if (params.direction === "outbound") {
+    return {
+      ...params.extras,
+      id: params.id,
+      content: params.content,
+      direction: "outbound",
+      platform: definition.name,
+      react,
+      reply,
+      edit: async (newContent) => {
+        if (!definition.actions.editMessage) {
+          throw new Error(
+            `Platform "${definition.name}" does not support editing messages`
+          );
+        }
+        const [resolved] = await resolveContents([newContent]);
+        if (!resolved) {
+          return;
+        }
+        await definition.actions.editMessage({
+          space: spaceRef,
+          messageId: params.id,
+          content: resolved,
+          client,
+          config
+        });
+      },
+      sender: senderWithPlatform,
+      space,
+      timestamp: params.timestamp
+    };
+  }
+  return {
+    ...params.extras,
+    id: params.id,
+    content: params.content,
+    direction: "inbound",
+    platform: definition.name,
+    react,
+    reply,
+    sender: senderWithPlatform,
+    space,
+    timestamp: params.timestamp
+  };
+}
+
+// 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 normalizeSpaceArgs = (args) => {
+    if (args.length === 0) {
+      return { users: [], params: void 0 };
+    }
+    const [first, ...rest] = args;
+    if (Array.isArray(first)) {
+      return {
+        users: first,
+        params: rest[0]
+      };
+    }
+    if (!isPlatformUser(first)) {
+      return {
+        users: [],
+        params: first
+      };
+    }
+    const last = args.at(-1);
+    if (last !== void 0 && !isPlatformUser(last)) {
+      return {
+        users: args.slice(0, -1),
+        params: last
+      };
+    }
+    return {
+      users: args,
+      params: void 0
+    };
+  };
+  const base = {
+    async user(userID) {
+      const resolved = await def.user.resolve({
+        input: { userID },
+        client: runtime.client,
+        config: runtime.config
+      });
+      return {
+        ...resolved,
+        __platform: def.name
+      };
+    },
+    async space(...args) {
+      const { users, params } = normalizeSpaceArgs(args);
+      let parsedParams = params;
+      if (params !== void 0 && def.space.params) {
+        parsedParams = def.space.params.parse(params);
+      }
+      const resolved = await def.space.resolve({
+        input: { users, params: parsedParams },
+        client: runtime.client,
+        config: runtime.config
+      });
+      const parsedSpace = def.space.schema ? def.space.schema.parse(resolved) : resolved;
+      const spaceRef = {
+        id: parsedSpace.id,
+        __platform: def.name
+      };
+      const typingCtx = {
+        space: spaceRef,
+        client: runtime.client,
+        config: runtime.config
+      };
+      return buildSpace({
+        spaceRef,
+        extras: parsedSpace,
+        typingCtx,
+        definition: def,
+        client: runtime.client,
+        config: runtime.config
+      });
+    }
+  };
+  const eventProperties = {};
+  for (const eventName of Object.keys(def.events)) {
+    if (eventName === "messages") {
+      continue;
+    }
+    const producer = def.events[eventName];
+    if (producer) {
+      eventProperties[eventName] = producer({
+        client: runtime.client,
+        config: runtime.config
+      });
+    }
+  }
+  return Object.assign(base, eventProperties);
+}
+function definePlatform(name, def) {
+  const fullDef = { name, ...def };
+  const platformCache = /* @__PURE__ */ new WeakMap();
+  const narrowSpectrum = (spectrum) => {
+    const cached = platformCache.get(spectrum);
+    if (cached) {
+      return cached;
+    }
+    const runtime = spectrum.__internal.platforms.get(name);
+    if (!runtime) {
+      throw new Error(`Platform "${name}" is not registered`);
+    }
+    const instance = createPlatformInstance(
+      fullDef,
+      runtime
+    );
+    platformCache.set(spectrum, instance);
+    return instance;
+  };
+  const narrowSpace = (input) => {
+    if (input.__platform !== name) {
+      throw new Error(
+        `Expected space from "${name}", got "${input.__platform}"`
+      );
+    }
+    return input;
+  };
+  const narrowMessage = (input) => {
+    if (input.platform !== name) {
+      throw new Error(
+        `Expected message from "${name}", got "${input.platform}"`
+      );
+    }
+    return input;
+  };
+  const narrower = ((input) => {
+    if ("__providers" in input && "__internal" in input) {
+      return narrowSpectrum(input);
+    }
+    if ("__platform" in input && "send" in input) {
+      return narrowSpace(input);
+    }
+    if ("platform" in input && "sender" in input && "space" in input) {
+      return narrowMessage(input);
+    }
+    throw new Error("Invalid input to platform narrowing function");
+  });
+  narrower.config = (config) => {
+    const resolvedConfig = config ?? {};
+    return {
+      __tag: "PlatformProviderConfig",
+      __def: void 0,
+      __name: name,
+      config: resolvedConfig,
+      __definition: fullDef
+    };
+  };
+  if (def.static) {
+    Object.assign(narrower, def.static);
+  }
+  return narrower;
+}
+
+export {
+  asText,
+  text,
+  resolveContents,
+  buildSpace,
+  buildMessage,
+  definePlatform
+};

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { C as ContentBuilder, 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, M as Message } from './types-BdWMydUJ.js';
-export { A as AnyPlatformDef, E as EventProducer, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage, U as User } from './types-BdWMydUJ.js';
+import { C as ContentBuilder, U as User, 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-DZMHfgYQ.js';
+export { A as AnyPlatformDef, E as EventProducer, M as Message, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage } from './types-DZMHfgYQ.js';
+import vCard from 'vcf';
 import z__default from 'zod';
 export { M as ManagedStream, m as mergeStreams, s as stream } from './stream-DGy4geUK.js';
 import 'hotscript';
@@ -9,12 +10,138 @@ declare function attachment(input: string | Buffer, options?: {
     name?: string;
 }): ContentBuilder;
 
+declare const nameSchema: 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>;
+declare const phoneSchema: 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>;
+declare const emailSchema: z__default.ZodObject<{
+    value: z__default.ZodString;
+    type: z__default.ZodOptional<z__default.ZodEnum<{
+        home: "home";
+        work: "work";
+        other: "other";
+    }>>;
+}, z__default.core.$strip>;
+declare const addressSchema: 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>;
+declare const orgSchema: 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>;
+declare const contactSchema: 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>;
+type Contact = z__default.infer<typeof contactSchema>;
+type ContactName = z__default.infer<typeof nameSchema>;
+type ContactPhone = z__default.infer<typeof phoneSchema>;
+type ContactEmail = z__default.infer<typeof emailSchema>;
+type ContactAddress = z__default.infer<typeof addressSchema>;
+type ContactOrg = z__default.infer<typeof orgSchema>;
+type ContactInput = Omit<Contact, "type">;
+type ContactDetails = Omit<ContactInput, "user">;
+declare function contact(user: User, details?: ContactDetails): ContentBuilder;
+declare function contact(input: string | ContactInput | vCard): ContentBuilder;
+
 declare function custom(raw: unknown): ContentBuilder;
 
 declare const resolveContents: (items: readonly ContentInput[]) => Promise<Content[]>;
 
 declare function text(text: string): ContentBuilder;
 
+declare const voiceSchema: 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 Voice = z__default.infer<typeof voiceSchema>;
+declare function voice(input: string | Buffer, options?: {
+    mimeType?: string;
+    name?: string;
+    duration?: number;
+}): ContentBuilder;
+
 declare function definePlatform<_Name extends string, _ConfigSchema extends z__default.ZodType<object>, _UserSchema extends z__default.ZodType<object> | undefined, _SpaceSchema extends z__default.ZodType<object> | undefined, _SpaceParamsSchema extends z__default.ZodType<object> | undefined, _Client, _ResolvedUser extends {
     id: string;
 }, _ResolvedSpace extends {
@@ -34,9 +161,11 @@ declare function definePlatform<_Name extends string, _ConfigSchema extends z__d
 }): Platform<PlatformDef<_Name, _ConfigSchema, _UserSchema, _SpaceSchema, _SpaceParamsSchema, _Client, _ResolvedUser, _ResolvedSpace, _MessageSchema, _MessageType, _Events>> & Readonly<_Static>;
 
 type SpectrumInstance<Providers extends PlatformProviderConfig[] = PlatformProviderConfig[]> = SpectrumLike<Providers> & CustomEventStreams<Providers> & {
-    readonly messages: AsyncIterable<[Space, Message]>;
+    readonly messages: AsyncIterable<[Space, InboundMessage]>;
     stop(): Promise<void>;
-    send(space: Space, ...content: [ContentInput, ...ContentInput[]]): Promise<void>;
+    send(space: Space, content: ContentInput): Promise<OutboundMessage>;
+    send(space: Space, ...content: [ContentInput, ContentInput, ...ContentInput[]]): Promise<OutboundMessage[]>;
+    edit(message: OutboundMessage, newContent: ContentInput): Promise<void>;
     responding<T>(space: Space, fn: () => T | Promise<T>): Promise<T>;
 };
 declare function Spectrum<const Providers extends PlatformProviderConfig[]>(options: {
@@ -86,4 +215,7 @@ declare const cloud: {
     togglePlatform: (projectId: string, projectSecret: string, platform: CloudPlatform, enabled: boolean) => Promise<PlatformsData>;
 };
 
-export { type CloudPlatform, Content, ContentBuilder, ContentInput, type DedicatedTokenData, type ImessageInfoData, Message, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, attachment, cloud, custom, definePlatform, resolveContents, text };
+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, type ImessageInfoData, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, User, type Voice, attachment, cloud, contact, custom, definePlatform, fromVCard, resolveContents, text, toVCard, voice };