spectrum-ts 0.9.1 → 1.1.0

package/dist/chunk-7Q7KJKGL.js

@@ -0,0 +1,117 @@
+import {
+  bufferToStream,
+  readSchema,
+  streamSchema
+} from "./chunk-XMAI2AAN.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 (typeof input === "string") {
+    return basename(input);
+  }
+  return void 0;
+};
+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 = typeof input === "string" ? basename(input) : name;
+      const mimeType = resolveVoiceMimeType(mimeHint, options?.mimeType);
+      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-HU2EOF3K.js → chunk-LAGNM6I7.js}

@@ -1,11 +1,9 @@
 import {
   bufferToStream,
   readSchema,
+  resolveContents,
   streamSchema
-} from "./chunk-OIXH5S65.js";
-import {
-  resolveContents
-} from "./chunk-U6WCQVVX.js";
+} from "./chunk-XMAI2AAN.js";
 
 // src/content/group.ts
 import z from "zod";

package/dist/chunk-PXX7ISZ6.js

@@ -0,0 +1,188 @@
+// src/content/poll.ts
+import z from "zod";
+var pollChoiceSchema = z.object({
+  title: z.string().nonempty()
+});
+var pollSchema = z.object({
+  type: z.literal("poll"),
+  title: z.string().nonempty().max(300),
+  options: z.array(pollChoiceSchema).min(2).max(10)
+});
+var pollOptionSchema = z.object({
+  type: z.literal("poll_option"),
+  option: pollChoiceSchema,
+  poll: pollSchema,
+  selected: z.boolean(),
+  title: z.string().nonempty()
+}).superRefine((value, ctx) => {
+  if (value.title !== value.option.title) {
+    ctx.addIssue({
+      code: "custom",
+      message: "poll_option title must match option.title",
+      path: ["title"]
+    });
+  }
+  if (!value.poll.options.some(
+    (pollOption) => pollOption.title === value.option.title
+  )) {
+    ctx.addIssue({
+      code: "custom",
+      message: "poll_option option must exist in poll.options",
+      path: ["option"]
+    });
+  }
+});
+var asPoll = (input) => pollSchema.parse({ type: "poll", ...input });
+var asPollOption = (input) => pollOptionSchema.parse({
+  type: "poll_option",
+  ...input,
+  title: input.option.title
+});
+var option = (title) => ({ title });
+var normalize = (raw) => typeof raw === "string" ? { title: raw } : { title: raw.title };
+var collectOptions = (args) => {
+  const [first] = args;
+  if (args.length === 1 && Array.isArray(first)) {
+    return first;
+  }
+  return args;
+};
+function poll(title, ...rest) {
+  return {
+    build: async () => asPoll({ title, options: collectOptions(rest).map(normalize) })
+  };
+}
+
+// src/utils/stream.ts
+import { Repeater } from "@repeaterjs/repeater";
+function stream(setup) {
+  const repeater = new Repeater(async (push, stop) => {
+    const emit = async (value) => {
+      try {
+        await push(value);
+      } catch (error) {
+        stop(error);
+        throw error;
+      }
+    };
+    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) {
+          await 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);
+    };
+  });
+}
+
+// src/utils/cloud.ts
+var SPECTRUM_CLOUD_URL = `https://${process.env.SPECTRUM_CLOUD_URL ?? "spectrum.photon.codes"}`;
+var SpectrumCloudError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.name = "SpectrumCloudError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var request = async (path, init) => {
+  const response = await fetch(`${SPECTRUM_CLOUD_URL}${path}`, init);
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    try {
+      const parsed = JSON.parse(body);
+      throw new SpectrumCloudError(
+        response.status,
+        parsed.code,
+        parsed.message
+      );
+    } catch (error) {
+      if (error instanceof SpectrumCloudError) {
+        throw error;
+      }
+      throw new SpectrumCloudError(
+        response.status,
+        "UNKNOWN",
+        body || response.statusText
+      );
+    }
+  }
+  const json = await response.json();
+  if (!json.succeed) {
+    throw new SpectrumCloudError(
+      response.status,
+      "UNKNOWN",
+      "Server returned succeed=false"
+    );
+  }
+  return json.data;
+};
+var basicAuth = (projectId, projectSecret) => `Basic ${btoa(`${projectId}:${projectSecret}`)}`;
+var cloud = {
+  getSubscription: (projectId) => request(`/projects/${projectId}/billing/subscription`),
+  issueImessageTokens: (projectId, projectSecret) => request(`/projects/${projectId}/imessage/tokens`, {
+    method: "POST",
+    headers: { Authorization: basicAuth(projectId, projectSecret) }
+  }),
+  getImessageInfo: (projectId) => request(`/projects/${projectId}/imessage/`),
+  issueWhatsappBusinessTokens: (projectId, projectSecret) => request(`/projects/${projectId}/whatsapp-business/tokens`, {
+    method: "POST",
+    headers: { Authorization: basicAuth(projectId, projectSecret) }
+  }),
+  getPlatforms: (projectId) => request(`/projects/${projectId}/platforms/`),
+  togglePlatform: (projectId, projectSecret, platform, enabled) => request(`/projects/${projectId}/platforms/`, {
+    method: "PATCH",
+    headers: {
+      Authorization: basicAuth(projectId, projectSecret),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ platform, enabled })
+  })
+};
+
+export {
+  asPoll,
+  asPollOption,
+  option,
+  poll,
+  stream,
+  mergeStreams,
+  SpectrumCloudError,
+  cloud
+};