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

package/dist/dev.cjs

@@ -215,7 +215,8 @@ function resourceIdentity(tag, props) {
   let id = "res:" + tag + ":" + (props.rel || "") + ":" + (props.href || props.src || "");
   for (let i = 0; i < RESOURCE_QUALIFIERS.length; i++) {
     const q = RESOURCE_QUALIFIERS[i];
-    if (props[q] != null) id += ":" + q + "=" + props[q];
+    const value = props[q];
+    if (value != null) id += ":" + q + "=" + (value === true ? "" : value);
   }
   return id;
 }
@@ -288,6 +289,7 @@ function decodeSafe(text) {
   }
 }
 function serializeCookie(name, value, options = {}) {
+  assertServableCookie(name, options);
   let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
   cookie += `; Path=${options.path === undefined ? "/" : options.path}`;
   if (options.domain) cookie += `; Domain=${options.domain}`;
@@ -295,12 +297,32 @@ function serializeCookie(name, value, options = {}) {
   if (options.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
   if (options.httpOnly) cookie += "; HttpOnly";
   if (options.secure) cookie += "; Secure";
+  if (options.partitioned) cookie += "; Partitioned";
   if (options.sameSite) {
     const sameSite = options.sameSite.toLowerCase();
     cookie += `; SameSite=${sameSite === "none" ? "None" : sameSite === "strict" ? "Strict" : "Lax"}`;
   }
   return cookie;
 }
+function assertServableCookie(name, options) {
+  const reject = reason => {
+    throw new Error(`serializeCookie: every browser silently rejects this cookie — ${reason}. ` + `It would never come back on a request, with no error anywhere.`);
+  };
+  const lower = name.toLowerCase();
+  if (lower.startsWith("__host-")) {
+    if (!options.secure) reject(`the __Host- prefix on \`${name}\` requires \`secure: true\``);
+    if (options.path !== undefined && options.path !== "/") reject(`the __Host- prefix on \`${name}\` requires \`Path=/\` (got \`${options.path}\`) — ` + `host-locking is the prefix's whole contract, so it cannot be path-scoped`);
+    if (options.domain) reject(`the __Host- prefix on \`${name}\` forbids \`Domain\` (got \`${options.domain}\`)`);
+  } else if (lower.startsWith("__secure-") && !options.secure) {
+    reject(`the __Secure- prefix on \`${name}\` requires \`secure: true\``);
+  }
+  if (options.sameSite && options.sameSite.toLowerCase() === "none" && !options.secure) {
+    reject("`SameSite=None` requires `secure: true`");
+  }
+  if (options.partitioned && !options.secure) {
+    reject("`Partitioned` requires `secure: true`");
+  }
+}
 const FLASH_COOKIE = "flash";
 const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
 function hasFlashCookie(cookieHeader) {
@@ -334,6 +356,10 @@ const waitAsset = promise => {
   }
   gate();
 };
+exports.listDriver = void 0;
+function installListDriver(driver) {
+  exports.listDriver = driver;
+}
 const $$EVENT_OWNER = "_$SOLID_EVENT_OWNER";
 const INNER_OWNED = {};
 const delegatedEvents = new Set();
@@ -585,16 +611,18 @@ function setStyleProperty(node, name, value) {
 }
 function spread(node, props = {}, skipChildren) {
   const prevProps = {};
-  if (!skipChildren) insert(node, () => props.children);
+  const get = typeof props === "function" ? props : () => props;
+  if (!skipChildren) insert(node, () => get().children);
   effect(() => {
-    const r = props.ref;
+    const r = get().ref;
     (typeof r === "function" || Array.isArray(r)) && ref(() => r, node);
   }, () => {});
   effect(() => {
+    const source = get();
     const newProps = {};
-    for (const prop in props) {
+    for (const prop in source) {
       if (prop === "children" || prop === "ref") continue;
-      newProps[prop] = props[prop];
+      newProps[prop] = source[prop];
     }
     return newProps;
   }, props => assign(node, props, true, prevProps, true));
@@ -617,11 +645,6 @@ function ref(fn, element) {
   const resolved = solidJs.untrack(fn);
   solidJs.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;
@@ -685,16 +708,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 (exports.listDriver !== undefined && typeof accessor === "function" && accessor.$ll !== undefined) {
+    const listAccessor = accessor;
+    const owner = solidJs.getOwner();
+    if (exports.listDriver(parent, accessor, marker, () => solidJs.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") {
@@ -1173,6 +1196,15 @@ function hydrate(code, element, options = {}) {
   solidJs.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 = {};
@@ -1686,6 +1718,331 @@ 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 = solidJs.createOwner({
+    id: "&each"
+  });
+  let subject = solidJs.runWithOwner(evalOwner, () => solidJs.untrack(meta.each));
+  evalOwner.dispose();
+  let raw = subject != null ? solidJs.patchableRaw(subject) : undefined;
+  if (raw === undefined || !Array.isArray(raw)) return false;
+  const optimistic = solidJs.storeHasOptimisticFamily(subject);
+  if (optimistic) raw = solidJs.untrack(() => Array.from(subject));
+  const hydrating = !!solidJs.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 = solidJs.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 = solidJs.createOwner();
+  let declined = false;
+  const bindRow = (abs, claimId) => {
+    {
+      const o = listOwner;
+      const prevChild = o._firstChild;
+      const prevDisposal = o._disposal;
+      const node = collectBind(abs, () => solidJs.runWithOwner(listOwner, () => claimId !== undefined ? solidJs.runWithOwner(solidJs.createOwner({
+        id: claimId
+      }), () => solidJs.untrack(() => rowFn(subject[abs]))) : solidJs.untrack(() => rowFn(subject[abs]))));
+      if (o._firstChild !== prevChild || o._disposal !== prevDisposal) {
+        console.warn("A patch-mode list row created reactive computations or cleanups " + "during build (likely a handler/attribute value expression calling " + "createEffect/onCleanup). This work attaches to the LIST, not the " + "row, and will not dispose when the row is removed. Move owned " + "work into effects/refs (which opt the row out of patch mode).");
+      }
+      return node;
+    }
+  };
+  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 ? solidJs.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 = solidJs.runWithOwner(listOwner, () => solidJs.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 ? solidJs.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 ? solidJs.runWithOwner(listOwner, () => solidJs.registerSlotPatch(subject, applySlot)) : null;
+  solidJs.runWithOwner(listOwner, () => effect(() => meta.each(), value => {
+    if (declined || value === subject) return;
+    const nextRaw = value != null ? solidJs.patchableRaw(value) : undefined;
+    unbindOps();
+    unbindSlots?.();
+    if (nextRaw !== undefined && Array.isArray(nextRaw) && solidJs.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 = solidJs.runWithOwner(listOwner, () => solidJs.registerRowOps(subject, applyOps));
+    if (shallow) unbindSlots = solidJs.runWithOwner(listOwner, () => solidJs.registerSlotPatch(subject, applySlot));
+    applyOps(nextRaw, swapOps);
+  }));
+  solidJs.onCleanup(() => {
+    unbindOps();
+    unbindSlots?.();
+    unbindAllRows();
+    listOwner.dispose();
+  });
+  return true;
+};
+const patchDriver = (subject, body) => {
+  const raw = solidJs.patchableRaw(subject);
+  if (raw !== undefined) {
+    if (!solidJs.sharedConfig.hydrating) body(raw, undefined, true);
+    const unbind = solidJs.registerPatch(subject, body);
+    if (rowCollector !== null) rowCollector.unbinds.push(unbind);
+    else solidJs.onCleanup(unbind);
+  } else if (rowCollector !== null && subject === rowCollector.row) {
+    rowCollector.bodies.push(body);
+    if (!solidJs.sharedConfig.hydrating) body(subject, undefined, true);
+  } else {
+    effect(() => body(subject, subject, false),
+    () => solidJs.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);
@@ -1759,6 +2116,7 @@ function isSafeError(value) {
   return !!(value && (typeof value === "object" || typeof value === "function") && value[SAFE_ERROR]);
 }
 const REVALIDATE_HEADER = "X-Revalidate";
+const RESPONSE_HEADER_VALUE_LIMIT = 4096;
 function initWithRevalidate(init = {}) {
   const resolved = typeof init === "number" ? {
     status: init
@@ -1779,7 +2137,13 @@ function initWithRevalidate(init = {}) {
   } else {
     headers = new Headers(responseInit.headers);
   }
-  revalidate !== undefined && headers.set(REVALIDATE_HEADER, revalidate.toString());
+  if (revalidate !== undefined) {
+    const keys = revalidate.toString();
+    if (keys.length > RESPONSE_HEADER_VALUE_LIMIT) {
+      throw new TypeError(`revalidate names ${keys.length} characters of cache keys; past ` + `${RESPONSE_HEADER_VALUE_LIMIT} the ${REVALIDATE_HEADER} header would overflow ` + `receivers (an 8 KiB proxy buffer holds the whole header block) and the response ` + `dies at the socket after the mutation committed. Split the invalidation across ` + `calls or use coarser keys — a dropped key would be a silently stale cache, so ` + `the runtime refuses rather than trims.`);
+    }
+    headers.set(REVALIDATE_HEADER, keys);
+  }
   return {
     responseInit,
     headers
@@ -1796,7 +2160,13 @@ 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];
+  const location = typeof target === "string" ? target : String(url);
+  const encoded = location.replace(/[^\x00-\x7f]/gu, encodeURIComponent);
+  if (encoded.length > RESPONSE_HEADER_VALUE_LIMIT) {
+    throw new TypeError(`redirect() target is ${encoded.length} characters; past ` + `${RESPONSE_HEADER_VALUE_LIMIT} the Location header (and the scripted transport's ` + `redirect header) would overflow receivers and the response dies at the socket. ` + `A target this size is usually unbounded input echoed into the url — carry the ` + `state server-side instead. Refused rather than trimmed: a cut target is a ` + `different address.`);
+  }
+  headers.set("Location", encoded);
   return new Response(null, {
     ...responseInit,
     headers
@@ -1812,11 +2182,18 @@ function reload(init = {}) {
     headers
   });
 }
+const NULL_BODY_STATUSES = new Set([204, 205, 304]);
 function respond(value, init = {}) {
   const {
     responseInit,
     headers
   } = initWithRevalidate(init);
+  if (NULL_BODY_STATUSES.has(responseInit.status)) {
+    return new ResponseEnvelope(new Response(null, {
+      ...responseInit,
+      headers
+    }), value);
+  }
   headers.set("Content-Type", "application/json");
   return new ResponseEnvelope(new Response(JSON.stringify(value), {
     ...responseInit,
@@ -2034,8 +2411,10 @@ exports.Dynamic = Dynamic;
 exports.HREF = HREF;
 exports.HydrationScript = HydrationScript;
 exports.MathMLElements = MathMLElements;
+exports.NULL_BODY_STATUSES = NULL_BODY_STATUSES;
 exports.Namespaces = Namespaces;
 exports.Portal = Portal;
+exports.RESPONSE_HEADER_VALUE_LIMIT = RESPONSE_HEADER_VALUE_LIMIT;
 exports.REVALIDATE_HEADER = REVALIDATE_HEADER;
 exports.RawTextElements = RawTextElements;
 exports.RequestContext = RequestContext;
@@ -2058,6 +2437,7 @@ exports.createRequestEvent = createRequestEvent;
 exports.createResponseStub = createResponseStub;
 exports.createSSRResponse = createSSRResponse;
 exports.delegateEvents = delegateEvents;
+exports.driveList = driveList;
 exports.dynamic = dynamic;
 exports.dynamicProperty = dynamicProperty;
 exports.effect = effect;
@@ -2080,6 +2460,7 @@ exports.httpStatus = httpStatus;
 exports.hydrate = hydrate;
 exports.insert = insert;
 exports.installHydrationRuntime = installHydrationRuntime;
+exports.installListDriver = installListDriver;
 exports.isDev = isDev;
 exports.isHref = isHref;
 exports.isResponseEnvelope = isResponseEnvelope;