@sylphx/lens-solid 2.3.3 → 2.3.4

package/dist/index.js

@@ -464,6 +464,229 @@ class EntityBuilder_ {
     return createEntityDef(this._name, fields);
   }
 }
+var valueStrategy = {
+  name: "value",
+  encode(_prev, next) {
+    return { strategy: "value", data: next };
+  },
+  decode(_current, update) {
+    return update.data;
+  },
+  estimateSize(update) {
+    return JSON.stringify(update.data).length;
+  }
+};
+var deltaStrategy = {
+  name: "delta",
+  encode(prev, next) {
+    const operations2 = computeStringDiff(prev, next);
+    const diffSize = JSON.stringify(operations2).length;
+    const valueSize = next.length + 20;
+    if (diffSize >= valueSize) {
+      return { strategy: "value", data: next };
+    }
+    return { strategy: "delta", data: operations2 };
+  },
+  decode(current, update) {
+    if (update.strategy === "value") {
+      return update.data;
+    }
+    const operations2 = update.data;
+    return applyStringDiff(current, operations2);
+  },
+  estimateSize(update) {
+    return JSON.stringify(update.data).length;
+  }
+};
+function computeStringDiff(prev, next) {
+  const operations2 = [];
+  let prefixLen = 0;
+  const minLen = Math.min(prev.length, next.length);
+  while (prefixLen < minLen && prev[prefixLen] === next[prefixLen]) {
+    prefixLen++;
+  }
+  let suffixLen = 0;
+  const remainingPrev = prev.length - prefixLen;
+  const remainingNext = next.length - prefixLen;
+  const maxSuffix = Math.min(remainingPrev, remainingNext);
+  while (suffixLen < maxSuffix && prev[prev.length - 1 - suffixLen] === next[next.length - 1 - suffixLen]) {
+    suffixLen++;
+  }
+  const deleteCount = prev.length - prefixLen - suffixLen;
+  const insertText = next.slice(prefixLen, next.length - suffixLen || undefined);
+  if (deleteCount > 0 || insertText.length > 0) {
+    operations2.push({
+      position: prefixLen,
+      ...deleteCount > 0 ? { delete: deleteCount } : {},
+      ...insertText.length > 0 ? { insert: insertText } : {}
+    });
+  }
+  return operations2;
+}
+function applyStringDiff(current, operations2) {
+  let result = current;
+  const sortedOps = [...operations2].sort((a, b) => b.position - a.position);
+  for (const op2 of sortedOps) {
+    const before = result.slice(0, op2.position);
+    const after = result.slice(op2.position + (op2.delete ?? 0));
+    result = before + (op2.insert ?? "") + after;
+  }
+  return result;
+}
+var patchStrategy = {
+  name: "patch",
+  encode(prev, next) {
+    const operations2 = computeJsonPatch(prev, next);
+    const patchSize = JSON.stringify(operations2).length;
+    const valueSize = JSON.stringify(next).length + 20;
+    if (patchSize >= valueSize) {
+      return { strategy: "value", data: next };
+    }
+    return { strategy: "patch", data: operations2 };
+  },
+  decode(current, update) {
+    if (update.strategy === "value") {
+      return update.data;
+    }
+    const operations2 = update.data;
+    return applyJsonPatch(current, operations2);
+  },
+  estimateSize(update) {
+    return JSON.stringify(update.data).length;
+  }
+};
+function computeJsonPatch(prev, next, basePath = "") {
+  const operations2 = [];
+  const prevObj = prev;
+  const nextObj = next;
+  for (const key of Object.keys(prevObj)) {
+    if (!(key in nextObj)) {
+      operations2.push({ op: "remove", path: `${basePath}/${escapeJsonPointer(key)}` });
+    }
+  }
+  for (const [key, nextValue] of Object.entries(nextObj)) {
+    const path = `${basePath}/${escapeJsonPointer(key)}`;
+    const prevValue = prevObj[key];
+    if (!(key in prevObj)) {
+      operations2.push({ op: "add", path, value: nextValue });
+    } else if (!deepEqual2(prevValue, nextValue)) {
+      if (isPlainObject(prevValue) && isPlainObject(nextValue) && !Array.isArray(prevValue) && !Array.isArray(nextValue)) {
+        operations2.push(...computeJsonPatch(prevValue, nextValue, path));
+      } else {
+        operations2.push({ op: "replace", path, value: nextValue });
+      }
+    }
+  }
+  return operations2;
+}
+function applyJsonPatch(current, operations2) {
+  const result = structuredClone(current);
+  for (const op2 of operations2) {
+    const pathParts = parseJsonPointer(op2.path);
+    switch (op2.op) {
+      case "add":
+      case "replace":
+        setValueAtPath(result, pathParts, op2.value);
+        break;
+      case "remove":
+        removeValueAtPath(result, pathParts);
+        break;
+      case "move":
+        if (op2.from) {
+          const fromParts = parseJsonPointer(op2.from);
+          const value = getValueAtPath(result, fromParts);
+          removeValueAtPath(result, fromParts);
+          setValueAtPath(result, pathParts, value);
+        }
+        break;
+      case "copy":
+        if (op2.from) {
+          const fromParts = parseJsonPointer(op2.from);
+          const value = structuredClone(getValueAtPath(result, fromParts));
+          setValueAtPath(result, pathParts, value);
+        }
+        break;
+      case "test":
+        break;
+    }
+  }
+  return result;
+}
+function applyUpdate(current, update) {
+  switch (update.strategy) {
+    case "value":
+      return valueStrategy.decode(current, update);
+    case "delta":
+      return deltaStrategy.decode(current, update);
+    case "patch":
+      return patchStrategy.decode(current, update);
+    default:
+      return update.data;
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepEqual2(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a !== "object" || a === null || b === null)
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  for (const key of aKeys) {
+    if (!deepEqual2(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function escapeJsonPointer(str) {
+  return str.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function parseJsonPointer(path) {
+  if (!path || path === "/")
+    return [];
+  return path.slice(1).split("/").map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function getValueAtPath(obj, path) {
+  let current = obj;
+  for (const key of path) {
+    if (current === null || typeof current !== "object")
+      return;
+    current = current[key];
+  }
+  return current;
+}
+function setValueAtPath(obj, path, value) {
+  if (path.length === 0)
+    return;
+  let current = obj;
+  for (let i = 0;i < path.length - 1; i++) {
+    const key = path[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[path[path.length - 1]] = value;
+}
+function removeValueAtPath(obj, path) {
+  if (path.length === 0)
+    return;
+  let current = obj;
+  for (let i = 0;i < path.length - 1; i++) {
+    const key = path[i];
+    if (!(key in current) || typeof current[key] !== "object")
+      return;
+    current = current[key];
+  }
+  delete current[path[path.length - 1]];
+}
 var OPTIMISTIC_PLUGIN_SYMBOL = Symbol.for("lens:optimistic-plugin");
 var DEFAULT_OPERATION_LOG_CONFIG = {
   maxEntries: 1e4,
@@ -846,6 +1069,245 @@ class ReconnectionMetricsTracker {
     return sorted[Math.max(0, index)];
   }
 }
+function applyOps(state, ops) {
+  let result = state;
+  for (const op2 of ops) {
+    result = applyOp(result, op2);
+  }
+  return result;
+}
+function applyOp(state, op2) {
+  switch (op2.o) {
+    case "set":
+      return setAtPath(state, op2.p, op2.v);
+    case "del":
+      return deleteAtPath(state, op2.p);
+    case "merge":
+      return mergeAtPath(state, op2.p, op2.v);
+    case "delta": {
+      const current = getAtPath(state, op2.p);
+      const updated = applyUpdate(current, { strategy: "delta", data: op2.d });
+      return setAtPath(state, op2.p, updated);
+    }
+    case "patch": {
+      const current = getAtPath(state, op2.p);
+      const updated = applyUpdate(current, { strategy: "patch", data: op2.d });
+      return setAtPath(state, op2.p, updated);
+    }
+    case "push":
+      return arrayPush(state, op2.p, op2.v);
+    case "unshift":
+      return arrayUnshift(state, op2.p, op2.v);
+    case "splice":
+      return arraySplice(state, op2.p, op2.i, op2.dc, op2.v);
+    case "arrSet":
+      return arraySetAt(state, op2.p, op2.i, op2.v);
+    case "arrDel":
+      return arrayDeleteAt(state, op2.p, op2.i);
+    case "arrSetId":
+      return arraySetById(state, op2.p, op2.id, op2.v);
+    case "arrDelId":
+      return arrayDeleteById(state, op2.p, op2.id);
+    case "arrMerge":
+      return arrayMergeAt(state, op2.p, op2.i, op2.v);
+    case "arrMergeId":
+      return arrayMergeById(state, op2.p, op2.id, op2.v);
+    default:
+      return state;
+  }
+}
+function parsePath(path) {
+  if (!path)
+    return [];
+  return path.split(".");
+}
+function getAtPath(state, path) {
+  const segments = parsePath(path);
+  let current = state;
+  for (const segment of segments) {
+    if (current === null || current === undefined)
+      return;
+    if (typeof current !== "object")
+      return;
+    current = current[segment];
+  }
+  return current;
+}
+function setAtPath(state, path, value) {
+  const segments = parsePath(path);
+  if (segments.length === 0)
+    return value;
+  return updateAtPath(state, segments, () => value);
+}
+function deleteAtPath(state, path) {
+  const segments = parsePath(path);
+  if (segments.length === 0)
+    return;
+  const parentPath = segments.slice(0, -1);
+  const key = segments[segments.length - 1];
+  return updateAtPath(state, parentPath, (parent) => {
+    if (parent === null || parent === undefined)
+      return parent;
+    if (Array.isArray(parent)) {
+      const idx = parseInt(key, 10);
+      const result = [...parent];
+      result.splice(idx, 1);
+      return result;
+    }
+    if (typeof parent === "object") {
+      const { [key]: _, ...rest } = parent;
+      return rest;
+    }
+    return parent;
+  });
+}
+function mergeAtPath(state, path, value) {
+  const segments = parsePath(path);
+  return updateAtPath(state, segments, (current) => {
+    if (current === null || current === undefined)
+      return value;
+    if (typeof current !== "object" || Array.isArray(current))
+      return value;
+    return { ...current, ...value };
+  });
+}
+function updateAtPath(state, segments, transform) {
+  if (segments.length === 0) {
+    return transform(state);
+  }
+  const [head, ...tail] = segments;
+  if (state === null || state === undefined) {
+    const isArrayIndex = /^\d+$/.test(head);
+    const newState = isArrayIndex ? [] : {};
+    return updateAtPath(newState, segments, transform);
+  }
+  if (Array.isArray(state)) {
+    const result = [...state];
+    const idx = parseInt(head, 10);
+    result[idx] = updateAtPath(result[idx], tail, transform);
+    return result;
+  }
+  if (typeof state === "object") {
+    const obj = state;
+    return {
+      ...obj,
+      [head]: updateAtPath(obj[head], tail, transform)
+    };
+  }
+  return { [head]: updateAtPath(undefined, tail, transform) };
+}
+function arrayPush(state, path, items) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return items;
+    return [...arr, ...items];
+  });
+}
+function arrayUnshift(state, path, items) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return items;
+    return [...items, ...arr];
+  });
+}
+function arraySplice(state, path, index, deleteCount, items) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return items ?? [];
+    const result = [...arr];
+    if (items) {
+      result.splice(index, deleteCount, ...items);
+    } else {
+      result.splice(index, deleteCount);
+    }
+    return result;
+  });
+}
+function arraySetAt(state, path, index, value) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr)) {
+      const result2 = [];
+      result2[index] = value;
+      return result2;
+    }
+    const result = [...arr];
+    result[index] = value;
+    return result;
+  });
+}
+function arrayDeleteAt(state, path, index) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return [];
+    const result = [...arr];
+    result.splice(index, 1);
+    return result;
+  });
+}
+function arraySetById(state, path, id2, value) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return [value];
+    const index = arr.findIndex((item) => item && typeof item === "object" && item.id === id2);
+    if (index === -1) {
+      return [...arr, value];
+    }
+    const result = [...arr];
+    result[index] = value;
+    return result;
+  });
+}
+function arrayDeleteById(state, path, id2) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return [];
+    return arr.filter((item) => !(item && typeof item === "object" && item.id === id2));
+  });
+}
+function arrayMergeAt(state, path, index, value) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr)) {
+      const result2 = [];
+      result2[index] = value;
+      return result2;
+    }
+    const result = [...arr];
+    const current = result[index];
+    if (current && typeof current === "object" && !Array.isArray(current)) {
+      result[index] = { ...current, ...value };
+    } else {
+      result[index] = value;
+    }
+    return result;
+  });
+}
+function arrayMergeById(state, path, id2, value) {
+  return updateAtPath(state, parsePath(path), (arr) => {
+    if (!Array.isArray(arr))
+      return [{ id: id2, ...value }];
+    const index = arr.findIndex((item) => item && typeof item === "object" && item.id === id2);
+    if (index === -1) {
+      return [...arr, { id: id2, ...value }];
+    }
+    const result = [...arr];
+    const current = result[index];
+    if (current && typeof current === "object" && !Array.isArray(current)) {
+      result[index] = { ...current, ...value };
+    } else {
+      result[index] = { id: id2, ...value };
+    }
+    return result;
+  });
+}
+function isSnapshot(msg) {
+  return msg.$ === "snapshot";
+}
+function isOps(msg) {
+  return msg.$ === "ops";
+}
+function isError(msg) {
+  return msg.$ === "error";
+}
 
 // ../client/dist/index.js
 function hasAnySubscription(entities, entityName, select, visited = new Set) {
@@ -926,16 +1388,16 @@ class ClientImpl {
         result = await plugin.afterResponse(result, processedOp);
       }
     }
-    if (result.error) {
-      const error = result.error;
+    if (isError(result)) {
+      const error = new Error(result.error);
       for (const plugin of this.plugins) {
         if (plugin.onError) {
           try {
             result = await plugin.onError(error, processedOp, () => this.execute(processedOp));
-            if (!result.error)
+            if (!isError(result))
               break;
           } catch (e) {
-            result = { error: e };
+            result = { $: "error", error: e instanceof Error ? e.message : String(e) };
           }
         }
       }
@@ -1094,14 +1556,17 @@ class ClientImpl {
             meta: select ? { select } : {}
           };
           const response = await this.execute(op2);
-          if (response.error) {
-            throw response.error;
+          if (isError(response)) {
+            throw new Error(response.error);
           }
-          sub.data = response.data;
-          for (const observer of sub.observers) {
-            observer.next?.(response.data);
+          if (isSnapshot(response)) {
+            sub.data = response.data;
+            for (const observer of sub.observers) {
+              observer.next?.(response.data);
+            }
+            return onfulfilled ? onfulfilled(response.data) : response.data;
           }
-          return onfulfilled ? onfulfilled(response.data) : response.data;
+          return onfulfilled ? onfulfilled(sub.data) : sub.data;
         } catch (error) {
           const err = error instanceof Error ? error : new Error(String(error));
           sub.error = err;
@@ -1136,16 +1601,29 @@ class ClientImpl {
       const resultOrObservable = this.transport.execute(op2);
       if (this.isObservable(resultOrObservable)) {
         const subscription = resultOrObservable.subscribe({
-          next: (result) => {
-            if (result.data !== undefined) {
-              sub.data = result.data;
+          next: (message) => {
+            if (isSnapshot(message)) {
+              sub.data = message.data;
               sub.error = null;
               for (const observer of sub.observers) {
-                observer.next?.(result.data);
+                observer.next?.(message.data);
               }
-            }
-            if (result.error) {
-              const err = result.error instanceof Error ? result.error : new Error(String(result.error));
+            } else if (isOps(message)) {
+              try {
+                sub.data = applyOps(sub.data, message.ops);
+                sub.error = null;
+                for (const observer of sub.observers) {
+                  observer.next?.(sub.data);
+                }
+              } catch (updateErr) {
+                const err = updateErr instanceof Error ? updateErr : new Error(String(updateErr));
+                sub.error = err;
+                for (const observer of sub.observers) {
+                  observer.error?.(err);
+                }
+              }
+            } else if (isError(message)) {
+              const err = new Error(message.error);
               sub.error = err;
               for (const observer of sub.observers) {
                 observer.error?.(err);
@@ -1186,10 +1664,13 @@ class ClientImpl {
       meta: select ? { select } : {}
     };
     const response = await this.execute(op2);
-    if (response.error) {
-      throw response.error;
+    if (isError(response)) {
+      throw new Error(response.error);
+    }
+    if (isSnapshot(response)) {
+      return { data: response.data };
     }
-    return { data: response.data };
+    return { data: null };
   }
   createAccessor(path) {
     return (descriptor) => {
@@ -1309,16 +1790,17 @@ async function executeRequest(baseUrl, op2, options) {
     }
     if (!response.ok) {
       return {
-        error: new Error(`HTTP ${response.status}: ${response.statusText}`)
+        $: "error",
+        error: `HTTP ${response.status}: ${response.statusText}`
       };
     }
     const result = await response.json();
     return result;
   } catch (error) {
     if (error instanceof Error && error.name === "AbortError") {
-      return { error: new Error("Request timeout") };
+      return { $: "error", error: "Request timeout" };
     }
-    return { error };
+    return { $: "error", error: error instanceof Error ? error.message : String(error) };
   }
 }
 function createPollingObservable(baseUrl, op2, options) {
@@ -1331,24 +1813,28 @@ function createPollingObservable(baseUrl, op2, options) {
         if (!active)
           return;
         try {
-          const result = await executeRequest(baseUrl, op2, {
+          const message = await executeRequest(baseUrl, op2, {
             headers: options.headers,
             fetch: options.fetch
           });
           if (!active)
             return;
-          if (result.error) {
+          if (isError(message)) {
             retries++;
             if (retries > options.maxRetries) {
-              observer.error?.(result.error);
+              observer.error?.(new Error(message.error));
               return;
             }
           } else {
             retries = 0;
-            const newValue = JSON.stringify(result.data);
-            if (newValue !== JSON.stringify(lastValue)) {
-              lastValue = result.data;
-              observer.next?.(result);
+            if (isSnapshot(message)) {
+              const hasDataChange = JSON.stringify(message.data) !== JSON.stringify(lastValue);
+              if (hasDataChange) {
+                lastValue = message.data;
+                observer.next?.(message);
+              }
+            } else if (isOps(message)) {
+              observer.next?.(message);
             }
           }
           if (active) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-solid",
-	"version": "2.3.3",
+	"version": "2.3.4",
 	"description": "SolidJS bindings for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -31,8 +31,8 @@
 	"author": "SylphxAI",
 	"license": "MIT",
 	"dependencies": {
-		"@sylphx/lens-client": "^2.5.3",
-		"@sylphx/lens-core": "^2.11.2"
+		"@sylphx/lens-client": "^2.6.0",
+		"@sylphx/lens-core": "^2.12.0"
 	},
 	"peerDependencies": {
 		"solid-js": ">=1.8.0"