spectrum-ts 1.17.1 → 2.0.0

package/dist/{chunk-MC6ZKFSG.js → chunk-5XEFJBN2.js}

@@ -1,83 +1,5 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
 
-// src/utils/cloud.ts
-var SPECTRUM_CLOUD_URL = process.env.SPECTRUM_CLOUD_URL ?? "https://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 = {
-  getProject: (projectId, projectSecret) => request(`/projects/${projectId}/`, {
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  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) }
-  }),
-  issueSlackTokens: (projectId, projectSecret) => request(`/projects/${projectId}/slack/tokens`, {
-    method: "POST",
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  issueFusorToken: (projectId, projectSecret) => request(`/projects/${projectId}/fusor/token`, {
-    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 })
-  })
-};
-
 // src/utils/stream.ts
 import { Repeater } from "@repeaterjs/repeater";
 function createAsyncQueue() {
@@ -190,6 +112,16 @@ function broadcast(source) {
   let terminalError;
   let pumpPromise;
   let closed = false;
+  const closeConsumers = (error) => {
+    if (consumers.size === 0) {
+      return;
+    }
+    const current = Array.from(consumers);
+    consumers.clear();
+    for (const consumer of current) {
+      consumer.end(error);
+    }
+  };
   const startPump = () => {
     if (pumping || terminated) {
       return;
@@ -198,35 +130,35 @@ function broadcast(source) {
     pumpPromise = (async () => {
       try {
         for await (const value of source) {
-          for (const consumer of consumers) {
+          if (terminated) {
+            break;
+          }
+          for (const consumer of Array.from(consumers)) {
             consumer.deliveries = consumer.deliveries.then(
               () => consumer.emit(value).catch(() => {
               })
             );
           }
         }
+        if (terminated) {
+          return;
+        }
         terminated = true;
         await Promise.allSettled(
           Array.from(consumers, (consumer) => consumer.deliveries)
         );
-        for (const consumer of consumers) {
-          consumer.end();
-        }
-        consumers.clear();
+        closeConsumers();
       } catch (error) {
         terminated = true;
         terminalError = error;
-        for (const consumer of consumers) {
-          consumer.end(error);
-        }
-        consumers.clear();
+        closeConsumers(error);
       }
     })();
   };
   return {
     subscribe() {
       return stream((emit, end) => {
-        if (terminated) {
+        if (terminated || closed) {
           end(terminalError);
           return;
         }
@@ -247,27 +179,17 @@ function broadcast(source) {
         return;
       }
       closed = true;
-      try {
-        await source.close();
-        if (pumpPromise) {
-          await pumpPromise.catch(ignoreCleanupError);
-        }
-      } finally {
-        if (!terminated) {
-          terminated = true;
-          for (const consumer of consumers) {
-            consumer.end();
-          }
-          consumers.clear();
-        }
+      terminated = true;
+      closeConsumers();
+      await source.close().catch(ignoreCleanupError);
+      if (pumpPromise) {
+        await pumpPromise.catch(ignoreCleanupError);
       }
     }
   };
 }
 
 export {
-  SpectrumCloudError,
-  cloud,
   createAsyncQueue,
   stream,
   mergeStreams,

package/dist/{chunk-JQN6CRSC.js → chunk-6BI4PFTP.js}

@@ -3,37 +3,11 @@ import {
   bufferToStream,
   fetchUrlBytes,
   readSchema,
-  resolveContents,
   streamSchema
 } from "./chunk-2ILTJC35.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 });
-    }
-  };
-}
-
 // src/content/richlink.ts
-import z2 from "zod";
+import z from "zod";
 
 // src/utils/link-metadata.ts
 import ogs from "open-graph-scraper";
@@ -90,22 +64,22 @@ var fetchImage = (url) => fetchUrlBytes(new URL(url), {
 });
 
 // src/content/richlink.ts
-var richlinkCoverSchema = z2.object({
-  mimeType: z2.string().min(1).optional(),
+var richlinkCoverSchema = z.object({
+  mimeType: z.string().min(1).optional(),
   read: readSchema,
   stream: streamSchema
 });
-var optionalStringAccessor = z2.function({
+var optionalStringAccessor = z.function({
   input: [],
-  output: z2.promise(z2.string().min(1).optional())
+  output: z.promise(z.string().min(1).optional())
 });
-var coverAccessor = z2.function({
+var coverAccessor = z.function({
   input: [],
-  output: z2.promise(richlinkCoverSchema.optional())
+  output: z.promise(richlinkCoverSchema.optional())
 });
-var richlinkSchema = z2.object({
-  type: z2.literal("richlink"),
-  url: z2.url(),
+var richlinkSchema = z.object({
+  type: z.literal("richlink"),
+  url: z.url(),
   title: optionalStringAccessor,
   summary: optionalStringAccessor,
   cover: coverAccessor
@@ -150,9 +124,6 @@ function richlink(url) {
 }
 
 export {
-  groupSchema,
-  asGroup,
-  group,
   asRichlink,
   richlink
 };

package/dist/{chunk-QGJFZMD5.js → chunk-6UZFVXQF.js}

@@ -1,7 +1,4 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  readSchema
-} from "./chunk-2ILTJC35.js";
 
 // src/utils/vcard.ts
 import vCard from "vcf";
@@ -350,109 +347,28 @@ var writePhoto = async (card, photo) => {
     type: photoTypeParam(photo.mimeType)
   });
 };
-var toVCard = async (contact2) => {
-  if (typeof contact2.raw === "string" && contact2.raw.startsWith("BEGIN:VCARD")) {
-    return contact2.raw;
+var toVCard = async (contact) => {
+  if (typeof contact.raw === "string" && contact.raw.startsWith("BEGIN:VCARD")) {
+    return contact.raw;
   }
   const card = new vCard();
-  writeName(card, contact2.name);
-  writePhones(card, contact2.phones);
-  writeEmails(card, contact2.emails);
-  writeAddresses(card, contact2.addresses);
-  writeOrg(card, contact2.org);
-  writeUrls(card, contact2.urls);
-  if (contact2.birthday) {
-    card.set("bday", contact2.birthday);
-  }
-  if (contact2.note) {
-    card.set("note", contact2.note);
-  }
-  await writePhoto(card, contact2.photo);
+  writeName(card, contact.name);
+  writePhones(card, contact.phones);
+  writeEmails(card, contact.emails);
+  writeAddresses(card, contact.addresses);
+  writeOrg(card, contact.org);
+  writeUrls(card, contact.urls);
+  if (contact.birthday) {
+    card.set("bday", contact.birthday);
+  }
+  if (contact.note) {
+    card.set("note", contact.note);
+  }
+  await writePhoto(card, contact.photo);
   return card.toString();
 };
 
-// src/content/contact.ts
-import vCard2 from "vcf";
-import z from "zod";
-var userRefSchema = z.object({
-  __platform: z.string(),
-  id: z.string()
-});
-var nameSchema = z.object({
-  formatted: z.string().optional(),
-  first: z.string().optional(),
-  last: z.string().optional(),
-  middle: z.string().optional(),
-  prefix: z.string().optional(),
-  suffix: z.string().optional()
-});
-var phoneTypeSchema = z.enum(["mobile", "home", "work", "other"]);
-var emailTypeSchema = z.enum(["home", "work", "other"]);
-var addressTypeSchema = z.enum(["home", "work", "other"]);
-var phoneSchema = z.object({
-  value: z.string(),
-  type: phoneTypeSchema.optional()
-});
-var emailSchema = z.object({
-  value: z.string(),
-  type: emailTypeSchema.optional()
-});
-var addressSchema = z.object({
-  street: z.string().optional(),
-  city: z.string().optional(),
-  region: z.string().optional(),
-  postalCode: z.string().optional(),
-  country: z.string().optional(),
-  type: addressTypeSchema.optional()
-});
-var orgSchema = z.object({
-  name: z.string().optional(),
-  title: z.string().optional(),
-  department: z.string().optional()
-});
-var photoSchema = z.object({
-  mimeType: z.string(),
-  read: readSchema
-});
-var contactSchema = z.object({
-  type: z.literal("contact"),
-  user: userRefSchema.optional(),
-  name: nameSchema.optional(),
-  phones: z.array(phoneSchema).optional(),
-  emails: z.array(emailSchema).optional(),
-  addresses: z.array(addressSchema).optional(),
-  org: orgSchema.optional(),
-  urls: z.array(z.string()).optional(),
-  birthday: z.string().optional(),
-  note: z.string().optional(),
-  photo: photoSchema.optional(),
-  raw: z.unknown().optional()
-});
-var asContact = (input) => contactSchema.parse({ type: "contact", ...input });
-var isUser = (value) => typeof value === "object" && value !== null && "__platform" in value && "id" in value && typeof value.__platform === "string" && typeof value.id === "string";
-function contact(input, details) {
-  return {
-    build: async () => {
-      if (typeof input === "string") {
-        return asContact(fromVCard(input));
-      }
-      if (input instanceof vCard2) {
-        return asContact(fromVCard(input.toString()));
-      }
-      if (isUser(input)) {
-        return asContact({
-          user: { __platform: input.__platform, id: input.id },
-          ...details
-        });
-      }
-      return asContact(input);
-    }
-  };
-}
-
 export {
   fromVCard,
-  toVCard,
-  asContact,
-  contact
+  toVCard
 };