@fictjs/runtime 0.4.0 → 0.5.1

package/dist/internal.js

@@ -1,31 +1,13 @@
 import {
   runInScope
-} from "./chunk-TWELIZRY.js";
+} from "./chunk-AR6NSCZM.js";
 import {
-  Aliases,
-  BooleanAttributes,
-  ChildProperties,
-  DelegatedEvents,
   Fragment,
-  Properties,
-  SVGElements,
-  SVGNamespace,
-  UnitlessStyles,
-  __fictPopContext,
   __fictProp,
   __fictPropsRest,
-  __fictPushContext,
-  __fictRender,
-  __fictResetContext,
-  __fictUseContext,
-  __fictUseEffect,
-  __fictUseMemo,
-  __fictUseSignal,
-  __resetReactiveState,
   addEventListener,
   assign,
   batch,
-  batch2,
   bindAttribute,
   bindClass,
   bindEvent,
@@ -37,194 +19,90 @@ import {
   classList,
   clearDelegatedEvents,
   createConditional,
-  createEffect,
   createElement,
-  createMemo,
   createPortal,
   createPropsProxy,
+  delegateEvents,
+  getSlotEnd,
+  hydrateComponent,
+  insert,
+  insertBetween,
+  insertNodesBefore,
+  isHydratingActive,
+  isReactive,
+  keyed,
+  mergeProps,
+  prop,
+  removeNodes,
+  render,
+  resolvePath,
+  spread,
+  template,
+  toNodeArray,
+  unwrap,
+  withHydrationRange
+} from "./chunk-RY5CY4CI.js";
+import {
+  Aliases,
+  BooleanAttributes,
+  ChildProperties,
+  DelegatedEvents,
+  Properties,
+  SVGElements,
+  SVGNamespace,
+  UnitlessStyles,
+  __fictDisableResumable,
+  __fictDisableSSR,
+  __fictEnableResumable,
+  __fictEnableSSR,
+  __fictEnsureScope,
+  __fictEnterHydration,
+  __fictExitHydration,
+  __fictGetResume,
+  __fictGetSSRScope,
+  __fictGetScopeProps,
+  __fictGetScopeRegistry,
+  __fictIsHydrating,
+  __fictIsResumable,
+  __fictIsSSR,
+  __fictPopContext,
+  __fictPrepareContext,
+  __fictPushContext,
+  __fictQrl,
+  __fictRegisterResume,
+  __fictRegisterScope,
+  __fictRender,
+  __fictResetContext,
+  __fictSerializeSSRState,
+  __fictSetSSRState,
+  __fictUseContext,
+  __fictUseEffect,
+  __fictUseLexicalScope,
+  __fictUseMemo,
+  __fictUseSignal,
+  __resetReactiveState,
+  createEffect,
+  createMemo,
   createRenderEffect,
   createRootContext,
   createSelector,
-  delegateEvents,
+  createStore,
+  deserializeValue,
   destroyRoot,
   effectScope,
   flush,
   flushOnMount,
   getCurrentRoot,
   getPropAlias,
-  insert,
-  insertNodesBefore,
-  isReactive,
-  keyed,
-  mergeProps,
+  isStoreProxy,
   onDestroy,
   popRoot,
-  prop,
   pushRoot,
-  removeNodes,
+  serializeValue,
   setActiveSub,
   signal,
-  spread,
-  template,
-  toNodeArray,
-  unwrap
-} from "./chunk-SO6X7G5S.js";
-
-// src/store.ts
-var PROXY = Symbol("fict:store-proxy");
-var TARGET = Symbol("fict:store-target");
-var ITERATE_KEY = Symbol("fict:iterate");
-function createStore(initialValue) {
-  const unwrapped = unwrap2(initialValue);
-  const wrapped = wrap(unwrapped);
-  function setStore(fn) {
-    batch(() => {
-      const result = fn(wrapped);
-      if (result !== void 0) {
-        reconcile(wrapped, result);
-      }
-    });
-  }
-  return [wrapped, setStore];
-}
-var proxyCache = /* @__PURE__ */ new WeakMap();
-var signalCache = /* @__PURE__ */ new WeakMap();
-function wrap(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (Reflect.get(value, PROXY)) return value;
-  if (proxyCache.has(value)) return proxyCache.get(value);
-  const handler = {
-    get(target, prop2, receiver) {
-      if (prop2 === PROXY) return true;
-      if (prop2 === TARGET) return target;
-      const value2 = Reflect.get(target, prop2, receiver);
-      track(target, prop2);
-      return wrap(value2);
-    },
-    has(target, prop2) {
-      const result = Reflect.has(target, prop2);
-      track(target, prop2);
-      return result;
-    },
-    ownKeys(target) {
-      track(target, ITERATE_KEY);
-      return Reflect.ownKeys(target);
-    },
-    getOwnPropertyDescriptor(target, prop2) {
-      track(target, prop2);
-      return Reflect.getOwnPropertyDescriptor(target, prop2);
-    },
-    set(target, prop2, value2, receiver) {
-      if (prop2 === PROXY || prop2 === TARGET) return false;
-      const isArrayLength = Array.isArray(target) && prop2 === "length";
-      const oldLength = isArrayLength ? target.length : void 0;
-      const hadKey = Object.prototype.hasOwnProperty.call(target, prop2);
-      const oldValue = Reflect.get(target, prop2, receiver);
-      if (oldValue === value2) return true;
-      const result = Reflect.set(target, prop2, value2, receiver);
-      if (result) {
-        trigger(target, prop2);
-        if (!hadKey) {
-          trigger(target, ITERATE_KEY);
-        }
-        if (isArrayLength) {
-          const nextLength = target.length;
-          if (typeof oldLength === "number" && nextLength < oldLength) {
-            const signals = signalCache.get(target);
-            if (signals) {
-              for (const key of signals.keys()) {
-                if (typeof key !== "string") continue;
-                const index = Number(key);
-                if (!Number.isInteger(index) || String(index) !== key) continue;
-                if (index >= nextLength && index < oldLength) {
-                  trigger(target, key);
-                }
-              }
-            }
-          }
-          trigger(target, ITERATE_KEY);
-        }
-      }
-      return result;
-    },
-    deleteProperty(target, prop2) {
-      const hadKey = Object.prototype.hasOwnProperty.call(target, prop2);
-      const result = Reflect.deleteProperty(target, prop2);
-      if (result) {
-        trigger(target, prop2);
-        if (hadKey) {
-          trigger(target, ITERATE_KEY);
-        }
-      }
-      return result;
-    }
-  };
-  const proxy = new Proxy(value, handler);
-  proxyCache.set(value, proxy);
-  return proxy;
-}
-function unwrap2(value) {
-  if (value && typeof value === "object" && Reflect.get(value, PROXY)) {
-    return Reflect.get(value, TARGET);
-  }
-  return value;
-}
-function track(target, prop2) {
-  let signals = signalCache.get(target);
-  if (!signals) {
-    signals = /* @__PURE__ */ new Map();
-    signalCache.set(target, signals);
-  }
-  let s = signals.get(prop2);
-  if (!s) {
-    const initial = prop2 === ITERATE_KEY ? Reflect.ownKeys(target).length : getLastValue(target, prop2);
-    s = signal(initial);
-    signals.set(prop2, s);
-  }
-  s();
-}
-function trigger(target, prop2) {
-  const signals = signalCache.get(target);
-  if (signals) {
-    const s = signals.get(prop2);
-    if (s) {
-      if (prop2 === ITERATE_KEY) {
-        s(Reflect.ownKeys(target).length);
-      } else {
-        s(getLastValue(target, prop2));
-      }
-    }
-  }
-}
-function getLastValue(target, prop2) {
-  return Reflect.get(target, prop2);
-}
-function reconcile(target, value) {
-  if (target === value) return;
-  if (value === null || typeof value !== "object") {
-    throw new Error(
-      `[Fict] Cannot replace store with primitive value: ${String(
-        value
-      )}. setStore should return an object/array to merge.`
-    );
-  }
-  const realTarget = unwrap2(target);
-  const realValue = unwrap2(value);
-  const keys = /* @__PURE__ */ new Set([...Object.keys(realTarget), ...Object.keys(realValue)]);
-  for (const key of keys) {
-    const rTarget = realTarget;
-    const rValue = realValue;
-    if (rValue[key] === void 0 && rTarget[key] !== void 0) {
-      delete target[key];
-    } else if (rTarget[key] !== rValue[key]) {
-      ;
-      target[key] = rValue[key];
-    }
-  }
-  if (Array.isArray(target) && Array.isArray(realValue) && target.length !== realValue.length) {
-    target.length = realValue.length;
-  }
-}
+  unwrapStore
+} from "./chunk-7BO6P2KP.js";
 
 // src/reconcile.ts
 function reconcileArrays(parentNode, a, b) {
@@ -314,6 +192,7 @@ function reconcileArrays(parentNode, a, b) {
 
 // src/list-helpers.ts
 var isDev = typeof __DEV__ !== "undefined" ? __DEV__ : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+var isShadowRoot = (node) => typeof ShadowRoot !== "undefined" && node instanceof ShadowRoot;
 function moveNodesBefore(parent, nodes, anchor) {
   for (let i = nodes.length - 1; i >= 0; i--) {
     const node = nodes[i];
@@ -353,21 +232,21 @@ var MAX_SAFE_VERSION = 9007199254740991;
 function createVersionedSignalAccessor(initialValue) {
   let current = initialValue;
   let version = 0;
-  const track2 = signal(version);
+  const track = signal(version);
   function accessor(value) {
     if (arguments.length === 0) {
-      track2();
+      track();
       return current;
     }
     current = value;
     version = version >= MAX_SAFE_VERSION ? 1 : version + 1;
-    track2(version);
+    track(version);
   }
   return accessor;
 }
-function createKeyedListContainer() {
-  const startMarker = document.createComment("fict:list:start");
-  const endMarker = document.createComment("fict:list:end");
+function createKeyedListContainer(startOverride, endOverride) {
+  const startMarker = startOverride ?? document.createComment("fict:list:start");
+  const endMarker = endOverride ?? document.createComment("fict:list:end");
   const dispose = () => {
     for (const block of container.blocks.values()) {
       destroyRoot(block.root);
@@ -407,7 +286,7 @@ function createKeyedListContainer() {
   };
   return container;
 }
-function createKeyedBlock(key, item, index, render, needsIndex = true, hostRoot) {
+function createKeyedBlock(key, item, index, render2, needsIndex = true, hostRoot) {
   const itemSig = createVersionedSignalAccessor(item);
   const indexSig = needsIndex ? signal(index) : ((next) => {
     if (arguments.length === 0) return index;
@@ -421,7 +300,7 @@ function createKeyedBlock(key, item, index, render, needsIndex = true, hostRoot)
   const prevSub = setActiveSub(void 0);
   try {
     scopeDispose = effectScope(() => {
-      const rendered = render(itemSig, indexSig, key);
+      const rendered = render2(itemSig, indexSig, key);
       if (rendered instanceof Node || Array.isArray(rendered) && rendered.every((n) => n instanceof Node)) {
         nodes = toNodeArray(rendered);
       } else {
@@ -534,20 +413,41 @@ function reorderByLIS(parent, endMarker, prev, next) {
   }
   return moved;
 }
-function createKeyedList(getItems, keyFn, renderItem, needsIndex) {
+function createKeyedList(getItems, keyFn, renderItem, needsIndex, startMarker, endMarker) {
   const resolvedNeedsIndex = arguments.length >= 4 ? !!needsIndex : renderItem.length > 1;
-  return createFineGrainedKeyedList(getItems, keyFn, renderItem, resolvedNeedsIndex);
+  return createFineGrainedKeyedList(
+    getItems,
+    keyFn,
+    renderItem,
+    resolvedNeedsIndex,
+    startMarker,
+    endMarker
+  );
 }
-function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
-  const container = createKeyedListContainer();
+function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex, startOverride, endOverride) {
+  const container = createKeyedListContainer(startOverride, endOverride);
   const hostRoot = getCurrentRoot();
-  const fragment = document.createDocumentFragment();
-  fragment.append(container.startMarker, container.endMarker);
+  const useProvided = !!(startOverride && endOverride);
+  const fragment = useProvided ? container.startMarker : document.createDocumentFragment();
+  if (!useProvided) {
+    ;
+    fragment.append(container.startMarker, container.endMarker);
+  }
   let disposed = false;
   let effectDispose;
   let connectObserver = null;
   let effectStarted = false;
   let startScheduled = false;
+  let initialHydrating = __fictIsHydrating();
+  const collectBetween = () => {
+    const nodes = [];
+    let cursor = container.startMarker.nextSibling;
+    while (cursor && cursor !== container.endMarker) {
+      nodes.push(cursor);
+      cursor = cursor.nextSibling;
+    }
+    return nodes;
+  };
   const getConnectedParent = () => {
     const endParent = container.endMarker.parentNode;
     const startParent = container.startMarker.parentNode;
@@ -556,19 +456,82 @@ function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
       if ("isConnected" in parentNode && !parentNode.isConnected) return null;
       return parentNode;
     }
+    if (endParent && startParent && endParent === startParent && isShadowRoot(endParent)) {
+      const shadowRoot = endParent;
+      const host = shadowRoot.host;
+      if ("isConnected" in host && !host.isConnected) return null;
+      return shadowRoot;
+    }
     return null;
   };
   const performDiff = () => {
     if (disposed) return;
-    const parent = getConnectedParent();
+    const isSSR = __fictIsSSR();
+    const parent = isSSR ? container.startMarker.parentNode : getConnectedParent();
     if (!parent) return;
-    batch2(() => {
+    batch(() => {
       const oldBlocks = container.blocks;
       const newBlocks = container.nextBlocks;
       const prevOrderedBlocks = container.orderedBlocks;
       const nextOrderedBlocks = container.nextOrderedBlocks;
       const orderedIndexByKey = container.orderedIndexByKey;
       const newItems = getItems();
+      if (initialHydrating && isHydratingActive()) {
+        initialHydrating = false;
+        newBlocks.clear();
+        nextOrderedBlocks.length = 0;
+        orderedIndexByKey.clear();
+        if (newItems.length === 0) {
+          oldBlocks.clear();
+          prevOrderedBlocks.length = 0;
+          container.currentNodes = [container.startMarker, container.endMarker];
+          container.nextNodes.length = 0;
+          return;
+        }
+        const createdBlocks2 = [];
+        withHydrationRange(
+          container.startMarker.nextSibling,
+          container.endMarker,
+          parent.ownerDocument ?? document,
+          () => {
+            for (let index = 0; index < newItems.length; index++) {
+              const item = newItems[index];
+              const key = keyFn(item, index);
+              if (newBlocks.has(key)) {
+                if (isDev) {
+                  console.warn(
+                    `[fict] Duplicate key "${String(key)}" detected in list hydration. Each item should have a unique key.`
+                  );
+                }
+                const existing = newBlocks.get(key);
+                if (existing) {
+                  destroyRoot(existing.root);
+                  removeNodes(existing.nodes);
+                }
+              }
+              const block = createKeyedBlock(key, item, index, renderItem, needsIndex, hostRoot);
+              createdBlocks2.push(block);
+              newBlocks.set(key, block);
+              orderedIndexByKey.set(key, nextOrderedBlocks.length);
+              nextOrderedBlocks.push(block);
+            }
+          }
+        );
+        container.blocks = newBlocks;
+        container.nextBlocks = oldBlocks;
+        container.orderedBlocks = nextOrderedBlocks;
+        container.nextOrderedBlocks = prevOrderedBlocks;
+        oldBlocks.clear();
+        prevOrderedBlocks.length = 0;
+        container.currentNodes = [container.startMarker, ...collectBetween(), container.endMarker];
+        container.nextNodes.length = 0;
+        for (const block of createdBlocks2) {
+          if (newBlocks.get(block.key) === block) {
+            flushOnMount(block.root);
+          }
+        }
+        return;
+      }
       if (newItems.length === 0) {
         if (oldBlocks.size > 0) {
           for (const block of oldBlocks.values()) {
@@ -798,7 +761,8 @@ function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
   };
   const ensureEffectStarted = () => {
     if (disposed || effectStarted) return effectStarted;
-    const parent = getConnectedParent();
+    const isSSR = __fictIsSSR();
+    const parent = isSSR ? container.startMarker.parentNode : getConnectedParent();
     if (!parent) return false;
     const start = () => {
       effectDispose = createRenderEffect(performDiff);
@@ -818,6 +782,8 @@ function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
   };
   const waitForConnection = () => {
     if (connectObserver || typeof MutationObserver === "undefined") return;
+    const root = container.startMarker.getRootNode?.() ?? document;
+    const shadowRoot = root && root.nodeType === 11 && isShadowRoot(root) ? root : null;
     connectObserver = new MutationObserver(() => {
       if (disposed) return;
       if (getConnectedParent()) {
@@ -828,6 +794,9 @@ function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
       }
     });
     connectObserver.observe(document, { childList: true, subtree: true });
+    if (shadowRoot) {
+      connectObserver.observe(shadowRoot, { childList: true, subtree: true });
+    }
   };
   const scheduleStart = () => {
     if (startScheduled || disposed || effectStarted) return;
@@ -880,14 +849,35 @@ export {
   SVGElements,
   SVGNamespace,
   UnitlessStyles,
+  __fictDisableResumable,
+  __fictDisableSSR,
+  __fictEnableResumable,
+  __fictEnableSSR,
+  __fictEnsureScope,
+  __fictEnterHydration,
+  __fictExitHydration,
+  __fictGetResume,
+  __fictGetSSRScope,
+  __fictGetScopeProps,
+  __fictGetScopeRegistry,
+  __fictIsHydrating,
+  __fictIsResumable,
+  __fictIsSSR,
   __fictPopContext,
+  __fictPrepareContext,
   __fictProp,
   __fictPropsRest,
   __fictPushContext,
+  __fictQrl,
+  __fictRegisterResume,
+  __fictRegisterScope,
   __fictRender,
   __fictResetContext,
+  __fictSerializeSSRState,
+  __fictSetSSRState,
   __fictUseContext,
   __fictUseEffect,
+  __fictUseLexicalScope,
   __fictUseMemo,
   __fictUseSignal,
   __resetReactiveState,
@@ -915,11 +905,16 @@ export {
   signal as createSignal,
   createStore,
   delegateEvents,
+  deserializeValue,
   getPropAlias,
+  getSlotEnd,
+  hydrateComponent,
   insert,
+  insertBetween,
   insertNodesBefore,
   isNodeBetweenMarkers,
   isReactive,
+  isStoreProxy,
   keyed,
   mergeProps,
   moveNodesBefore,
@@ -927,10 +922,14 @@ export {
   prop,
   reconcileArrays,
   removeNodes,
+  render,
+  resolvePath,
   runInScope,
+  serializeValue,
   spread,
   template,
   toNodeArray,
-  unwrap
+  unwrap,
+  unwrapStore
 };
 //# sourceMappingURL=internal.js.map