@solidjs/web 2.0.0-rc.3 → 2.0.0-rc.4

package/dist/web.js

@@ -1,4 +1,4 @@
-import { createRenderEffect, createMemo, sharedConfig, enableHydration, untrack, runWithOwner, createRoot, flatten, flush, createComponent, omit, createOwner, createSignal, onCleanup, getOwner, createEffect } from 'solid-js';
+import { createRenderEffect, createMemo, sharedConfig, enableHydration, untrack, runWithOwner, createRoot, flatten, flush, getOwner, createOwner, patchableRaw, storeHasOptimisticFamily, storeIsShallow, registerRowOps, registerSlotPatch, onCleanup, registerPatch, createComponent, omit, createSignal, createEffect } from 'solid-js';
 export { Errored, For, Hydration, Loading, Match, NoHydration, Repeat, Reveal, Show, Switch, createComponent, getOwner, merge as mergeProps, untrack } from 'solid-js';
 
 const DOMWithState = {
@@ -332,6 +332,10 @@ const waitAsset = promise => {
   }
   gate();
 };
+let listDriver;
+function installListDriver(driver) {
+  listDriver = driver;
+}
 const $$EVENT_OWNER = "_$SOLID_EVENT_OWNER";
 const INNER_OWNED = {};
 const delegatedEvents = new Set();
@@ -607,11 +611,6 @@ function ref(fn, element) {
   const resolved = untrack(fn);
   runWithOwner(null, () => applyRef(resolved, element));
 }
-const PURE_ROW = Symbol.for("solid.pure-row");
-function rowProof(fn) {
-  fn[PURE_ROW] = true;
-  return fn;
-}
 function scope(fn) {
   fn.$s = true;
   return fn;
@@ -675,16 +674,16 @@ function stripTextSeparators(nodes) {
   nodes.length = j;
   return nodes;
 }
-function patchDriver(subject, body) {
-  {
-    effect(() => body(subject, subject, false), () => body(subject, undefined, true));
-  }
-}
 function insert(parent, accessor, marker, initial, options) {
   const multi = marker !== undefined;
   const host = options && options.host;
   if (multi && !initial) initial = [];
   if (hydrationRt !== null) initial = hydrationRt.claimInitial(parent, multi, initial);
+  if (listDriver !== undefined && typeof accessor === "function" && accessor.$ll !== undefined) {
+    const listAccessor = accessor;
+    const owner = getOwner();
+    if (listDriver(parent, accessor, marker, () => runWithOwner(owner, () => insert(parent, () => listAccessor(), marker, marker !== undefined ? [] : undefined, options)))) return;
+  }
   if (typeof accessor !== "function") {
     accessor = normalize(accessor, initial, multi, true);
     if (typeof accessor !== "function") {
@@ -1160,6 +1159,15 @@ function hydrate(code, element, options = {}) {
   enableHydration();
   installHydrationRuntime();
   if (globalThis._$HY.done) return render(code, element, [...element.childNodes], options);
+  const head = (element.nodeType === 9 ? element : element.ownerDocument).head;
+  if (head && element.contains(head)) {
+    let n = head.firstChild;
+    while (n && n.nodeType === 1 && n.hasAttribute("data-dh") && !n.hasAttribute("data-dhf")) {
+      const next = n.nextSibling;
+      head.appendChild(n);
+      n = next;
+    }
+  }
   options.renderId ||= "";
   if (!globalThis._$HY.modules) globalThis._$HY.modules = {};
   if (!globalThis._$HY.loading) globalThis._$HY.loading = {};
@@ -1618,6 +1626,322 @@ function getHydrationKey() {
 }
 const RequestContext = Symbol();
 
+const PURE_ROW = Symbol.for("solid.pure-row");
+const arm = () => {
+  installListDriver(driveList);
+};
+function rowProof(fn) {
+  arm();
+  fn[PURE_ROW] = true;
+  return fn;
+}
+let rowCollector = null;
+const lisPositions = sources => {
+  const n = sources.length;
+  const tails = [];
+  const tailsIdx = [];
+  const prev = new Array(n).fill(-1);
+  for (let j = 0; j < n; j++) {
+    const v = sources[j];
+    if (v === -1) continue;
+    let lo = 0,
+      hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (tails[mid] < v) lo = mid + 1;else hi = mid;
+    }
+    if (lo > 0) prev[j] = tailsIdx[lo - 1];
+    tails[lo] = v;
+    tailsIdx[lo] = j;
+  }
+  const stable = new Set();
+  let k = tailsIdx.length ? tailsIdx[tails.length - 1] : -1;
+  while (k >= 0) {
+    stable.add(k);
+    k = prev[k];
+  }
+  return stable;
+};
+const driveList = (parent, listFn, marker, lateClassic) => {
+  const meta = listFn.$ll;
+  if (meta.row?.[PURE_ROW] !== true) return false;
+  if (typeof meta.keyed === "function") return false;
+  const evalOwner = createOwner({
+    id: "&each"
+  });
+  let subject = runWithOwner(evalOwner, () => untrack(meta.each));
+  evalOwner.dispose();
+  let raw = subject != null ? patchableRaw(subject) : undefined;
+  if (raw === undefined || !Array.isArray(raw)) return false;
+  const optimistic = storeHasOptimisticFamily(subject);
+  if (optimistic) raw = untrack(() => Array.from(subject));
+  const hydrating = !!sharedConfig.hydrating;
+  if (hydrating && raw.length === 0) return false;
+  let domRows;
+  let rowIds;
+  if (hydrating) {
+    if (marker !== undefined) return false;
+    domRows = Array.from(parent.children);
+    if (domRows.length !== raw.length) return false;
+    rowIds = new Array(raw.length);
+    for (let i = 0; i < domRows.length; i++) {
+      const key = domRows[i].getAttribute("_hk");
+      if (key === null || !key.endsWith("0") || key.length < 2) return false;
+      rowIds[i] = key.slice(0, -1);
+    }
+  }
+  const rowFn = meta.row;
+  const endAnchor = marker ?? null;
+  const shallow = storeIsShallow(subject);
+  let lastBodies = null;
+  let lastUnbinds = null;
+  const collectBind = (abs, build) => {
+    const prevC = rowCollector;
+    rowCollector = {
+      row: shallow ? subject[abs] : undefined,
+      bodies: [],
+      unbinds: []
+    };
+    try {
+      return build();
+    } finally {
+      lastBodies = rowCollector.bodies;
+      lastUnbinds = rowCollector.unbinds;
+      rowCollector = prevC;
+    }
+  };
+  const listOwner = createOwner();
+  let declined = false;
+  const bindRow = (abs, claimId) => {
+    return collectBind(abs, () => runWithOwner(listOwner, () => claimId !== undefined ? runWithOwner(createOwner({
+      id: claimId
+    }), () => untrack(() => rowFn(subject[abs]))) : untrack(() => rowFn(subject[abs]))));
+  };
+  let entries = new Array(raw.length);
+  let rowBodies = shallow ? new Array(raw.length) : null;
+  let rowUnbinds = new Array(raw.length);
+  const runUnbinds = list => {
+    if (list !== undefined) for (let u = 0; u < list.length; u++) list[u]();
+  };
+  const unbindAllRows = () => {
+    for (let j = 0; j < rowUnbinds.length; j++) runUnbinds(rowUnbinds[j]);
+    rowUnbinds = [];
+  };
+  let prevRaws = raw.slice();
+  try {
+    if (hydrating) {
+      for (let i = 0; i < raw.length; i++) {
+        entries[i] = bindRow(i, rowIds[i]);
+        if (rowBodies !== null) rowBodies[i] = lastBodies;
+        rowUnbinds[i] = lastUnbinds;
+      }
+    } else {
+      for (let i = 0; i < raw.length; i++) {
+        const node = bindRow(i);
+        entries[i] = node;
+        if (rowBodies !== null) rowBodies[i] = lastBodies;
+        rowUnbinds[i] = lastUnbinds;
+        parent.insertBefore(node, endAnchor);
+      }
+    }
+  } catch (err) {
+    unbindAllRows();
+    runUnbinds(lastUnbinds ?? undefined);
+    for (let j = 0; j < entries.length; j++) {
+      const n = entries[j];
+      if (n !== undefined && n.parentNode === parent) n.remove();
+    }
+    listOwner.dispose();
+    throw err;
+  }
+  const identityOps = nextArr => {
+    const keyOf = r => {
+      const w = r != null ? patchableRaw(r) : undefined;
+      return w !== undefined ? w : r;
+    };
+    const oldIndex = new Map();
+    for (let j = 0; j < prevRaws.length; j++) {
+      const k = keyOf(prevRaws[j]);
+      const existing = oldIndex.get(k);
+      if (existing === undefined) oldIndex.set(k, j);else if (Array.isArray(existing)) existing.push(j);else oldIndex.set(k, [existing, j]);
+    }
+    const sources = new Array(nextArr.length);
+    for (let k = 0; k < nextArr.length; k++) {
+      const m = oldIndex.get(keyOf(nextArr[k]));
+      if (m === undefined) sources[k] = -1;else if (Array.isArray(m)) {
+        sources[k] = m.shift();
+        if (m.length === 1) oldIndex.set(keyOf(nextArr[k]), m[0]);
+      } else {
+        sources[k] = m;
+        oldIndex.delete(keyOf(nextArr[k]));
+      }
+    }
+    return {
+      prefix: 0,
+      sources
+    };
+  };
+  let resyncNeeded = false;
+  const applyOps = (next, ops) => {
+    if (declined) return;
+    if (resyncNeeded) ops = null;
+    if (ops === null) ops = identityOps(next);
+    const {
+      prefix,
+      sources
+    } = ops;
+    const built = new Array(sources.length);
+    const builtBodies = rowBodies !== null ? new Array(sources.length) : null;
+    const builtUnbinds = new Array(sources.length);
+    let j = 0;
+    try {
+      for (; j < sources.length; j++) {
+        const abs = prefix + j;
+        const src = sources[j];
+        if (src === -1 || refRebuild && src >= 0 && next[abs] !== prevRaws[src]) {
+          built[j] = bindRow(abs);
+          if (builtBodies !== null) builtBodies[j] = lastBodies;
+          builtUnbinds[j] = lastUnbinds;
+        }
+      }
+    } catch (err) {
+      for (let k = 0; k < j; k++) runUnbinds(builtUnbinds[k]);
+      runUnbinds(lastUnbinds ?? undefined);
+      resyncNeeded = true;
+      throw err;
+    }
+    const retained = new Set();
+    for (let k = 0; k < sources.length; k++) {
+      if (sources[k] >= 0 && built[k] === undefined) retained.add(sources[k]);
+    }
+    for (let k = prefix; k < entries.length; k++) {
+      if (!retained.has(k)) {
+        entries[k].remove();
+        runUnbinds(rowUnbinds[k]);
+      }
+    }
+    const newEntries = new Array(prefix + sources.length);
+    const newBodies = rowBodies !== null ? new Array(prefix + sources.length) : null;
+    const newUnbinds = new Array(prefix + sources.length);
+    for (let i = 0; i < prefix; i++) {
+      newEntries[i] = entries[i];
+      if (newBodies !== null) newBodies[i] = rowBodies[i];
+      newUnbinds[i] = rowUnbinds[i];
+    }
+    const stable = lisPositions(sources);
+    let anchor = endAnchor;
+    for (let k = sources.length - 1; k >= 0; k--) {
+      const abs = prefix + k;
+      const src = sources[k];
+      let node;
+      if (built[k] !== undefined) {
+        node = built[k];
+        if (newBodies !== null) newBodies[abs] = builtBodies[k];
+        newUnbinds[abs] = builtUnbinds[k];
+        parent.insertBefore(node, anchor);
+      } else {
+        node = entries[src];
+        if (newBodies !== null) newBodies[abs] = rowBodies[src];
+        newUnbinds[abs] = rowUnbinds[src];
+        if (!stable.has(k)) parent.insertBefore(node, anchor);
+      }
+      newEntries[abs] = node;
+      anchor = node;
+    }
+    entries = newEntries;
+    if (newBodies !== null) rowBodies = newBodies;
+    rowUnbinds = newUnbinds;
+    prevRaws = next.slice();
+    resyncNeeded = false;
+  };
+  let unbindOps = runWithOwner(listOwner, () => registerRowOps(subject, applyOps));
+  const refRebuild = shallow && typeof meta.keyed !== "function";
+  const rebuildSlot = i => {
+    runUnbinds(rowUnbinds[i]);
+    const old = entries[i];
+    const node = bindRow(i);
+    rowBodies[i] = lastBodies;
+    rowUnbinds[i] = lastUnbinds;
+    parent.insertBefore(node, old);
+    old.remove();
+    entries[i] = node;
+  };
+  const applySlot = (i, next, prev) => {
+    if (declined) return;
+    if (resyncNeeded) {
+      const live = subject != null ? patchableRaw(subject) : undefined;
+      if (live !== undefined && Array.isArray(live)) applyOps(live, null);
+      return;
+    }
+    if (refRebuild) {
+      rebuildSlot(i);
+      prevRaws[i] = next;
+      return;
+    }
+    const bodies = rowBodies[i];
+    if (bodies !== undefined) {
+      for (let b = 0; b < bodies.length; b++) bodies[b](next, prev, false);
+    }
+    prevRaws[i] = next;
+  };
+  let unbindSlots = shallow ? runWithOwner(listOwner, () => registerSlotPatch(subject, applySlot)) : null;
+  runWithOwner(listOwner, () => effect(() => meta.each(), value => {
+    if (declined || value === subject) return;
+    const nextRaw = value != null ? patchableRaw(value) : undefined;
+    unbindOps();
+    unbindSlots?.();
+    if (nextRaw !== undefined && Array.isArray(nextRaw) && storeIsShallow(value) !== shallow) {
+      for (let j = 0; j < entries.length; j++) entries[j].remove();
+      entries = [];
+      prevRaws = [];
+      unbindAllRows();
+      subject = value;
+      declined = true;
+      listOwner.dispose();
+      lateClassic?.();
+      return;
+    }
+    if (nextRaw === undefined || !Array.isArray(nextRaw)) {
+      for (let j = 0; j < entries.length; j++) entries[j].remove();
+      entries = [];
+      prevRaws = [];
+      unbindAllRows();
+      subject = value;
+      declined = true;
+      listOwner.dispose();
+      lateClassic?.();
+      return;
+    }
+    const swapOps = identityOps(nextRaw);
+    subject = value;
+    unbindOps = runWithOwner(listOwner, () => registerRowOps(subject, applyOps));
+    if (shallow) unbindSlots = runWithOwner(listOwner, () => registerSlotPatch(subject, applySlot));
+    applyOps(nextRaw, swapOps);
+  }));
+  onCleanup(() => {
+    unbindOps();
+    unbindSlots?.();
+    unbindAllRows();
+    listOwner.dispose();
+  });
+  return true;
+};
+const patchDriver = (subject, body) => {
+  const raw = patchableRaw(subject);
+  if (raw !== undefined) {
+    if (!sharedConfig.hydrating) body(raw, undefined, true);
+    const unbind = registerPatch(subject, body);
+    if (rowCollector !== null) rowCollector.unbinds.push(unbind);
+    else onCleanup(unbind);
+  } else if (rowCollector !== null && subject === rowCollector.row) {
+    rowCollector.bodies.push(body);
+    if (!sharedConfig.hydrating) body(subject, undefined, true);
+  } else {
+    effect(() => body(subject, subject, false),
+    () => untrack(() => body(subject, undefined, true)));
+  }
+};
+
 function throwInBrowser(func) {
   const err = new Error(`${func.name} is not supported in the browser, returning undefined`);
   console.error(err);
@@ -1728,7 +2052,8 @@ function redirect(url, init = 302) {
   if (responseInit.status === undefined) {
     responseInit.status = 302;
   }
-  headers.set("Location", String(url));
+  const target = typeof url === "string" ? url : url[HREF];
+  headers.set("Location", typeof target === "string" ? target : String(url));
   return new Response(null, {
     ...responseInit,
     headers
@@ -1899,4 +2224,4 @@ _moduleUrl) {
 function httpStatus(_code, _text) {}
 function httpHeader(_name, _value, _options) {}
 
-export { ChildProperties, DOMElements, DOMWithState, DelegatedEvents, Dynamic, HREF, HydrationScript, MathMLElements, Namespaces, Portal, REVALIDATE_HEADER, RawTextElements, RequestContext, ResponseEnvelope, SAFE_ERROR, SVGElements, VoidElements, acquireAsset, addEvent, applyRef, assign, claimElement, claimElementTree, className, clearFlashCookie, clientOnly, commitEventResponse, composeMiddleware, createRequestEvent, createResponseStub, createSSRResponse, delegateEvents, dynamic, dynamicProperty, effect, escape, generateHydrationScript, getDelegatedRoot, getExpectedRedirectStatus, getFirstChild, getHydrationKey, getNextElement, getNextMarker, getNextMatch, getNextSibling, getRequestEvent, getServerFunctionMetadata, getServerFunctionRPC, hasFlashCookie, httpHeader, httpStatus, hydrate, insert, installHydrationRuntime, isDev, isHref, isResponseEnvelope, isSafeError, isServer, isServerFunction, markSafeError, memo, parseCookieHeader, patchDriver, redirect, ref, registerDelegatedContainer, registerDelegatedRoot, registerElementClaim, reload, render, renderToStream, renderToString, resolveSSRNode, respond, rowProof, runHydrationEvents, scope, serializeCookie, setAttribute, setAttributeNS, setProperty, setStyleProperty, spread, ssr, ssrAttribute, ssrClassName, ssrElement, ssrGroup, ssrHydrationKey, ssrStyle, ssrStyleProperty, style, template, unregisterDelegatedContainer, unregisterDelegatedRoot, useHead, waitAsset, warmAsset };
+export { ChildProperties, DOMElements, DOMWithState, DelegatedEvents, Dynamic, HREF, HydrationScript, MathMLElements, Namespaces, Portal, REVALIDATE_HEADER, RawTextElements, RequestContext, ResponseEnvelope, SAFE_ERROR, SVGElements, VoidElements, acquireAsset, addEvent, applyRef, assign, claimElement, claimElementTree, className, clearFlashCookie, clientOnly, commitEventResponse, composeMiddleware, createRequestEvent, createResponseStub, createSSRResponse, delegateEvents, driveList, dynamic, dynamicProperty, effect, escape, generateHydrationScript, getDelegatedRoot, getExpectedRedirectStatus, getFirstChild, getHydrationKey, getNextElement, getNextMarker, getNextMatch, getNextSibling, getRequestEvent, getServerFunctionMetadata, getServerFunctionRPC, hasFlashCookie, httpHeader, httpStatus, hydrate, insert, installHydrationRuntime, installListDriver, isDev, isHref, isResponseEnvelope, isSafeError, isServer, isServerFunction, listDriver, markSafeError, memo, parseCookieHeader, patchDriver, redirect, ref, registerDelegatedContainer, registerDelegatedRoot, registerElementClaim, reload, render, renderToStream, renderToString, resolveSSRNode, respond, rowProof, runHydrationEvents, scope, serializeCookie, setAttribute, setAttributeNS, setProperty, setStyleProperty, spread, ssr, ssrAttribute, ssrClassName, ssrElement, ssrGroup, ssrHydrationKey, ssrStyle, ssrStyleProperty, style, template, unregisterDelegatedContainer, unregisterDelegatedRoot, useHead, waitAsset, warmAsset };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@solidjs/web",
   "description": "Solid's web runtime: client rendering, hydration, SSR, and DOM-specific control flow (Portal, Dynamic).",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0-rc.4",
   "author": "Ryan Carniato",
   "license": "MIT",
   "homepage": "https://solidjs.com",
@@ -398,7 +398,7 @@
     "seroval-plugins": "~1.5.4"
   },
   "peerDependencies": {
-    "solid-js": "^2.0.0-rc.3"
+    "solid-js": "^2.0.0-rc.4"
   },
   "devDependencies": {
     "@codspeed/vitest-plugin": "^5.4.0",