spectrum-ts 4.2.0 → 5.1.0

package/dist/chunk-FAIFTUV2.js

@@ -1,139 +0,0 @@
-import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  bufferToStream,
-  fetchUrlBytes,
-  readSchema,
-  streamSchema
-} from "./chunk-UXAKIXVM.js";
-
-// src/content/voice.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 AUDIO_MIME_PATTERN = /^audio\//i;
-var audioMimeSchema = z.string().nonempty().regex(AUDIO_MIME_PATTERN, "voice content requires an audio/* MIME type");
-var voiceSchema = z.object({
-  type: z.literal("voice"),
-  name: z.string().nonempty().optional(),
-  mimeType: audioMimeSchema,
-  duration: z.number().nonnegative().optional(),
-  size: z.number().int().nonnegative().optional(),
-  read: readSchema,
-  stream: streamSchema
-});
-var resolveVoiceName = (input, name) => {
-  if (name) {
-    return name;
-  }
-  if (input instanceof URL) {
-    return basename(input.pathname) || void 0;
-  }
-  if (typeof input === "string") {
-    return basename(input);
-  }
-  return;
-};
-var resolveVoiceMimeHint = (input, name) => {
-  if (input instanceof URL) {
-    return basename(input.pathname) || void 0;
-  }
-  if (typeof input === "string") {
-    return basename(input);
-  }
-  return name;
-};
-var resolveVoiceMimeType = (name, mimeType) => {
-  if (mimeType) {
-    if (!AUDIO_MIME_PATTERN.test(mimeType)) {
-      throw new Error(
-        `voice content requires an audio/* MIME type, got "${mimeType}".`
-      );
-    }
-    return mimeType;
-  }
-  if (name) {
-    const resolved = lookupMimeType(name);
-    if (resolved && AUDIO_MIME_PATTERN.test(resolved)) {
-      return resolved;
-    }
-    if (resolved) {
-      throw new Error(
-        `Resolved non-audio MIME type "${resolved}" from name "${name}". Pass options.mimeType explicitly with an audio/* type.`
-      );
-    }
-  }
-  throw new Error(
-    "Unable to resolve MIME type for voice content. Pass options.mimeType explicitly."
-  );
-};
-var asVoice = (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 voiceSchema.parse({
-    type: "voice",
-    name: input.name,
-    mimeType: input.mimeType,
-    duration: input.duration,
-    size: input.size,
-    read,
-    stream
-  });
-};
-function voice(input, options) {
-  return {
-    build: async () => {
-      const name = resolveVoiceName(input, options?.name);
-      const mimeHint = resolveVoiceMimeHint(input, name);
-      const mimeType = resolveVoiceMimeType(mimeHint, options?.mimeType);
-      if (input instanceof URL) {
-        return asVoice({
-          name,
-          mimeType,
-          duration: options?.duration,
-          read: async () => (await fetchUrlBytes(input)).data
-        });
-      }
-      if (typeof input === "string") {
-        const stats = await stat(input);
-        if (!stats.isFile()) {
-          throw new Error(
-            `voice content path "${input}" is not a regular file.`
-          );
-        }
-        return asVoice({
-          name,
-          mimeType,
-          duration: options?.duration,
-          size: stats.size,
-          read: () => readFile(input),
-          stream: async () => Readable.toWeb(
-            createReadStream(input)
-          )
-        });
-      }
-      return asVoice({
-        name,
-        mimeType,
-        duration: options?.duration,
-        size: input.byteLength,
-        read: async () => input,
-        stream: async () => bufferToStream(input)
-      });
-    }
-  };
-}
-
-export {
-  asVoice,
-  voice
-};

package/dist/chunk-LZXPLXZF.js

@@ -1,35 +0,0 @@
-import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  resolveContents
-} from "./chunk-UXAKIXVM.js";
-
-// src/content/group.ts
-import z from "zod";
-var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
-var groupSchema = z.object({
-  type: z.literal("group"),
-  items: z.array(z.custom(isMessage)).min(2)
-});
-var asGroup = (input) => groupSchema.parse({ type: "group", items: input.items });
-var stubOutboundMessage = (content) => ({ id: "", content });
-function group(...items) {
-  return {
-    build: async () => {
-      const resolved = await resolveContents(items);
-      const members = [];
-      for (const item of resolved) {
-        if (item.type === "group" || item.type === "reaction") {
-          throw new Error(`group() cannot contain "${item.type}" items`);
-        }
-        members.push(stubOutboundMessage(item));
-      }
-      return asGroup({ items: members });
-    }
-  };
-}
-
-export {
-  groupSchema,
-  asGroup,
-  group
-};