@symbo.ls/sdk 2.32.2 → 2.32.4

package/src/services/SubscriptionService.js

@@ -39,7 +39,7 @@ export class SubscriptionService extends BaseService {
       }
       throw new Error(response.message)
     } catch (error) {
-      throw new Error(`Failed to create subscription: ${error.message}`)
+      throw new Error(`Failed to create subscription: ${error.message}`, { cause: error })
     }
   }
 
@@ -62,7 +62,7 @@ export class SubscriptionService extends BaseService {
       }
       throw new Error(response.message)
     } catch (error) {
-      throw new Error(`Failed to get project subscription status: ${error.message}`)
+      throw new Error(`Failed to get project subscription status: ${error.message}`, { cause: error })
     }
   }
 
@@ -85,7 +85,7 @@ export class SubscriptionService extends BaseService {
       }
       throw new Error(response.message)
     } catch (error) {
-      throw new Error(`Failed to get subscription usage: ${error.message}`)
+      throw new Error(`Failed to get subscription usage: ${error.message}`, { cause: error })
     }
   }
 
@@ -108,7 +108,7 @@ export class SubscriptionService extends BaseService {
       }
       throw new Error(response.message)
     } catch (error) {
-      throw new Error(`Failed to cancel subscription: ${error.message}`)
+      throw new Error(`Failed to cancel subscription: ${error.message}`, { cause: error })
     }
   }
 
@@ -142,7 +142,7 @@ export class SubscriptionService extends BaseService {
       }
       throw new Error(response.message)
     } catch (error) {
-      throw new Error(`Failed to list invoices: ${error.message}`)
+      throw new Error(`Failed to list invoices: ${error.message}`, { cause: error })
     }
   }
 
@@ -171,7 +171,7 @@ export class SubscriptionService extends BaseService {
       }
       throw new Error(response.message)
     } catch (error) {
-      throw new Error(`Failed to get portal URL: ${error.message}`)
+      throw new Error(`Failed to get portal URL: ${error.message}`, { cause: error })
     }
   }
 
@@ -216,7 +216,7 @@ export class SubscriptionService extends BaseService {
       const status = await this.getProjectStatus(projectId)
       return status.hasSubscription === true
     } catch (error) {
-      throw new Error(`Failed to check subscription status: ${error.message}`)
+      throw new Error(`Failed to check subscription status: ${error.message}`, { cause: error })
     }
   }
 
@@ -231,7 +231,7 @@ export class SubscriptionService extends BaseService {
       }
       return status.subscription
     } catch (error) {
-      throw new Error(`Failed to get project subscription: ${error.message}`)
+      throw new Error(`Failed to get project subscription: ${error.message}`, { cause: error })
     }
   }
 
@@ -246,7 +246,7 @@ export class SubscriptionService extends BaseService {
       }
       return status.usage
     } catch (error) {
-      throw new Error(`Failed to get project usage: ${error.message}`)
+      throw new Error(`Failed to get project usage: ${error.message}`, { cause: error })
     }
   }
 
@@ -261,7 +261,7 @@ export class SubscriptionService extends BaseService {
         pagination: result.pagination || {}
       }
     } catch (error) {
-      throw new Error(`Failed to get invoices with pagination: ${error.message}`)
+      throw new Error(`Failed to get invoices with pagination: ${error.message}`, { cause: error })
     }
   }
 
@@ -275,7 +275,7 @@ export class SubscriptionService extends BaseService {
       // You might need to adjust based on your backend response
       return usage && usage.subscription && usage.subscription.status === 'active'
     } catch (error) {
-      throw new Error(`Failed to check subscription status: ${error.message}`)
+      throw new Error(`Failed to check subscription status: ${error.message}`, { cause: error })
     }
   }
 
@@ -287,7 +287,7 @@ export class SubscriptionService extends BaseService {
       const usage = await this.getUsage(subscriptionId)
       return usage.limits || {}
     } catch (error) {
-      throw new Error(`Failed to get subscription limits: ${error.message}`)
+      throw new Error(`Failed to get subscription limits: ${error.message}`, { cause: error })
     }
   }
 
@@ -327,7 +327,7 @@ export class SubscriptionService extends BaseService {
       }
       throw new Error(response.message)
     } catch (error) {
-      throw new Error(`Failed to change subscription: ${error.message}`)
+      throw new Error(`Failed to change subscription: ${error.message}`, { cause: error })
     }
   }
 
@@ -359,7 +359,7 @@ export class SubscriptionService extends BaseService {
       }
       throw new Error(response.message)
     } catch (error) {
-      throw new Error(`Failed to downgrade subscription: ${error.message}`)
+      throw new Error(`Failed to downgrade subscription: ${error.message}`, { cause: error })
     }
   }
 

package/src/services/index.js

@@ -11,6 +11,7 @@ import { DnsService } from './DnsService.js'
 import { BranchService } from './BranchService.js'
 import { PullRequestService } from './PullRequestService.js'
 import { AdminService } from './AdminService.js'
+import { ScreenshotService } from './ScreenshotService.js'
 
 const createService = (ServiceClass, config) => new ServiceClass(config)
 
@@ -49,6 +50,9 @@ export const createPullRequestService = config =>
 export const createAdminService = config =>
   createService(AdminService, config)
 
+export const createScreenshotService = config =>
+  createService(ScreenshotService, config)
+
 export {
   AuthService,
   CoreService,
@@ -61,5 +65,6 @@ export {
   DnsService,
   BranchService,
   PullRequestService,
-  AdminService
+  AdminService,
+  ScreenshotService
 }

package/src/utils/TokenManager.js

@@ -6,7 +6,7 @@ export class TokenManager {
   constructor (options = {}) {
     this.config = {
       storagePrefix: 'symbols_',
-      storageType: (typeof window === 'undefined' || process.env.NODE_ENV === 'test') ? 'memory' : 'localStorage', // 'localStorage' | 'sessionStorage' | 'memory'
+      storageType: (typeof window === 'undefined' || process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'testing') ? 'memory' : 'localStorage', // 'localStorage' | 'sessionStorage' | 'memory'
       refreshBuffer: 60 * 1000, // Refresh 1 minute before expiry
       maxRetries: 3,
       apiUrl: options.apiUrl || '/api',
@@ -52,16 +52,30 @@ export class TokenManager {
       return this._memoryStorage
     }
 
-    const hasLocalStorage = typeof window.localStorage !== 'undefined'
-    const hasSessionStorage = typeof window.sessionStorage !== 'undefined'
+    // Guard against environments where accessing storage throws (e.g., opaque origins)
+    const safeGetStorage = (provider) => {
+      try {
+        const storage = provider()
+        // Try a simple set/remove cycle to ensure it is usable
+        const testKey = `${this.config.storagePrefix}__tm_test__`
+        storage.setItem(testKey, '1')
+        storage.removeItem(testKey)
+        return storage
+      } catch {
+        return null
+      }
+    }
+
+    const localStorageInstance = safeGetStorage(() => window.localStorage)
+    const sessionStorageInstance = safeGetStorage(() => window.sessionStorage)
 
     switch (this.config.storageType) {
       case 'sessionStorage':
-        return hasSessionStorage ? window.sessionStorage : this._memoryStorage
+        return sessionStorageInstance || this._memoryStorage
       case 'memory':
         return this._memoryStorage
       default:
-        return hasLocalStorage ? window.localStorage : this._memoryStorage
+        return localStorageInstance || this._memoryStorage
     }
   }
 

package/src/utils/changePreprocessor.js

@@ -0,0 +1,139 @@
+
+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 }
+}
+
+/**
+ * Preprocess broad project changes into granular changes and ordering metadata.
+ * - Expands top-level object updates (e.g. ['update', ['components'], {...}])
+ *   into fine-grained ['update'|'delete', [...], value] tuples using a diff
+ *   against the current state when available
+ * - Preserves schema paths as-is
+ * - Filters out explicit deletes targeting __order keys
+ * - Appends any extra tuples from options.append
+ * - Computes stable orders for impacted parent containers
+ */
+export function preprocessChanges (root, tuples = [], options = {}) {
+  const expandTuple = (t) => {
+    const [action, path, value] = t || []
+    const isSchemaPath = Array.isArray(path) && path[0] === 'schema'
+    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) { return [t] }
+
+    const prev = getByPathSafe(root, path) || {}
+    const next = value || {}
+    if (!isPlainObject(prev) || !isPlainObject(next)) { return [t] }
+
+    const ops = diffJson(prev, next, [])
+    // If diff yields no nested ops, preserve the original tuple as a fallback
+    // (e.g. when value equality or missing previous state prevents expansion).
+    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]) }
+      }
+    }
+    // Prefer granular leaf operations only to minimize payload duplication.
+    return out
+  }
+
+  const minimizeTuples = (input) => {
+    const out = []
+    const seen = 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 (!seen.has(key)) { seen.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 {
+      // Fallback to original tuples if anything goes wrong
+      return Array.isArray(tuples) ? tuples.slice() : []
+    }
+  })()
+
+  // Base orders from granular changes/state
+  const baseOrders = computeOrdersForTuples(root, granularChanges)
+
+  // Prefer explicit order for containers updated via ['update', [type], value] or ['update', [type, key], value]
+  const preferOrdersMap = new Map()
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i]
+    if (!Array.isArray(t) || t.length < 3) {
+      // eslint-disable-next-line no-continue
+      continue
+    }
+    const [action, path, value] = t
+    if (
+      action !== 'update' ||
+      !Array.isArray(path) ||
+      (path.length !== 1 && path.length !== 2) ||
+      !isPlainObject(value)
+    ) {
+      // eslint-disable-next-line no-continue
+      continue
+    }
+    const keys = Object.keys(value).filter(k => k !== '__order')
+    const key = JSON.stringify(path)
+    preferOrdersMap.set(key, { path, keys })
+  }
+
+  const mergedOrders = []
+  const seen = new Set()
+  // Add preferred top-level orders first
+  preferOrdersMap.forEach((v, k) => { seen.add(k); mergedOrders.push(v) })
+  // Add remaining base orders
+  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, orders: mergedOrders }
+}
+
+

package/src/utils/jsonDiff.js

@@ -7,12 +7,47 @@ function isPlainObject (o) {
 }
 
 function deepEqual (a, b) {
-  try {
-    return JSON.stringify(a) === JSON.stringify(b)
-  } catch (err) {
-    console.warn('deepEqual error', err)
-    return false
+  // Fast path for strict equality (handles primitives and same refs)
+  if (Object.is(a, b)) { return true }
+
+  // Functions: compare source text to detect semantic change
+  if (typeof a === 'function' && typeof b === 'function') {
+    try { return a.toString() === b.toString() } catch { return false }
   }
+
+  // One is function and the other is not
+  if (typeof a === 'function' || typeof b === 'function') { return false }
+
+  // Dates
+  if (a instanceof Date && b instanceof Date) { return a.getTime() === b.getTime() }
+
+  // RegExp
+  if (a instanceof RegExp && b instanceof RegExp) { return String(a) === String(b) }
+
+  // Arrays
+  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
+  }
+
+  // Objects (including plain objects when we get here)
+  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
+  }
+
+  // Fallback for different types
+  return false
 }
 
 import * as Y from 'yjs'

package/src/utils/ordering.js

@@ -0,0 +1,244 @@
+/* eslint-disable no-continue */
+// Utilities to compute stable key ordering for parent objects impacted by changes
+
+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 []
+}
+
+export function getParentPathsFromTuples (tuples = []) {
+  const seen = new Set()
+  const parents = []
+  const META_KEYS = 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}
+    // Ignore schema containers entirely for parent order targets
+    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)
+      }
+    }
+
+    // If the tuple points to a meta key (e.g. props/text), also include the container parent
+    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)
+        }
+      }
+    }
+    // Additionally include container parents for any meta segment in the path
+    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
+}
+
+/**
+ * Compute ordered key arrays for each parent path using the provided root state's getByPath.
+ *
+ * @param {Object} root - Root state with a getByPath(pathArray) method
+ * @param {Array<Array<string>>} parentPaths - Array of parent paths to inspect
+ * @returns {Array<{ path: string[], keys: string[] }>} orders
+ */
+export function computeOrdersFromState (root, parentPaths = []) {
+  if (!root || typeof root.getByPath !== 'function') {return []}
+
+  const orders = []
+  const EXCLUDE_KEYS = 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
+}
+
+/**
+ * Convenience helper to derive orders directly from tuples and a root state.
+ */
+// --- Schema `code` parsing helpers ---
+function normaliseSchemaCode (code) {
+  if (typeof code !== 'string' || !code.length) { return '' }
+  // Replace custom placeholders back to actual characters
+  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 {
+    // eslint-disable-next-line no-new-func
+    return new Function(body)()
+  } catch {
+    return null
+  }
+}
+
+function extractTopLevelKeysFromCode (code) {
+  const obj = parseExportedObject(code)
+  if (!obj || typeof obj !== 'object') { return [] }
+  return Object.keys(obj)
+}
+
+export function computeOrdersForTuples (root, tuples = []) {
+  // Pre-scan tuples to collect child keys that will be added/updated for each
+  // data container (e.g. ['pages', '/']). This lets us include keys created in
+  // the same batch even if they are not yet present in the state object when
+  // we compute orders.
+  const pendingChildrenByContainer = 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 }
+    // Ignore schema edits here – we want actual data container child keys
+    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, new Set())
+    }
+    // We only track updates/sets; deletes need not appear in the desired order
+    if (action === 'update' || action === 'set') {
+      pendingChildrenByContainer.get(key).add(childKey)
+    }
+  }
+
+  // 1) Prefer code-derived order for corresponding data container when schema 'code' present
+  const preferredOrderMap = 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
+
+    // Resolve present keys from state
+    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 = new Set(['__order'])
+
+    // Try to parse key order from schema.code
+    const codeKeys = extractTopLevelKeysFromCode(code)
+    let resolved = []
+    // Keys eligible for ordering are those already present OR being added in
+    // this same batch of tuples under the same container.
+    const pendingKey = JSON.stringify(containerPath)
+    const pendingChildren = pendingChildrenByContainer.get(pendingKey) || new Set()
+    const eligible = 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)
+        }
+      }
+    }
+    // Ensure any pending children not referenced by code/uses still appear
+    // after code/uses-derived order, preserving stability.
+    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 })
+    }
+  }
+
+  // 2) Include immediate parent paths from tuples (excluding schema paths)
+  const parents = getParentPathsFromTuples(tuples)
+
+  // 3) Build final orders: prefer schema-derived order when available, otherwise infer from state
+  const orders = []
+  const seen = new Set()
+
+  // Add preferred orders first
+  preferredOrderMap.forEach(v => {
+    const k = JSON.stringify(v.path)
+    if (!seen.has(k)) { seen.add(k); orders.push(v) }
+  })
+
+  // Add remaining parents with state-derived order
+  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 }
+    // Merge in any pending children (for containers without schema edits)
+    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
+}
+
+

package/src/utils/services.js

@@ -243,5 +243,19 @@ export const SERVICE_METHODS = {
   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'
 }