spectrum-ts 0.9.0 → 1.0.1

package/dist/chunk-2Y5GBI6W.js

@@ -0,0 +1,129 @@
+// 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 {
+  stream,
+  mergeStreams,
+  SpectrumCloudError,
+  cloud
+};

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-6ZOLTQDN.js → chunk-LAGNM6I7.js}

@@ -1,11 +1,37 @@
 import {
   bufferToStream,
   readSchema,
+  resolveContents,
   streamSchema
-} from "./chunk-CZIWNTXP.js";
+} from "./chunk-XMAI2AAN.js";
 
-// src/content/richlink.ts
+// 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 });
+    }
+  };
+}
+
+// src/content/richlink.ts
+import z2 from "zod";
 
 // src/utils/link-metadata.ts
 import ogs from "open-graph-scraper";
@@ -76,22 +102,22 @@ var fetchImage = async (url) => {
 };
 
 // src/content/richlink.ts
-var richlinkCoverSchema = z.object({
-  mimeType: z.string().min(1).optional(),
+var richlinkCoverSchema = z2.object({
+  mimeType: z2.string().min(1).optional(),
   read: readSchema,
   stream: streamSchema
 });
-var optionalStringAccessor = z.function({
+var optionalStringAccessor = z2.function({
   input: [],
-  output: z.promise(z.string().min(1).optional())
+  output: z2.promise(z2.string().min(1).optional())
 });
-var coverAccessor = z.function({
+var coverAccessor = z2.function({
   input: [],
-  output: z.promise(richlinkCoverSchema.optional())
+  output: z2.promise(richlinkCoverSchema.optional())
 });
-var richlinkSchema = z.object({
-  type: z.literal("richlink"),
-  url: z.url(),
+var richlinkSchema = z2.object({
+  type: z2.literal("richlink"),
+  url: z2.url(),
   title: optionalStringAccessor,
   summary: optionalStringAccessor,
   cover: coverAccessor
@@ -136,6 +162,8 @@ function richlink(url) {
 }
 
 export {
+  asGroup,
+  group,
   asRichlink,
   richlink
 };