spectrum-ts 0.5.0 → 0.6.1

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,5 @@
-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, M as Message } from './types-CfiD_00g.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-CfiD_00g.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';
@@ -161,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: {
@@ -216,4 +218,4 @@ declare const cloud: {
 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, Message, 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 };
+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 };

package/dist/index.js

@@ -15,10 +15,12 @@ import {
   toVCard
 } from "./chunk-UZWRB3FZ.js";
 import {
+  buildMessage,
+  buildSpace,
   definePlatform,
   resolveContents,
   text
-} from "./chunk-XEEDIGVK.js";
+} from "./chunk-XZTTLPHE.js";
 
 // src/content/voice.ts
 import { createReadStream } from "fs";
@@ -207,72 +209,27 @@ async function Spectrum(options) {
           __platform: definition.name
         };
         const typingCtx = { space: spaceRef, client, config };
-        const space = {
-          ...spaceRef,
-          send: async (...content) => {
-            const resolved = await resolveContents(content);
-            for (const item of resolved) {
-              await definition.actions.send({
-                ...typingCtx,
-                content: item
-              });
-            }
-          },
-          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(() => {
-              });
-            }
-          }
-        };
-        const normalizedMessage = {
-          ...parsedExtra,
+        const space = buildSpace({
+          spaceRef,
+          extras: {},
+          typingCtx,
+          definition,
+          client,
+          config
+        });
+        const normalizedMessage = buildMessage({
           id: msg.id,
           content: msg.content,
-          platform: definition.name,
-          react: async (reaction) => {
-            if (!definition.actions.reactToMessage) {
-              return;
-            }
-            await definition.actions.reactToMessage({
-              space: spaceRef,
-              messageId: msg.id,
-              reaction,
-              client,
-              config
-            });
-          },
-          reply: async (...content) => {
-            if (!definition.actions.replyToMessage) {
-              return;
-            }
-            const resolved = await resolveContents(content);
-            for (const item of resolved) {
-              await definition.actions.replyToMessage({
-                space: spaceRef,
-                messageId: msg.id,
-                content: item,
-                client,
-                config
-              });
-            }
-          },
-          sender: {
-            ...msg.sender,
-            __platform: definition.name
-          },
+          sender: msg.sender,
+          timestamp: msg.timestamp ?? /* @__PURE__ */ new Date(),
+          extras: parsedExtra,
+          spaceRef,
           space,
-          timestamp: msg.timestamp ?? /* @__PURE__ */ new Date()
-        };
+          definition,
+          client,
+          config,
+          direction: "inbound"
+        });
         yield [space, normalizedMessage];
       }
     };
@@ -383,8 +340,13 @@ async function Spectrum(options) {
     __internal: { platforms: platformStates },
     messages,
     stop: stopOnce,
-    send: async (space, ...content) => {
-      await space.send(...content);
+    send: (async (space, ...content) => {
+      return content.length === 1 ? await space.send(content[0]) : await space.send(
+        ...content
+      );
+    }),
+    edit: async (message, newContent) => {
+      await message.edit(newContent);
     },
     responding: async (space, fn) => {
       return space.responding(fn);

package/dist/providers/imessage/index.d.ts

@@ -3,7 +3,7 @@ import { AdvancedIMessage } from '@photon-ai/advanced-imessage';
 import { IMessageSDK } from '@photon-ai/imessage-kit';
 import * as z from 'zod';
 import z__default from 'zod';
-import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-CfiD_00g.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-DZMHfgYQ.js';
 import * as zod_v4_core from 'zod/v4/core';
 import 'hotscript';