@symbo.ls/sdk 2.34.34 → 3.1.1

package/dist/esm/utils/changePreprocessor.js

@@ -1,542 +0,0 @@
-// src/utils/jsonDiff.js
-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;
-}
-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;
-}
-
-// 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 < 2) {
-      continue;
-    }
-    if (p[0] === "schema") {
-      continue;
-    }
-    const containerPath = p.slice(0, -1);
-    const childKey = p[p.length - 1];
-    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 existingKeys = v.keys;
-      const existingSet = new Set(existingKeys);
-      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"
-      ]);
-      let firstMetaIndex = existingKeys.length;
-      for (let j = 0; j < existingKeys.length; j++) {
-        if (META_KEYS.has(existingKeys[j])) {
-          firstMetaIndex = j;
-          break;
-        }
-      }
-      for (const child of pending) {
-        if (existingSet.has(child)) {
-          continue;
-        }
-        const insertIndex = firstMetaIndex;
-        existingKeys.splice(insertIndex, 0, child);
-        existingSet.add(child);
-        firstMetaIndex++;
-      }
-    }
-    seen.add(k);
-    orders.push(v);
-  }
-  return orders;
-}
-
-// src/utils/changePreprocessor.js
-function isPlainObject2(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) && isPlainObject2(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 (!isPlainObject2(prev) || !isPlainObject2(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 || !isPlainObject2(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
-};