@epoch32/visage 1.3.0 → 1.3.1

package/src/signals/store.ts

@@ -5,6 +5,7 @@ import { isSignal } from "./types";
 const STORE_RAW = Symbol("visage.store.raw");
 const STORE_SIGNALS = Symbol("visage.store.signals");
 const STORE_PROXY = Symbol("visage.store.proxy");
+const STORE_ITERATE = Symbol("visage.store.iterate");
 
 export type Store<T> = T;
 
@@ -61,9 +62,29 @@ function createStoreProxy<T extends object>(target: T): T {
       return value;
     },
 
+    has(target, prop) {
+      if (prop === STORE_RAW || prop === STORE_PROXY) return true;
+      if (typeof prop === "string" || typeof prop === "symbol") {
+        const sig = getOrCreatePropertySignal(target, prop);
+        sig.get();
+      }
+      return Reflect.has(target, prop);
+    },
+
+    ownKeys(target) {
+      const iterSig = getOrCreatePropertySignal(target, STORE_ITERATE);
+      iterSig.get();
+      return Reflect.ownKeys(target);
+    },
+
+    getOwnPropertyDescriptor(target, prop) {
+      return Reflect.getOwnPropertyDescriptor(target, prop);
+    },
+
     set(target, prop, value, receiver) {
+      const hadProp = Reflect.has(target, prop);
       const prevValue = Reflect.get(target, prop, receiver);
-      if (Object.is(prevValue, value)) {
+      if (hadProp && Object.is(prevValue, value)) {
         return true;
       }
 
@@ -72,10 +93,18 @@ function createStoreProxy<T extends object>(target: T): T {
         const sig = getOrCreatePropertySignal(target, prop);
         sig.set(value);
 
+        // If a new property was added, notify key iteration
+        if (!hadProp) {
+          const iterSig = getOrCreatePropertySignal(target, STORE_ITERATE);
+          iterSig.update((prev: number = 0) => prev + 1);
+        }
+
         // If array length or property keys changed, notify length/keys
         if (Array.isArray(target) && prop !== "length") {
           const lenSig = getOrCreatePropertySignal(target, "length");
           lenSig.set(target.length);
+          const iterSig = getOrCreatePropertySignal(target, STORE_ITERATE);
+          iterSig.update((prev: number = 0) => prev + 1);
         }
       }
       return success;
@@ -87,6 +116,8 @@ function createStoreProxy<T extends object>(target: T): T {
       if (hadProp && success) {
         const sig = getOrCreatePropertySignal(target, prop);
         sig.set(undefined);
+        const iterSig = getOrCreatePropertySignal(target, STORE_ITERATE);
+        iterSig.update((prev: number = 0) => prev + 1);
       }
       return success;
     }

package/src/signals/system.ts

@@ -59,6 +59,14 @@ export function removePendingEffect(eff: any): void {
   ctx.pendingEffects.delete(eff);
 }
 
+export function getBatchDepth(): number {
+  return ctx.batchDepth;
+}
+
+export function getIsFlushing(): boolean {
+  return ctx.isFlushing;
+}
+
 const MAX_FLUSH_COUNT = 100;
 
 export function flushEffects(): void {

package/src/template/template.ts

@@ -66,11 +66,22 @@ export function html(
 
   for (const bind of bindings) {
     if (bind.isAttr && bind.attrName) {
-      const targetEl = findElementWithAttributeValue(root, bind.attrName, bind.id);
+      const targetEl = findElementWithAttributeValue(root as HTMLElement, bind.attrName, bind.id);
       if (targetEl) {
         targetEl.removeAttribute(bind.attrName);
         setAttribute(targetEl, bind.attrName, bind.value);
       }
+    } else if (bind.isAttr && !bind.attrName) {
+      const propAttr = `data-visage-prop-${bind.id.replace(MARKER_PREFIX, "")}`;
+      const targetEl = findElementWithAttributeValue(root as HTMLElement, propAttr, bind.id);
+      if (targetEl) {
+        targetEl.removeAttribute(propAttr);
+        if (typeof bind.value === "object" && bind.value !== null) {
+          for (const key of Object.keys(bind.value)) {
+            setAttribute(targetEl, key, bind.value[key]);
+          }
+        }
+      }
     } else if (!bind.isAttr) {
       const commentNode = findCommentNode(root, bind.id);
       if (commentNode?.parentNode) {

package/src/virtual/virtualizer.ts

@@ -56,30 +56,41 @@ export function createVirtualizer(options: VirtualizerOptions): Virtualizer {
     return getItemHeight(index);
   };
 
-  // Compute prefix offsets for fast range calculation
-  const totalSize = computed(() => {
-    const count = getCount();
-    if (typeof options.itemHeight === "number" && dynamicSizeCache.size === 0) {
-      return count * options.itemHeight;
-    }
-    let total = 0;
-    for (let i = 0; i < count; i++) {
-      total += getItemSize(i);
-    }
-    return total;
-  });
+  // Cached prefix offsets for O(1) offset lookups and true O(log N) binary search
+  const offsetsCache: number[] = [0];
+  let offsetsValidUpTo = 0;
+
+  const invalidateOffsetsFrom = (index: number) => {
+    offsetsValidUpTo = Math.min(offsetsValidUpTo, index);
+  };
 
   const getOffsetForIndex = (targetIndex: number): number => {
+    if (targetIndex <= 0) return 0;
     if (typeof options.itemHeight === "number" && dynamicSizeCache.size === 0) {
       return targetIndex * options.itemHeight;
     }
-    let offset = 0;
-    for (let i = 0; i < targetIndex; i++) {
-      offset += getItemSize(i);
+    if (targetIndex <= offsetsValidUpTo) {
+      return offsetsCache[targetIndex]!;
     }
-    return offset;
+    for (let i = offsetsValidUpTo; i < targetIndex; i++) {
+      offsetsCache[i + 1] = (offsetsCache[i] ?? 0) + getItemSize(i);
+    }
+    offsetsValidUpTo = targetIndex;
+    return offsetsCache[targetIndex]!;
   };
 
+  const measurementVersion = signal(0, { internal: true });
+
+  // Compute prefix offsets for fast range calculation
+  const totalSize = computed(() => {
+    measurementVersion();
+    const count = getCount();
+    if (typeof options.itemHeight === "number" && dynamicSizeCache.size === 0) {
+      return count * options.itemHeight;
+    }
+    return getOffsetForIndex(count);
+  });
+
   const findIndexAtOffset = (offset: number): number => {
     const count = getCount();
     if (count === 0) return 0;
@@ -110,12 +121,14 @@ export function createVirtualizer(options: VirtualizerOptions): Virtualizer {
   };
 
   const startIndex = computed(() => {
+    measurementVersion();
     const offset = scrollOffset();
     const rawStart = findIndexAtOffset(offset);
     return Math.max(0, rawStart - overscan);
   });
 
   const endIndex = computed(() => {
+    measurementVersion();
     const count = getCount();
     if (count === 0) return 0;
     const endOffset = scrollOffset() + (containerSize() || 500);
@@ -255,8 +268,8 @@ export function createVirtualizer(options: VirtualizerOptions): Virtualizer {
       : element.getBoundingClientRect().height;
     if (measuredSize > 0 && dynamicSizeCache.get(index) !== measuredSize) {
       dynamicSizeCache.set(index, measuredSize);
-      // Force recalculation by touching scrollOffset
-      scrollOffset.update((o) => o);
+      invalidateOffsetsFrom(index);
+      measurementVersion.update((v) => v + 1);
     }
   };