@symbo.ls/sdk 2.34.35 → 3.1.2

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
-};

package/dist/node/utils/changePreprocessor.js

@@ -1,180 +0,0 @@
-import { diffJson } from "./jsonDiff.js";
-import { computeOrdersForTuples } from "./ordering.js";
-function isPlainObject(val) {
-  return val && typeof val === "object" && !Array.isArray(val);
-}
-function getByPathSafe(root, path) {
-  if (!root || typeof root.getByPath !== "function") {
-    return null;
-  }
-  try {
-    return root.getByPath(path);
-  } catch {
-    return null;
-  }
-}
-function resolveNextValueFromTuples(tuples, path) {
-  if (!Array.isArray(tuples) || !Array.isArray(path)) {
-    return null;
-  }
-  for (let i = tuples.length - 1; i >= 0; i--) {
-    const t = tuples[i];
-    if (!Array.isArray(t) || t.length < 3) {
-      continue;
-    }
-    const [action, tuplePath, tupleValue] = t;
-    if (action !== "update" && action !== "set" || !Array.isArray(tuplePath)) {
-      continue;
-    }
-    if (tuplePath.length > path.length) {
-      continue;
-    }
-    let isPrefix = true;
-    for (let j = 0; j < tuplePath.length; j++) {
-      if (tuplePath[j] !== path[j]) {
-        isPrefix = false;
-        break;
-      }
-    }
-    if (!isPrefix) {
-      continue;
-    }
-    if (tuplePath.length === path.length) {
-      return tupleValue;
-    }
-    let current = tupleValue;
-    for (let j = tuplePath.length; j < path.length; j++) {
-      if (current == null) {
-        return null;
-      }
-      current = current[path[j]];
-    }
-    if (current !== null) {
-      return current;
-    }
-  }
-  return null;
-}
-function preprocessChanges(root, tuples = [], options = {}) {
-  const expandTuple = (t) => {
-    const [action, path, value] = t || [];
-    const isSchemaPath = Array.isArray(path) && path[0] === "schema";
-    const isFilesPath = Array.isArray(path) && path[0] === "files";
-    if (action === "delete") {
-      return [t];
-    }
-    const canConsiderExpansion = action === "update" && Array.isArray(path) && (path.length === 1 || path.length === 2 || isSchemaPath && path.length === 3) && isPlainObject(value);
-    if (!canConsiderExpansion || isFilesPath || value && value.type === "files") {
-      return [t];
-    }
-    const prevRaw = getByPathSafe(root, path);
-    const isCreatePath = Array.isArray(path) && action === "update" && // e.g. ['update', ['components', 'NewKey'], {...}]
-    (!isSchemaPath && path.length === 2 || // e.g. ['update', ['schema', 'components', 'NewKey'], {...}]
-    isSchemaPath && path.length === 3) && (prevRaw === null || typeof prevRaw === "undefined");
-    if (isCreatePath) {
-      return [t];
-    }
-    const prev = prevRaw || {};
-    const next = value || {};
-    if (!isPlainObject(prev) || !isPlainObject(next)) {
-      return [t];
-    }
-    const ops = diffJson(prev, next, []);
-    if (!ops.length) {
-      return [t];
-    }
-    const out = [];
-    for (let i = 0; i < ops.length; i++) {
-      const op = ops[i];
-      const fullPath = [...path, ...op.path];
-      const last = fullPath[fullPath.length - 1];
-      if (op.action === "set") {
-        out.push(["update", fullPath, op.value]);
-      } else if (op.action === "del") {
-        if (last !== "__order") {
-          out.push(["delete", fullPath]);
-        }
-      }
-    }
-    return out;
-  };
-  const minimizeTuples = (input) => {
-    const out = [];
-    const seen2 = /* @__PURE__ */ new Set();
-    for (let i = 0; i < input.length; i++) {
-      const expanded = expandTuple(input[i]);
-      for (let k = 0; k < expanded.length; k++) {
-        const tuple = expanded[k];
-        const isDelete = Array.isArray(tuple) && tuple[0] === "delete";
-        const isOrderKey = isDelete && Array.isArray(tuple[1]) && tuple[1][tuple[1].length - 1] === "__order";
-        if (!isOrderKey) {
-          const key = JSON.stringify(tuple);
-          if (!seen2.has(key)) {
-            seen2.add(key);
-            out.push(tuple);
-          }
-        }
-      }
-    }
-    return out;
-  };
-  const granularChanges = (() => {
-    try {
-      const res = minimizeTuples(tuples);
-      if (options.append && options.append.length) {
-        res.push(...options.append);
-      }
-      return res;
-    } catch {
-      return Array.isArray(tuples) ? tuples.slice() : [];
-    }
-  })();
-  const hydratedGranularChanges = granularChanges.map((t) => {
-    if (!Array.isArray(t) || t.length < 3) {
-      return t;
-    }
-    const [action, path] = t;
-    if (action !== "update" && action !== "set" || !Array.isArray(path)) {
-      return t;
-    }
-    const nextValue = resolveNextValueFromTuples(tuples, path);
-    if (nextValue === null) {
-      return t;
-    }
-    return [action, path, nextValue];
-  });
-  const baseOrders = computeOrdersForTuples(root, hydratedGranularChanges);
-  const preferOrdersMap = /* @__PURE__ */ new Map();
-  for (let i = 0; i < tuples.length; i++) {
-    const t = tuples[i];
-    if (!Array.isArray(t) || t.length < 3) {
-      continue;
-    }
-    const [action, path, value] = t;
-    const isFilesPath = Array.isArray(path) && path[0] === "files";
-    if (action !== "update" || !Array.isArray(path) || path.length !== 1 && path.length !== 2 || !isPlainObject(value) || isFilesPath || value && value.type === "files") {
-      continue;
-    }
-    const keys = Object.keys(value).filter((k) => k !== "__order");
-    const key = JSON.stringify(path);
-    preferOrdersMap.set(key, { path, keys });
-  }
-  const mergedOrders = [];
-  const seen = /* @__PURE__ */ new Set();
-  preferOrdersMap.forEach((v, k) => {
-    seen.add(k);
-    mergedOrders.push(v);
-  });
-  for (let i = 0; i < baseOrders.length; i++) {
-    const v = baseOrders[i];
-    const k = JSON.stringify(v.path);
-    if (!seen.has(k)) {
-      seen.add(k);
-      mergedOrders.push(v);
-    }
-  }
-  return { granularChanges: hydratedGranularChanges, orders: mergedOrders };
-}
-export {
-  preprocessChanges
-};

package/dist/node/utils/jsonDiff.js

@@ -1,116 +0,0 @@
-function isPlainObject(o) {
-  return o && typeof o === "object" && !Array.isArray(o);
-}
-function deepEqual(a, b) {
-  if (Object.is(a, b)) {
-    return true;
-  }
-  if (typeof a === "function" && typeof b === "function") {
-    try {
-      return a.toString() === b.toString();
-    } catch {
-      return false;
-    }
-  }
-  if (typeof a === "function" || typeof b === "function") {
-    return false;
-  }
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime();
-  }
-  if (a instanceof RegExp && b instanceof RegExp) {
-    return String(a) === String(b);
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (a && b && typeof a === "object" && typeof b === "object") {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length) {
-      return false;
-    }
-    for (let i = 0; i < aKeys.length; i++) {
-      const key = aKeys[i];
-      if (!Object.hasOwn(b, key)) {
-        return false;
-      }
-      if (!deepEqual(a[key], b[key])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-import * as Y from "yjs";
-function getRootMap(ydoc) {
-  return ydoc.getMap("root");
-}
-function diffJson(prev, next, prefix = []) {
-  const ops = [];
-  const _prefix = Array.isArray(prefix) ? prefix : [];
-  for (const key in prev) {
-    if (Object.hasOwn(prev, key) && !(key in next)) {
-      ops.push({ action: "del", path: [..._prefix, key] });
-    }
-  }
-  for (const key in next) {
-    if (Object.hasOwn(next, key)) {
-      const pVal = prev == null ? void 0 : prev[key];
-      const nVal = next[key];
-      if (isPlainObject(pVal) && isPlainObject(nVal)) {
-        ops.push(...diffJson(pVal, nVal, [..._prefix, key]));
-      } else if (!deepEqual(pVal, nVal)) {
-        ops.push({ action: "set", path: [..._prefix, key], value: nVal });
-      }
-    }
-  }
-  return ops;
-}
-function applyOpsToJson(ops, ydoc) {
-  if (!ydoc || !Array.isArray(ops) || !ops.length) {
-    return;
-  }
-  ydoc.transact(() => {
-    const root = getRootMap(ydoc);
-    ops.forEach((op) => {
-      const { action, path = [], value } = op || {};
-      if (!path.length) {
-        return;
-      }
-      let target = root;
-      for (let i = 0; i < path.length - 1; i++) {
-        const key = path[i];
-        let next = target.get(key);
-        if (!(next instanceof Y.Map)) {
-          const fresh = new Y.Map();
-          if (isPlainObject(next)) {
-            Object.entries(next).forEach(([k, v]) => fresh.set(k, v));
-          }
-          target.set(key, fresh);
-          next = fresh;
-        }
-        target = next;
-      }
-      const last = path[path.length - 1];
-      if (action === "set") {
-        target.set(last, value);
-      } else if (action === "del") {
-        target.delete(last);
-      }
-    });
-  }, "remote");
-}
-export {
-  applyOpsToJson,
-  diffJson
-};