@symbo.ls/sdk 2.32.0 → 2.32.2

package/src/utils/ordering.js

@@ -1,240 +0,0 @@
-/* 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',
-    'props', 'define', 'on', 'extend', 'extends', 'childExtend', 'childExtends',
-    'childProps', '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 extractTopLevelKeysFromCode (code) {
-  const src = normaliseSchemaCode(code)
-  if (!src) { return [] }
-
-  const idx = src.indexOf('export default')
-  if (idx === -1) { return [] }
-  let i = src.indexOf('{', idx)
-  if (i === -1) { return [] }
-
-  const keys = []
-  let depth = 0
-  let inStr = false
-  let strCh = ''
-  let inEsc = false
-
-  for (; i < src.length; i++) {
-    const ch = src[i]
-    if (inStr) {
-      if (inEsc) {
-        inEsc = false
-      } else if (ch === '\\') {
-        inEsc = true
-      } else if (ch === strCh) {
-        inStr = false
-        strCh = ''
-      }
-      continue
-    }
-    if (ch === '"' || ch === '\'' || ch === '`') { inStr = true; strCh = ch; continue }
-    if (ch === '{') { depth++; continue }
-    if (ch === '}') { depth--; if (depth === 0) { break } continue }
-    if (depth !== 1) { continue }
-
-    if (/[A-Za-z_$]/u.test(ch)) {
-      let j = i
-      while (j < src.length && /[A-Za-z0-9_$]/u.test(src[j])) { j++ }
-      let k = j
-      while (k < src.length && /\s/u.test(src[k])) { k++ }
-      if (src[k] === ':') {
-        const key = src.slice(i, j)
-        keys.push(key)
-      }
-      i = j
-      continue
-    }
-  }
-
-  if (!keys.length) {
-    const bodyStart = src.indexOf('{', idx)
-    const bodyEnd = src.lastIndexOf('}')
-    if (bodyStart === -1 || bodyEnd === -1 || bodyEnd <= bodyStart) {
-      return Array.from(new Set(keys))
-    }
-    const body = src.slice(bodyStart + 1, bodyEnd)
-    const re = /(?:[A-Za-z_$][A-Za-z0-9_$]*|"[^"]+"|'[^']+')\s*:/gu
-    for (const m of body.matchAll(re)) {
-      const raw = m[0].split(':')[0].trim()
-      const key = (raw[0] === '"' || raw[0] === '\'') ? raw.slice(1, -1) : raw
-      keys.push(key)
-    }
-  }
-
-  return Array.from(new Set(keys))
-}
-
-export function computeOrdersForTuples (root, tuples = []) {
-  // 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 = []
-    if (Array.isArray(codeKeys) && codeKeys.length) {
-      resolved = codeKeys.filter(k => present.has(k) && !EXCLUDE_KEYS.has(k))
-    }
-    if (resolved.length && Array.isArray(uses) && uses.length) {
-      for (let u = 0; u < uses.length; u++) {
-        const keyName = uses[u]
-        if (present.has(keyName) && !EXCLUDE_KEYS.has(keyName) && !resolved.includes(keyName)) {
-          resolved.push(keyName)
-        }
-      }
-    }
-
-    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)) { seen.add(k); orders.push(v) }
-  }
-
-  return orders
-}
-
-