spectrum-ts 0.9.0 → 1.0.1

package/dist/chunk-PLJI5FTO.js

@@ -1,513 +0,0 @@
-// 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/utils/errors.ts
-var composeMessage = (opts) => {
-  const platform = opts.platform ?? "platform";
-  const subject = opts.kind === "content" ? `content type "${opts.contentType ?? "unknown"}"` : `action "${opts.action ?? "unknown"}"`;
-  const detail = opts.detail ? `: ${opts.detail}` : "";
-  return `${platform} does not support ${subject}${detail}`;
-};
-var UnsupportedError = class _UnsupportedError extends Error {
-  kind;
-  platform;
-  contentType;
-  action;
-  detail;
-  constructor(opts) {
-    super(composeMessage(opts));
-    this.name = "UnsupportedError";
-    this.kind = opts.kind;
-    this.platform = opts.platform;
-    this.contentType = opts.contentType;
-    this.action = opts.action;
-    this.detail = opts.detail;
-  }
-  static content(contentType, platform, detail) {
-    return new _UnsupportedError({
-      kind: "content",
-      contentType,
-      platform,
-      detail
-    });
-  }
-  static action(action, platform, detail) {
-    return new _UnsupportedError({ kind: "action", action, platform, detail });
-  }
-  withPlatform(platform) {
-    if (this.platform) {
-      return this;
-    }
-    return new _UnsupportedError({
-      kind: this.kind,
-      platform,
-      contentType: this.contentType,
-      action: this.action,
-      detail: this.detail
-    });
-  }
-};
-
-// src/platform/build.ts
-var ANSI_YELLOW = "\x1B[33m";
-var ANSI_RESET = "\x1B[0m";
-var supportsAnsiColor = () => {
-  if (typeof process === "undefined") {
-    return false;
-  }
-  if (process.env.NO_COLOR) {
-    return false;
-  }
-  const force = process.env.FORCE_COLOR;
-  if (force !== void 0) {
-    return force !== "" && force !== "0" && force !== "false";
-  }
-  return Boolean(process.stderr?.isTTY);
-};
-var warnUnsupported = (err, fallbackPlatform) => {
-  const platform = err.platform ?? fallbackPlatform;
-  const subject = err.kind === "content" ? `content type "${err.contentType ?? "unknown"}"` : `action "${err.action ?? "unknown"}"`;
-  const detail = err.detail ? `: ${err.detail}` : "";
-  const body = `[spectrum-ts] ${platform} does not support ${subject}${detail}; skipping.`;
-  console.warn(
-    supportsAnsiColor() ? `${ANSI_YELLOW}${body}${ANSI_RESET}` : body
-  );
-};
-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) {
-      if (item.type === "reaction") {
-        await dispatchReaction(item);
-        continue;
-      }
-      const sent = await dispatchSend(item);
-      if (sent) {
-        results.push(sent);
-      }
-    }
-    if (content.length === 1) {
-      return results[0];
-    }
-    return 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) {
-      warnUnsupported(
-        UnsupportedError.action("react", definition.name),
-        definition.name
-      );
-      return;
-    }
-    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) {
-      warnUnsupported(
-        UnsupportedError.action("reply", definition.name),
-        definition.name
-      );
-      return content.length === 1 ? void 0 : [];
-    }
-    const resolved = await resolveContents(content);
-    const results = [];
-    for (const item of resolved) {
-      let sendResult;
-      try {
-        sendResult = await definition.actions.replyToMessage({
-          space: spaceRef,
-          messageId: params.id,
-          content: item,
-          client,
-          config
-        });
-      } catch (err) {
-        if (err instanceof UnsupportedError) {
-          warnUnsupported(err, definition.name);
-          continue;
-        }
-        throw err;
-      }
-      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"
-        })
-      );
-    }
-    if (content.length === 1) {
-      return results[0];
-    }
-    return 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) {
-          warnUnsupported(
-            UnsupportedError.action("edit", definition.name),
-            definition.name
-          );
-          return;
-        }
-        const [resolved] = await resolveContents([newContent]);
-        if (!resolved) {
-          return;
-        }
-        try {
-          await definition.actions.editMessage({
-            space: spaceRef,
-            messageId: params.id,
-            content: resolved,
-            client,
-            config
-          });
-        } catch (err) {
-          if (err instanceof UnsupportedError) {
-            warnUnsupported(err, definition.name);
-            return;
-          }
-          throw err;
-        }
-      },
-      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 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 };
-    }
-    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 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);
-      }
-      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,
-  UnsupportedError,
-  buildSpace,
-  buildMessage,
-  definePlatform
-};