@symbo.ls/sdk 2.32.2 → 2.32.5

package/dist/esm/utils/ordering.js

@@ -0,0 +1,256 @@
+// src/utils/ordering.js
+function isObjectLike(val) {
+  return val && typeof val === "object" && !Array.isArray(val);
+}
+function normalizePath(path) {
+  if (Array.isArray(path)) {
+    return path;
+  }
+  if (typeof path === "string") {
+    return [path];
+  }
+  return [];
+}
+function getParentPathsFromTuples(tuples = []) {
+  const seen = /* @__PURE__ */ new Set();
+  const parents = [];
+  const META_KEYS = /* @__PURE__ */ new Set([
+    "style",
+    "class",
+    "text",
+    "html",
+    "content",
+    "data",
+    "attr",
+    "state",
+    "scope",
+    "define",
+    "on",
+    "extend",
+    "extends",
+    "childExtend",
+    "childExtends",
+    "children",
+    "component",
+    "context",
+    "tag",
+    "key",
+    "__order",
+    "if"
+  ]);
+  for (let i = 0; i < tuples.length; i++) {
+    const tuple = tuples[i];
+    if (!Array.isArray(tuple) || tuple.length < 2) {
+      continue;
+    }
+    const path = normalizePath(tuple[1]);
+    if (!path.length) {
+      continue;
+    }
+    if (path[0] === "schema") {
+      continue;
+    }
+    const immediateParent = path.slice(0, -1);
+    if (immediateParent.length) {
+      const key = JSON.stringify(immediateParent);
+      if (!seen.has(key)) {
+        seen.add(key);
+        parents.push(immediateParent);
+      }
+    }
+    const last = path[path.length - 1];
+    if (META_KEYS.has(last) && path.length >= 2) {
+      const containerParent = path.slice(0, -2);
+      if (containerParent.length) {
+        const key2 = JSON.stringify(containerParent);
+        if (!seen.has(key2)) {
+          seen.add(key2);
+          parents.push(containerParent);
+        }
+      }
+    }
+    for (let j = 0; j < path.length; j++) {
+      const seg = path[j];
+      if (!META_KEYS.has(seg)) {
+        continue;
+      }
+      const containerParent2 = path.slice(0, j);
+      if (!containerParent2.length) {
+        continue;
+      }
+      const key3 = JSON.stringify(containerParent2);
+      if (!seen.has(key3)) {
+        seen.add(key3);
+        parents.push(containerParent2);
+      }
+    }
+  }
+  return parents;
+}
+function computeOrdersFromState(root, parentPaths = []) {
+  if (!root || typeof root.getByPath !== "function") {
+    return [];
+  }
+  const orders = [];
+  const EXCLUDE_KEYS = /* @__PURE__ */ new Set(["__order"]);
+  for (let i = 0; i < parentPaths.length; i++) {
+    const parentPath = parentPaths[i];
+    const obj = (() => {
+      try {
+        return root.getByPath(parentPath);
+      } catch {
+        return null;
+      }
+    })();
+    if (!isObjectLike(obj)) {
+      continue;
+    }
+    const keys = Object.keys(obj).filter((k) => !EXCLUDE_KEYS.has(k));
+    orders.push({ path: parentPath, keys });
+  }
+  return orders;
+}
+function normaliseSchemaCode(code) {
+  if (typeof code !== "string" || !code.length) {
+    return "";
+  }
+  return code.replaceAll("/////n", "\n").replaceAll("/////tilde", "`");
+}
+function parseExportedObject(code) {
+  const src = normaliseSchemaCode(code);
+  if (!src) {
+    return null;
+  }
+  const body = src.replace(/^\s*export\s+default\s*/u, "return ");
+  try {
+    return new Function(body)();
+  } catch {
+    return null;
+  }
+}
+function extractTopLevelKeysFromCode(code) {
+  const obj = parseExportedObject(code);
+  if (!obj || typeof obj !== "object") {
+    return [];
+  }
+  return Object.keys(obj);
+}
+function computeOrdersForTuples(root, tuples = []) {
+  const pendingChildrenByContainer = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i];
+    if (!Array.isArray(t)) {
+      continue;
+    }
+    const [action, path] = t;
+    const p = normalizePath(path);
+    if (!Array.isArray(p) || p.length < 3) {
+      continue;
+    }
+    if (p[0] === "schema") {
+      continue;
+    }
+    const [typeName, containerKey, childKey] = p;
+    const containerPath = [typeName, containerKey];
+    const key = JSON.stringify(containerPath);
+    if (!pendingChildrenByContainer.has(key)) {
+      pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
+    }
+    if (action === "update" || action === "set") {
+      pendingChildrenByContainer.get(key).add(childKey);
+    }
+  }
+  const preferredOrderMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i];
+    if (!Array.isArray(t)) {
+      continue;
+    }
+    const [action, path, value] = t;
+    const p = normalizePath(path);
+    if (action !== "update" || !Array.isArray(p) || p.length < 3) {
+      continue;
+    }
+    if (p[0] !== "schema") {
+      continue;
+    }
+    const [, type, key] = p;
+    const containerPath = [type, key];
+    const uses = value && Array.isArray(value.uses) ? value.uses : null;
+    const code = value && value.code;
+    const obj = (() => {
+      try {
+        return root && typeof root.getByPath === "function" ? root.getByPath(containerPath) : null;
+      } catch {
+        return null;
+      }
+    })();
+    if (!obj) {
+      continue;
+    }
+    const present = new Set(Object.keys(obj));
+    const EXCLUDE_KEYS = /* @__PURE__ */ new Set(["__order"]);
+    const codeKeys = extractTopLevelKeysFromCode(code);
+    let resolved = [];
+    const pendingKey = JSON.stringify(containerPath);
+    const pendingChildren = pendingChildrenByContainer.get(pendingKey) || /* @__PURE__ */ new Set();
+    const eligible = /* @__PURE__ */ new Set([...present, ...pendingChildren]);
+    if (Array.isArray(codeKeys) && codeKeys.length) {
+      resolved = codeKeys.filter((k) => eligible.has(k) && !EXCLUDE_KEYS.has(k));
+    }
+    if (Array.isArray(uses) && uses.length) {
+      for (let u = 0; u < uses.length; u++) {
+        const keyName = uses[u];
+        if (eligible.has(keyName) && !EXCLUDE_KEYS.has(keyName) && !resolved.includes(keyName)) {
+          resolved.push(keyName);
+        }
+      }
+    }
+    if (pendingChildren.size) {
+      for (const child of pendingChildren) {
+        if (!EXCLUDE_KEYS.has(child) && !resolved.includes(child)) {
+          resolved.push(child);
+        }
+      }
+    }
+    if (resolved.length) {
+      preferredOrderMap.set(JSON.stringify(containerPath), { path: containerPath, keys: resolved });
+    }
+  }
+  const parents = getParentPathsFromTuples(tuples);
+  const orders = [];
+  const seen = /* @__PURE__ */ new Set();
+  preferredOrderMap.forEach((v) => {
+    const k = JSON.stringify(v.path);
+    if (!seen.has(k)) {
+      seen.add(k);
+      orders.push(v);
+    }
+  });
+  const fallbackOrders = computeOrdersFromState(root, parents);
+  for (let i = 0; i < fallbackOrders.length; i++) {
+    const v = fallbackOrders[i];
+    const k = JSON.stringify(v.path);
+    if (seen.has(k)) {
+      continue;
+    }
+    const pending = pendingChildrenByContainer.get(k);
+    if (pending && pending.size) {
+      const existing = new Set(v.keys);
+      for (const child of pending) {
+        if (existing.has(child)) {
+          continue;
+        }
+        v.keys.push(child);
+      }
+    }
+    seen.add(k);
+    orders.push(v);
+  }
+  return orders;
+}
+export {
+  computeOrdersForTuples,
+  computeOrdersFromState,
+  getParentPathsFromTuples
+};

package/dist/esm/utils/services.js

@@ -224,7 +224,20 @@ var SERVICE_METHODS = {
   promoteToAdmin: "admin",
   demoteFromAdmin: "admin",
   // Utility methods
-  getHealthStatus: "core"
+  getHealthStatus: "core",
+  // Screenshot methods
+  createScreenshotProject: "screenshot",
+  getProjectScreenshots: "screenshot",
+  reprocessProjectScreenshots: "screenshot",
+  recreateProjectScreenshots: "screenshot",
+  deleteProjectScreenshots: "screenshot",
+  getThumbnailCandidate: "screenshot",
+  updateProjectThumbnail: "screenshot",
+  getPageScreenshot: "screenshot",
+  getComponentScreenshot: "screenshot",
+  getScreenshotByKey: "screenshot",
+  getQueueStatistics: "screenshot",
+  refreshThumbnail: "screenshot"
 };
 export {
   SERVICE_METHODS

package/dist/node/config/environment.js

@@ -23,18 +23,28 @@ const CONFIG = {
     // For based api
     basedOrg: "symbols",
     // For based api
-    githubClientId: "Ov23liHxyWFBxS8f1gnF",
+    githubClientId: "Ov23liAFrsR0StbAO6PO",
     // For github api
     // Environment-specific feature toggles (override common)
     features: {
       betaFeatures: true
       // Enable beta features in local dev
-    }
+    },
+    typesenseCollectionName: "docs",
+    typesenseApiKey: "vZya3L2zpq8L6iI5WWMUZJZABvT63VDb",
+    typesenseHost: "localhost",
+    typesensePort: "8108",
+    typesenseProtocol: "http"
   },
   development: {
     socketUrl: "https://dev.api.symbols.app",
     apiUrl: "https://dev.api.symbols.app",
-    githubClientId: "Ov23liHxyWFBxS8f1gnF"
+    githubClientId: "Ov23liHxyWFBxS8f1gnF",
+    typesenseCollectionName: "docs",
+    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
+    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
+    typesensePort: "443",
+    typesenseProtocol: "https"
   },
   testing: {
     socketUrl: "https://test.api.symbols.app",
@@ -42,12 +52,22 @@ const CONFIG = {
     basedEnv: "testing",
     basedProject: "platform-v2-sm",
     basedOrg: "symbols",
-    githubClientId: "Ov23liHxyWFBxS8f1gnF"
+    githubClientId: "Ov23liHxyWFBxS8f1gnF",
+    typesenseCollectionName: "docs",
+    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
+    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
+    typesensePort: "443",
+    typesenseProtocol: "https"
   },
   upcoming: {
     socketUrl: "https://upcoming.api.symbols.app",
     apiUrl: "https://upcoming.api.symbols.app",
-    githubClientId: "Ov23liWF7NvdZ056RV5J"
+    githubClientId: "Ov23liWF7NvdZ056RV5J",
+    typesenseCollectionName: "docs",
+    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
+    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
+    typesensePort: "443",
+    typesenseProtocol: "https"
   },
   staging: {
     socketUrl: "https://staging.api.symbols.app",
@@ -55,7 +75,12 @@ const CONFIG = {
     basedEnv: "staging",
     basedProject: "platform-v2-sm",
     basedOrg: "symbols",
-    githubClientId: "Ov23ligwZDQVD0VfuWNa"
+    githubClientId: "Ov23ligwZDQVD0VfuWNa",
+    typesenseCollectionName: "docs",
+    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
+    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
+    typesensePort: "443",
+    typesenseProtocol: "https"
   },
   production: {
     socketUrl: "https://api.symbols.app",
@@ -63,7 +88,12 @@ const CONFIG = {
     basedEnv: "production",
     basedProject: "platform-v2-sm",
     basedOrg: "symbols",
-    githubClientId: "Ov23liFAlOEIXtX3dBtR"
+    githubClientId: "Ov23liFAlOEIXtX3dBtR",
+    typesenseCollectionName: "docs",
+    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
+    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
+    typesensePort: "443",
+    typesenseProtocol: "https"
   }
 };
 const getEnvironment = () => {
@@ -86,6 +116,11 @@ const getConfig = () => {
       basedProject: process.env.SYMBOLS_APP_BASED_PROJECT || envConfig.basedProject,
       basedOrg: process.env.SYMBOLS_APP_BASED_ORG || envConfig.basedOrg,
       githubClientId: process.env.SYMBOLS_APP_GITHUB_CLIENT_ID || envConfig.githubClientId,
+      typesenseCollectionName: process.env.TYPESENSE_COLLECTION_NAME || envConfig.typesenseCollectionName,
+      typesenseApiKey: process.env.TYPESENSE_API_KEY || envConfig.typesenseApiKey,
+      typesenseHost: process.env.TYPESENSE_HOST || envConfig.typesenseHost,
+      typesensePort: process.env.TYPESENSE_PORT || envConfig.typesensePort,
+      typesenseProtocol: process.env.TYPESENSE_PROTOCOL || envConfig.typesenseProtocol,
       isDevelopment: isDevelopment(env),
       isTesting: env === "testing",
       isStaging: env === "staging",
@@ -105,7 +140,7 @@ const getConfig = () => {
       );
     }
     if (finalConfig.isDevelopment) {
-      console.log(
+      console.warn(
         "environment in SDK:",
         env || process.env.NODE_ENV || process.env.NODE_ENV
       );

package/dist/node/index.js

@@ -10,15 +10,18 @@ import {
   createBranchService,
   createPullRequestService,
   createAdminService,
-  createSubscriptionService
+  createSubscriptionService,
+  createScreenshotService
 } from "./services/index.js";
 import { SERVICE_METHODS } from "./utils/services.js";
 import environment from "./config/environment.js";
+import { rootBus } from "./state/rootEventBus.js";
 class SDK {
   constructor(options = {}) {
     this._services = /* @__PURE__ */ new Map();
     this._context = {};
     this._options = this._validateOptions(options);
+    this.rootBus = rootBus;
     this._createServiceProxies();
   }
   // Initialize SDK with context
@@ -112,6 +115,13 @@ class SDK {
           context: this._context,
           options: this._options
         })
+      ),
+      this._initService(
+        "screenshot",
+        createScreenshotService({
+          context: this._context,
+          options: this._options
+        })
       )
     ]);
     return this;
@@ -149,9 +159,10 @@ class SDK {
   }
   // Update context
   updateContext(newContext) {
+    const { authToken, ...sanitized } = newContext || {};
     this._context = {
       ...this._context,
-      ...newContext
+      ...sanitized
     };
     for (const service of this._services.values()) {
       service.updateContext(this._context);
@@ -160,9 +171,7 @@ class SDK {
   // Check if SDK is ready
   isReady() {
     const sdkServices = Array.from(this._services.values());
-    return sdkServices.length > 0 && sdkServices.every(
-      (service) => service.isReady()
-    );
+    return sdkServices.length > 0 && sdkServices.every((service) => service.isReady());
   }
   // Get SDK status
   getStatus() {

package/dist/node/services/AdminService.js

@@ -51,7 +51,7 @@ class AdminService extends BaseService {
       }
       throw new Error(response.message);
     } catch (error) {
-      throw new Error(`Failed to get admin users: ${error.message}`);
+      throw new Error(`Failed to get admin users: ${error.message}`, { cause: error });
     }
   }
   /**
@@ -82,7 +82,7 @@ class AdminService extends BaseService {
       }
       throw new Error(response.message);
     } catch (error) {
-      throw new Error(`Failed to assign projects to user: ${error.message}`);
+      throw new Error(`Failed to assign projects to user: ${error.message}`, { cause: error });
     }
   }
   /**
@@ -111,7 +111,7 @@ class AdminService extends BaseService {
       if ((_a = error.message) == null ? void 0 : _a.includes("Duplicate")) {
         throw new Error("Username already exists");
       }
-      throw new Error(`Failed to update user: ${error.message}`);
+      throw new Error(`Failed to update user: ${error.message}`, { cause: error });
     }
   }
   // ==================== ADMIN HELPER METHODS ====================
@@ -241,7 +241,7 @@ class AdminService extends BaseService {
       });
       return stats;
     } catch (error) {
-      throw new Error(`Failed to get user stats: ${error.message}`);
+      throw new Error(`Failed to get user stats: ${error.message}`, { cause: error });
     }
   }
   /**