@symbo.ls/sdk 2.34.35 → 3.1.1

package/dist/node/services/WaitlistService.js

@@ -1,129 +0,0 @@
-import { BaseService } from "./BaseService.js";
-class WaitlistService extends BaseService {
-  // ==================== WAITLIST METHODS ====================
-  /**
-   * Join a waitlist campaign (public).
-   *
-   * Mirrors: POST /waitlist (WaitlistController.join)
-   */
-  async joinWaitlist(data = {}) {
-    this._requireReady("joinWaitlist");
-    if (!data || typeof data !== "object") {
-      throw new Error("Waitlist join payload is required");
-    }
-    if (!data.email) {
-      throw new Error("Email is required");
-    }
-    try {
-      const response = await this._request("/waitlist", {
-        method: "POST",
-        body: JSON.stringify(data),
-        methodName: "joinWaitlist"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to join waitlist: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * List waitlist entries (admin).
-   *
-   * Mirrors: GET /waitlist (WaitlistController.list)
-   */
-  async listWaitlistEntries(options = {}) {
-    this._requireReady("listWaitlistEntries");
-    const {
-      campaignKey,
-      status,
-      search,
-      page,
-      limit
-    } = options || {};
-    const queryParams = new URLSearchParams();
-    if (campaignKey != null) {
-      queryParams.append("campaignKey", String(campaignKey));
-    }
-    if (status != null) {
-      queryParams.append("status", String(status));
-    }
-    if (search != null) {
-      queryParams.append("search", String(search));
-    }
-    if (page != null) {
-      queryParams.append("page", String(page));
-    }
-    if (limit != null) {
-      queryParams.append("limit", String(limit));
-    }
-    const queryString = queryParams.toString();
-    const url = `/waitlist${queryString ? `?${queryString}` : ""}`;
-    try {
-      const response = await this._request(url, {
-        method: "GET",
-        methodName: "listWaitlistEntries"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to list waitlist entries: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Update a waitlist entry (admin).
-   *
-   * Mirrors: PATCH /waitlist/:id (WaitlistController.update)
-   */
-  async updateWaitlistEntry(id, update = {}) {
-    this._requireReady("updateWaitlistEntry");
-    if (!id) {
-      throw new Error("Waitlist entry ID is required");
-    }
-    if (!update || typeof update !== "object") {
-      throw new Error("Update payload is required");
-    }
-    try {
-      const response = await this._request(`/waitlist/${id}`, {
-        method: "PATCH",
-        body: JSON.stringify(update),
-        methodName: "updateWaitlistEntry"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update waitlist entry: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Send an invitation email for a waitlist entry (admin).
-   *
-   * Mirrors: POST /waitlist/:id/invite (WaitlistController.invite)
-   */
-  async inviteWaitlistEntry(id) {
-    this._requireReady("inviteWaitlistEntry");
-    if (!id) {
-      throw new Error("Waitlist entry ID is required");
-    }
-    try {
-      const response = await this._request(`/waitlist/${id}/invite`, {
-        method: "POST",
-        methodName: "inviteWaitlistEntry"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to invite waitlist entry: ${error.message}`, { cause: error });
-    }
-  }
-}
-export {
-  WaitlistService
-};

package/dist/node/state/RootStateManager.js

@@ -1,36 +0,0 @@
-import * as utils from "@domql/utils";
-import { rootBus } from "./rootEventBus.js";
-const { isFunction } = utils.default || utils;
-class RootStateManager {
-  constructor(rootState) {
-    this._rootState = rootState;
-  }
-  /**
-   * Apply change tuples to the root state using the built-in setPathCollection
-   * of Symbo.ls APP state tree.
-   *
-   * @param {Array} changes – eg. ['update', ['foo'], 'bar']
-   * @param {Object} opts   – forwarded to setPathCollection
-   */
-  async applyChanges(changes = [], opts = {}) {
-    if (!this._rootState || !isFunction(this._rootState.setPathCollection)) {
-      return;
-    }
-    const result = await this._rootState.setPathCollection(changes, {
-      preventUpdate: true,
-      ...opts
-    });
-    return result;
-  }
-  setVersion(v) {
-    if (this._rootState) {
-      this._rootState.version = v;
-    }
-  }
-  get root() {
-    return this._rootState;
-  }
-}
-export {
-  RootStateManager
-};

package/dist/node/state/rootEventBus.js

@@ -1,55 +0,0 @@
-const getGlobalBus = () => {
-  if (globalThis.__SMBLS_ROOT_BUS__) {
-    return globalThis.__SMBLS_ROOT_BUS__;
-  }
-  const events = {};
-  const lastPayloads = {};
-  const bus = {
-    on(event, handler) {
-      (events[event] ||= []).push(handler);
-      if (Object.hasOwn(lastPayloads, event)) {
-        try {
-          handler(lastPayloads[event]);
-        } catch (err) {
-          console.error("[rootBus] handler error for (replay)", event, err);
-        }
-      }
-    },
-    off(event, handler) {
-      const list = events[event];
-      if (!list) {
-        return;
-      }
-      const idx = list.indexOf(handler);
-      if (idx !== -1) {
-        list.splice(idx, 1);
-      }
-    },
-    emit(event, payload) {
-      lastPayloads[event] = payload;
-      const list = events[event];
-      if (!list || !list.length) {
-        return;
-      }
-      list.slice().forEach((fn) => {
-        try {
-          fn(payload);
-        } catch (err) {
-          console.error("[rootBus] handler error for", event, err);
-        }
-      });
-    }
-  };
-  Object.defineProperty(bus, "_listeners", {
-    value: events,
-    enumerable: false
-  });
-  globalThis.__SMBLS_ROOT_BUS__ = bus;
-  return bus;
-};
-const rootBus = getGlobalBus();
-var rootEventBus_default = rootBus;
-export {
-  rootEventBus_default as default,
-  rootBus
-};

package/dist/node/utils/CollabClient.js

@@ -1,194 +0,0 @@
-import { io } from "socket.io-client";
-import * as Y from "yjs";
-import { nanoid } from "nanoid";
-import environment from "../config/environment.js";
-import { diffJson, applyOpsToJson } from "./jsonDiff.js";
-class CollabClient {
-  /* public fields */
-  socket = null;
-  ydoc = null;
-  branch = "main";
-  live = false;
-  projectId = null;
-  jwt = null;
-  /* private state */
-  _buffer = [];
-  _flushTimer = null;
-  _clientId = nanoid();
-  _outboxStore = createMemoryOutbox();
-  // Dexie table fallback
-  _readyResolve;
-  ready = new Promise((res) => this._readyResolve = res);
-  constructor({ jwt, projectId, branch = "main", live = false }) {
-    Object.assign(this, { jwt, projectId, branch, live });
-    this.ydoc = new Y.Doc();
-    const hasIndexedDB = typeof globalThis.indexedDB !== "undefined";
-    if (typeof window === "undefined" || !hasIndexedDB) {
-      console.log("[CollabClient] IndexedDB not available \u2013 skipping offline persistence");
-    } else {
-      import("y-indexeddb").then(({ IndexeddbPersistence }) => {
-        new IndexeddbPersistence(`${projectId}:${branch}`, this.ydoc);
-      }).catch((err) => {
-        console.warn("[CollabClient] Failed to load IndexeddbPersistence:", err);
-      });
-    }
-    if (typeof window !== "undefined" && hasIndexedDB) {
-      createDexieOutbox(`${projectId}:${branch}`).then((outboxStore) => {
-        this._outboxStore = outboxStore;
-      }).catch((err) => {
-        console.warn("[CollabClient] Failed to load Dexie:", err);
-      });
-    }
-    this.socket = io(environment.socketUrl, {
-      path: "/collab-socket",
-      transports: ["websocket"],
-      auth: { token: jwt, projectId, branch, live },
-      reconnectionAttempts: Infinity,
-      reconnectionDelayMax: 4e3
-    });
-    this.socket.on("snapshot", this._onSnapshot).on("ops", this._onOps).on("commit", this._onCommit).on("liveMode", this._onLiveMode).on("connect", this._onConnect).on("error", this._onError);
-    this._prevJson = this.ydoc.getMap("root").toJSON();
-    this.ydoc.on("afterTransaction", (tr) => {
-      if (tr.origin === "remote") {
-        return;
-      }
-      const currentJson = this.ydoc.getMap("root").toJSON();
-      const ops = diffJson(this._prevJson, currentJson);
-      this._prevJson = currentJson;
-      if (!ops.length) {
-        return;
-      }
-      this._queueOps(ops);
-    });
-  }
-  /* ---------- public helpers ---------- */
-  toggleLive(flag) {
-    this.socket.emit("toggleLive", Boolean(flag));
-  }
-  sendCursor(data) {
-    this.socket.emit("cursor", data);
-  }
-  sendPresence(d) {
-    this.socket.emit("presence", d);
-  }
-  /* ---------- private handlers ---------- */
-  _onSnapshot = ({
-    data
-    /* Uint8Array */
-  }) => {
-    if (Array.isArray(data) ? data.length : data && data.byteLength) {
-      Y.applyUpdate(this.ydoc, Uint8Array.from(data));
-    } else {
-      console.warn("[collab] Received empty snapshot \u2013 skipping applyUpdate");
-    }
-    this._prevJson = this.ydoc.getMap("root").toJSON();
-    if (typeof this._readyResolve === "function") {
-      this._readyResolve();
-      this._readyResolve = null;
-    }
-  };
-  _onOps = ({ changes }) => {
-    applyOpsToJson(changes, this.ydoc);
-    this._prevJson = this.ydoc.getMap("root").toJSON();
-  };
-  _onCommit = async ({ version }) => {
-    await this._outboxStore.clear();
-    console.info("[collab] committed", version);
-  };
-  _onConnect = async () => {
-    if (typeof this._readyResolve === "function") {
-      this._readyResolve();
-      this._readyResolve = null;
-    }
-    const queued = await this._outboxStore.toArray();
-    if (queued.length) {
-      this.socket.emit("ops", {
-        changes: queued.flatMap((e) => e.ops),
-        ts: Date.now(),
-        clientId: this._clientId
-      });
-      await this._outboxStore.clear();
-    }
-  };
-  /* ---------- buffering & debounce ---------- */
-  _queueOps(ops) {
-    this._buffer.push(...ops);
-    this._outboxStore.put({ id: nanoid(), ops });
-    if (this.live && this.socket.connected) {
-      this._flushNow();
-    } else {
-      clearTimeout(this._flushTimer);
-      this._flushTimer = setTimeout(() => this._flushNow(), 40);
-    }
-  }
-  _flushNow() {
-    if (!this._buffer.length || !this.socket.connected) {
-      return;
-    }
-    this.socket.emit("ops", {
-      changes: this._buffer,
-      ts: Date.now(),
-      clientId: this._clientId
-    });
-    this._buffer.length = 0;
-  }
-  dispose() {
-    var _a;
-    clearTimeout(this._flushTimer);
-    this._flushTimer = null;
-    this._buffer.length = 0;
-    if ((_a = this._outboxStore) == null ? void 0 : _a.clear) {
-      try {
-        const result = this._outboxStore.clear();
-        if (result && typeof result.catch === "function") {
-          result.catch(() => {
-          });
-        }
-      } catch (error) {
-        console.warn("[CollabClient] Failed to clear outbox store during dispose:", error);
-      }
-    }
-    if (this.socket) {
-      this.socket.off("snapshot", this._onSnapshot);
-      this.socket.off("ops", this._onOps);
-      this.socket.off("commit", this._onCommit);
-      this.socket.off("liveMode", this._onLiveMode);
-      this.socket.off("connect", this._onConnect);
-      this.socket.off("error", this._onError);
-      this.socket.removeAllListeners();
-      this.socket.disconnect();
-      this.socket = null;
-    }
-    if (this.ydoc) {
-      this.ydoc.destroy();
-      this.ydoc = null;
-    }
-    if (typeof this._readyResolve === "function") {
-      this._readyResolve();
-      this._readyResolve = null;
-    }
-  }
-  _onLiveMode = (flag) => {
-    this.live = flag;
-  };
-  _onError = (e) => {
-    console.warn("[collab] socket error", e);
-  };
-}
-function createMemoryOutbox() {
-  const store = /* @__PURE__ */ new Map();
-  return {
-    put: (item) => store.set(item.id, item),
-    toArray: () => Array.from(store.values()),
-    clear: () => store.clear()
-  };
-}
-async function createDexieOutbox(name) {
-  const { default: Dexie } = await import("dexie");
-  const db = new Dexie(`collab-${name}`);
-  db.version(1).stores({ outbox: "id, ops" });
-  return db.table("outbox");
-}
-export {
-  CollabClient
-};