spectrum-ts 0.4.0 → 0.6.0

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
-};

package/dist/chunk-XEEDIGVK.js

@@ -1,199 +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/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 {
-        ...parsedSpace,
-        ...spaceRef,
-        send: async (...content) => {
-          const built = await resolveContents(content);
-          for (const item of built) {
-            await def.actions.send({
-              ...typingCtx,
-              content: item
-            });
-          }
-        },
-        startTyping: async () => {
-          await def.actions.startTyping?.(typingCtx);
-        },
-        stopTyping: async () => {
-          await def.actions.stopTyping?.(typingCtx);
-        },
-        responding: async (fn) => {
-          await def.actions.startTyping?.(typingCtx);
-          try {
-            return await fn();
-          } finally {
-            await def.actions.stopTyping?.(typingCtx).catch(() => {
-            });
-          }
-        }
-      };
-    }
-  };
-  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,
-  definePlatform
-};