@sylphx/lens-signals 1.0.0

package/dist/index.js

@@ -0,0 +1,528 @@
+// src/signal.ts
+import {
+  batch as preactBatch,
+  computed as preactComputed,
+  effect as preactEffect,
+  signal as preactSignal
+} from "@preact/signals-core";
+function signal(initial) {
+  return preactSignal(initial);
+}
+function computed(compute) {
+  return preactComputed(compute);
+}
+function effect(fn) {
+  return preactEffect(fn);
+}
+function batch(fn) {
+  return preactBatch(fn);
+}
+function isSignal(value) {
+  return value !== null && typeof value === "object" && "value" in value && "peek" in value && "subscribe" in value;
+}
+function toPromise(sig) {
+  return new Promise((resolve) => {
+    let isFirst = true;
+    let unsub;
+    unsub = sig.subscribe((value) => {
+      if (isFirst) {
+        isFirst = false;
+        return;
+      }
+      unsub();
+      resolve(value);
+    });
+  });
+}
+function derive(signals, fn) {
+  return computed(() => fn(signals.map((s) => s.value)));
+}
+// src/reactive-store.ts
+import { applyUpdate, makeEntityKey } from "@sylphx/lens-core";
+import {
+  createCachePlugin,
+  execute,
+  registerPlugin,
+  unregisterPlugin
+} from "@sylphx/reify";
+class ReactiveStore {
+  entities = new Map;
+  lists = new Map;
+  optimisticUpdates = new Map;
+  optimisticTransactions = new Map;
+  config;
+  tagIndex = new Map;
+  constructor(config = {}) {
+    this.config = {
+      optimistic: config.optimistic ?? true,
+      cacheTTL: config.cacheTTL ?? 5 * 60 * 1000,
+      maxCacheSize: config.maxCacheSize ?? 1000,
+      cascadeRules: config.cascadeRules ?? []
+    };
+  }
+  getEntity(entityName, entityId) {
+    const key = this.makeKey(entityName, entityId);
+    if (!this.entities.has(key)) {
+      this.entities.set(key, signal({
+        data: null,
+        loading: true,
+        error: null,
+        stale: false,
+        refCount: 0
+      }));
+    }
+    return this.entities.get(key);
+  }
+  setEntity(entityName, entityId, data, tags) {
+    const key = this.makeKey(entityName, entityId);
+    const entitySignal = this.entities.get(key);
+    const now = Date.now();
+    if (entitySignal) {
+      entitySignal.value = {
+        ...entitySignal.value,
+        data,
+        loading: false,
+        error: null,
+        stale: false,
+        cachedAt: now,
+        tags: tags ?? entitySignal.value.tags
+      };
+    } else {
+      this.entities.set(key, signal({
+        data,
+        loading: false,
+        error: null,
+        stale: false,
+        refCount: 0,
+        cachedAt: now,
+        tags
+      }));
+    }
+    if (tags) {
+      for (const tag of tags) {
+        if (!this.tagIndex.has(tag)) {
+          this.tagIndex.set(tag, new Set);
+        }
+        this.tagIndex.get(tag).add(key);
+      }
+    }
+  }
+  applyServerUpdate(entityName, entityId, update) {
+    const key = this.makeKey(entityName, entityId);
+    const entitySignal = this.entities.get(key);
+    if (entitySignal && entitySignal.value.data != null) {
+      const newData = applyUpdate(entitySignal.value.data, update);
+      entitySignal.value = {
+        ...entitySignal.value,
+        data: newData,
+        stale: false
+      };
+    }
+  }
+  setEntityError(entityName, entityId, error) {
+    const key = this.makeKey(entityName, entityId);
+    const entitySignal = this.entities.get(key);
+    if (entitySignal) {
+      entitySignal.value = {
+        ...entitySignal.value,
+        loading: false,
+        error
+      };
+    }
+  }
+  setEntityLoading(entityName, entityId, loading) {
+    const key = this.makeKey(entityName, entityId);
+    const entitySignal = this.entities.get(key);
+    if (entitySignal) {
+      entitySignal.value = {
+        ...entitySignal.value,
+        loading
+      };
+    }
+  }
+  removeEntity(entityName, entityId) {
+    const key = this.makeKey(entityName, entityId);
+    this.entities.delete(key);
+  }
+  hasEntity(entityName, entityId) {
+    const key = this.makeKey(entityName, entityId);
+    return this.entities.has(key);
+  }
+  getList(queryKey) {
+    if (!this.lists.has(queryKey)) {
+      this.lists.set(queryKey, signal({
+        data: null,
+        loading: true,
+        error: null,
+        stale: false,
+        refCount: 0
+      }));
+    }
+    return this.lists.get(queryKey);
+  }
+  setList(queryKey, data) {
+    const listSignal = this.lists.get(queryKey);
+    if (listSignal) {
+      listSignal.value = {
+        ...listSignal.value,
+        data,
+        loading: false,
+        error: null,
+        stale: false
+      };
+    } else {
+      this.lists.set(queryKey, signal({
+        data,
+        loading: false,
+        error: null,
+        stale: false,
+        refCount: 0
+      }));
+    }
+  }
+  applyOptimistic(entityName, type, data) {
+    if (!this.config.optimistic) {
+      return "";
+    }
+    const optimisticId = `opt_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    const entityId = data.id;
+    const key = this.makeKey(entityName, entityId);
+    const entitySignal = this.entities.get(key);
+    const originalData = entitySignal?.value.data ?? null;
+    batch(() => {
+      switch (type) {
+        case "create":
+          this.setEntity(entityName, entityId, data);
+          break;
+        case "update":
+          if (entitySignal?.value.data) {
+            this.setEntity(entityName, entityId, {
+              ...entitySignal.value.data,
+              ...data
+            });
+          }
+          break;
+        case "delete":
+          if (entitySignal) {
+            entitySignal.value = {
+              ...entitySignal.value,
+              data: null
+            };
+          }
+          break;
+      }
+    });
+    this.optimisticUpdates.set(optimisticId, {
+      id: optimisticId,
+      entityName,
+      entityId,
+      type,
+      originalData,
+      optimisticData: data,
+      timestamp: Date.now()
+    });
+    return optimisticId;
+  }
+  confirmOptimistic(optimisticId, serverData) {
+    const entry = this.optimisticUpdates.get(optimisticId);
+    if (!entry)
+      return;
+    if (serverData !== undefined && entry.type !== "delete") {
+      this.setEntity(entry.entityName, entry.entityId, serverData);
+    }
+    this.optimisticUpdates.delete(optimisticId);
+  }
+  rollbackOptimistic(optimisticId) {
+    const entry = this.optimisticUpdates.get(optimisticId);
+    if (!entry)
+      return;
+    batch(() => {
+      switch (entry.type) {
+        case "create":
+          this.removeEntity(entry.entityName, entry.entityId);
+          break;
+        case "update":
+        case "delete":
+          if (entry.originalData !== null) {
+            this.setEntity(entry.entityName, entry.entityId, entry.originalData);
+          }
+          break;
+      }
+    });
+    this.optimisticUpdates.delete(optimisticId);
+  }
+  getPendingOptimistic() {
+    return Array.from(this.optimisticUpdates.values());
+  }
+  async applyPipelineOptimistic(pipeline, input) {
+    if (!this.config.optimistic) {
+      return "";
+    }
+    const txId = `tx_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    const originalData = new Map;
+    const cacheAdapter = {
+      get: (key) => {
+        const [entityName, entityId] = key.split(":");
+        const entitySignal = this.entities.get(this.makeKey(entityName, entityId));
+        return entitySignal?.value.data ?? undefined;
+      },
+      set: (key, value) => {
+        const [entityName, entityId] = key.split(":");
+        const storeKey = this.makeKey(entityName, entityId);
+        if (!originalData.has(storeKey)) {
+          const entitySignal = this.entities.get(storeKey);
+          originalData.set(storeKey, entitySignal?.value.data ?? null);
+        }
+        this.setEntity(entityName, entityId, value);
+      },
+      delete: (key) => {
+        const [entityName, entityId] = key.split(":");
+        const storeKey = this.makeKey(entityName, entityId);
+        if (!originalData.has(storeKey)) {
+          const entitySignal2 = this.entities.get(storeKey);
+          originalData.set(storeKey, entitySignal2?.value.data ?? null);
+        }
+        const entitySignal = this.entities.get(storeKey);
+        if (entitySignal) {
+          entitySignal.value = { ...entitySignal.value, data: null };
+        }
+        return true;
+      },
+      has: (key) => {
+        const [entityName, entityId] = key.split(":");
+        return this.entities.has(this.makeKey(entityName, entityId));
+      }
+    };
+    const cachePlugin = createCachePlugin(cacheAdapter);
+    registerPlugin(cachePlugin);
+    let results;
+    try {
+      results = await execute(pipeline, input);
+    } finally {
+      unregisterPlugin("entity");
+    }
+    this.optimisticTransactions.set(txId, {
+      id: txId,
+      results,
+      originalData,
+      timestamp: Date.now()
+    });
+    return txId;
+  }
+  confirmPipelineOptimistic(txId, serverResults) {
+    const tx = this.optimisticTransactions.get(txId);
+    if (!tx)
+      return;
+    if (serverResults) {
+      batch(() => {
+        for (const result of serverResults) {
+          this.removeEntity(result.entity, result.tempId);
+          const realData = result.data;
+          if (realData?.id) {
+            this.setEntity(result.entity, realData.id, realData);
+          }
+        }
+      });
+    }
+    this.optimisticTransactions.delete(txId);
+  }
+  rollbackPipelineOptimistic(txId) {
+    const tx = this.optimisticTransactions.get(txId);
+    if (!tx)
+      return;
+    batch(() => {
+      for (const [key, originalData] of tx.originalData) {
+        const [entityName, entityId] = key.split(":");
+        if (originalData === null) {
+          this.removeEntity(entityName, entityId);
+        } else {
+          this.setEntity(entityName, entityId, originalData);
+        }
+      }
+    });
+    this.optimisticTransactions.delete(txId);
+  }
+  getPendingTransactions() {
+    return Array.from(this.optimisticTransactions.values());
+  }
+  invalidate(entityName, entityId, options) {
+    const key = this.makeKey(entityName, entityId);
+    this.markStale(key);
+    if (options?.cascade !== false) {
+      this.cascadeInvalidate(entityName, "update");
+    }
+  }
+  invalidateEntity(entityName, options) {
+    for (const key of this.entities.keys()) {
+      if (key.startsWith(`${entityName}:`)) {
+        this.markStale(key);
+      }
+    }
+    for (const listKey of this.lists.keys()) {
+      if (listKey.includes(entityName)) {
+        const listSignal = this.lists.get(listKey);
+        if (listSignal) {
+          listSignal.value = { ...listSignal.value, stale: true };
+        }
+      }
+    }
+    if (options?.cascade !== false) {
+      this.cascadeInvalidate(entityName, "update");
+    }
+  }
+  invalidateByTags(tags) {
+    let count = 0;
+    for (const tag of tags) {
+      const keys = this.tagIndex.get(tag);
+      if (keys) {
+        for (const key of keys) {
+          this.markStale(key);
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+  invalidateByPattern(pattern) {
+    const regex = this.patternToRegex(pattern);
+    let count = 0;
+    for (const key of this.entities.keys()) {
+      if (regex.test(key)) {
+        this.markStale(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  tagEntity(entityName, entityId, tags) {
+    const key = this.makeKey(entityName, entityId);
+    const entitySignal = this.entities.get(key);
+    if (entitySignal) {
+      entitySignal.value = {
+        ...entitySignal.value,
+        tags: [...new Set([...entitySignal.value.tags ?? [], ...tags])]
+      };
+      for (const tag of tags) {
+        if (!this.tagIndex.has(tag)) {
+          this.tagIndex.set(tag, new Set);
+        }
+        this.tagIndex.get(tag).add(key);
+      }
+    }
+  }
+  isStale(entityName, entityId) {
+    const key = this.makeKey(entityName, entityId);
+    const entitySignal = this.entities.get(key);
+    if (!entitySignal)
+      return true;
+    if (entitySignal.value.stale)
+      return true;
+    if (!entitySignal.value.cachedAt)
+      return false;
+    return Date.now() - entitySignal.value.cachedAt > this.config.cacheTTL;
+  }
+  getStaleWhileRevalidate(entityName, entityId, revalidate) {
+    const key = this.makeKey(entityName, entityId);
+    const entitySignal = this.entities.get(key);
+    const isStale = this.isStale(entityName, entityId);
+    let revalidating = null;
+    if (isStale && entitySignal?.value.data != null) {
+      revalidating = revalidate().then((newData) => {
+        this.setEntity(entityName, entityId, newData);
+        return newData;
+      });
+    }
+    return {
+      data: entitySignal?.value.data ?? null,
+      isStale,
+      revalidating
+    };
+  }
+  markStale(key) {
+    const entitySignal = this.entities.get(key);
+    if (entitySignal) {
+      entitySignal.value = { ...entitySignal.value, stale: true };
+    }
+  }
+  cascadeInvalidate(entityName, operation) {
+    for (const rule of this.config.cascadeRules) {
+      if (rule.source !== entityName)
+        continue;
+      if (rule.operations && !rule.operations.includes(operation))
+        continue;
+      for (const target of rule.targets) {
+        this.invalidateEntity(target, { cascade: false });
+      }
+    }
+  }
+  patternToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
+  }
+  retain(entityName, entityId) {
+    const key = this.makeKey(entityName, entityId);
+    const entitySignal = this.entities.get(key);
+    if (entitySignal) {
+      entitySignal.value = {
+        ...entitySignal.value,
+        refCount: entitySignal.value.refCount + 1
+      };
+    }
+  }
+  release(entityName, entityId) {
+    const key = this.makeKey(entityName, entityId);
+    const entitySignal = this.entities.get(key);
+    if (entitySignal) {
+      const newRefCount = Math.max(0, entitySignal.value.refCount - 1);
+      entitySignal.value = {
+        ...entitySignal.value,
+        refCount: newRefCount
+      };
+      if (newRefCount === 0) {
+        entitySignal.value = {
+          ...entitySignal.value,
+          stale: true
+        };
+      }
+    }
+  }
+  gc() {
+    let cleared = 0;
+    for (const [key, entitySignal] of this.entities) {
+      if (entitySignal.value.stale && entitySignal.value.refCount === 0) {
+        this.entities.delete(key);
+        cleared++;
+      }
+    }
+    return cleared;
+  }
+  clear() {
+    this.entities.clear();
+    this.lists.clear();
+    this.optimisticUpdates.clear();
+  }
+  makeKey(entityName, entityId) {
+    return makeEntityKey(entityName, entityId);
+  }
+  getStats() {
+    return {
+      entities: this.entities.size,
+      lists: this.lists.size,
+      pendingOptimistic: this.optimisticUpdates.size
+    };
+  }
+}
+function createStore(config) {
+  return new ReactiveStore(config);
+}
+export {
+  toPromise,
+  signal,
+  isSignal,
+  effect,
+  derive,
+  createStore,
+  computed,
+  batch,
+  ReactiveStore
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+	"name": "@sylphx/lens-signals",
+	"version": "1.0.0",
+	"description": "Signals-based reactive store for Lens client",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"scripts": {
+		"build": "bunup",
+		"typecheck": "tsc --noEmit",
+		"test": "echo 'no tests yet'",
+		"prepack": "[ -d dist ] || bun run build"
+	},
+	"files": [
+		"dist",
+		"src"
+	],
+	"keywords": [
+		"lens",
+		"signals",
+		"reactive",
+		"store",
+		"preact"
+	],
+	"author": "SylphxAI",
+	"license": "MIT",
+	"dependencies": {
+		"@sylphx/lens-core": "^2.0.1",
+		"@sylphx/reify": "^0.1.2"
+	},
+	"peerDependencies": {
+		"@preact/signals-core": ">=1.8.0"
+	},
+	"devDependencies": {
+		"@preact/signals-core": "^1.8.0",
+		"typescript": "^5.9.3"
+	}
+}

package/src/index.ts

@@ -0,0 +1,58 @@
+/**
+ * @sylphx/lens-signals
+ *
+ * Signals-based reactive store for Lens client.
+ * Uses Preact Signals for fine-grained reactivity.
+ *
+ * @example
+ * ```typescript
+ * import { createStore, signal, computed, effect } from "@sylphx/lens-signals";
+ *
+ * // Create reactive store
+ * const store = createStore();
+ *
+ * // Get entity signal
+ * const user = store.getEntity<User>("User", "123");
+ *
+ * // React to changes
+ * effect(() => {
+ *   console.log("User:", user.value.data);
+ * });
+ * ```
+ */
+
+// =============================================================================
+// Signals
+// =============================================================================
+
+export {
+	batch,
+	computed,
+	derive,
+	effect,
+	isSignal,
+	// Types
+	type Signal,
+	type Subscriber,
+	// Functions
+	signal,
+	toPromise,
+	type Unsubscribe,
+	type WritableSignal,
+} from "./signal.js";
+
+// =============================================================================
+// Store
+// =============================================================================
+
+export {
+	type CascadeRule,
+	createStore,
+	type EntityKey,
+	type EntityState,
+	type InvalidationOptions,
+	type OptimisticEntry,
+	type OptimisticTransaction,
+	ReactiveStore,
+	type StoreConfig,
+} from "./reactive-store.js";