octane 0.2.3 → 0.2.4

package/dist/cjs/runtime.server.cjs

@@ -136,6 +136,8 @@ __export(runtime_server_exports, {
   ssrValueAttr: () => ssrValueAttr,
   ssrVoidContent: () => ssrVoidContent,
   startTransition: () => startTransition,
+  styleMap: () => styleMap,
+  touchStyleMap: () => touchStyleMap,
   use: () => use,
   useActionState: () => useActionState,
   useCallback: () => useCallback,
@@ -1565,8 +1567,9 @@ function isAggregatedFormAttribute(tag, name) {
 function ssrAttrs(sources, tag, namespace = "html", skipFormControls = false) {
   namespace = resolveAttributeNamespace(namespace);
   const props = /* @__PURE__ */ new Map();
+  let classMerges = null;
   let sourceOrder = 0;
-  const record = (rawName, value) => {
+  function record(rawName, value) {
     if (typeof rawName !== "string") return;
     const order = sourceOrder++;
     const previous = props.get(rawName);
@@ -1576,9 +1579,17 @@ function ssrAttrs(sources, tag, namespace = "html", skipFormControls = false) {
       firstOrder: previous?.firstOrder ?? order,
       lastOrder: order
     });
-  };
-  for (const [isSpread, sourceOrName, directValue] of sources) {
+  }
+  for (const [isSpread, sourceOrName, directValue, merge] of sources) {
     if (!isSpread) {
+      if (merge === true && typeof sourceOrName === "string" && (sourceOrName === "class" || sourceOrName === "className")) {
+        (classMerges ??= []).push({
+          rawName: sourceOrName,
+          value: directValue,
+          order: sourceOrder++
+        });
+        continue;
+      }
       record(sourceOrName, directValue);
       continue;
     }
@@ -1590,6 +1601,24 @@ function ssrAttrs(sources, tag, namespace = "html", skipFormControls = false) {
       record(name, source[name]);
     }
   }
+  if (process.env.NODE_ENV === "production") {
+    let canonical = true;
+    for (const name of props.keys()) {
+      if (normalizeSsrAttributeName(name, tag, namespace) !== name || namespace === "html" && name.toLowerCase() !== name) {
+        canonical = false;
+        break;
+      }
+    }
+    if (canonical) {
+      let out2 = "";
+      for (const { rawName, value } of props.values()) {
+        if (rawName === "dangerouslySetInnerHTML" || skipFormControls && isAggregatedFormAttribute(tag, rawName))
+          continue;
+        out2 += ssrAttrEntry(rawName, value, tag, namespace);
+      }
+      return out2;
+    }
+  }
   const resolved = /* @__PURE__ */ new Map();
   let needsWinningOrderSort = false;
   for (const writer of props.values()) {
@@ -1616,6 +1645,24 @@ function ssrAttrs(sources, tag, namespace = "html", skipFormControls = false) {
       lastOrder
     ]);
   }
+  if (classMerges !== null) {
+    for (const extra of classMerges) {
+      const name = normalizeSsrAttributeName(extra.rawName, tag, namespace);
+      if (!import_constants.VALID_ATTR_NAME.test(name)) continue;
+      const identity = namespace === "html" ? name.toLowerCase() : name;
+      const previous = resolved.get(identity);
+      if (previous !== void 0) {
+        resolved.set(identity, [
+          previous[0],
+          (0, import_css.mergeClass)(previous[1], extra.value),
+          previous[2],
+          extra.order
+        ]);
+        continue;
+      }
+      resolved.set(identity, [name, extra.value, extra.order, extra.order]);
+    }
+  }
   let out = "";
   const ordered = [...resolved.values()];
   if (needsWinningOrderSort) ordered.sort((a, b) => a[2] - b[2]);
@@ -3654,6 +3701,28 @@ function isChildrenBlock(value) {
 function injectStyle(id, css, nonce) {
   if (CSS !== null) CSS.set(id, nonce === void 0 ? { css } : { css, nonce });
 }
+function styleMap(id, css, map, applied = []) {
+  let touching = false;
+  const touch = () => {
+    if (CSS === null || touching) return;
+    touching = true;
+    try {
+      for (const dependency of applied) touchStyleMap(dependency);
+      if (id !== null && css !== null) injectStyle(id, css);
+    } finally {
+      touching = false;
+    }
+  };
+  return new Proxy(map, {
+    get(target, key, receiver) {
+      touch();
+      return Reflect.get(target, key, receiver);
+    }
+  });
+}
+function touchStyleMap(map) {
+  if (map !== null && typeof map === "object") void map.$class;
+}
 const HEAD_VOID_ELEMENTS = /* @__PURE__ */ new Set(["meta", "link", "base"]);
 function ssrHeadEl(key, tag, attrs, text) {
   if (HEAD === null || FALLBACK_HOIST_DEPTH !== 0) return "";
@@ -5007,19 +5076,30 @@ async function runStream(component, props, options, sink, resolved) {
   };
   const injection = options?.injection;
   if (injection !== void 0) injection.done.then(NOOP, NOOP);
+  let injectionCompleted = false;
+  const completeInjection = injection === void 0 ? NOOP : () => {
+    if (injectionCompleted) return;
+    injectionCompleted = true;
+    injection.renderComplete?.();
+  };
   let injectionUnsubscribe;
   let injectionFailure;
   let injectionFailed = false;
+  const unacceptedInjection = injection === void 0 ? void 0 : [];
+  const rememberUnaccepted = injection === void 0 ? NOOP : (chunk) => {
+    unacceptedInjection.push(chunk);
+  };
   let signalInjectionFailure;
   const failInjection = (err) => {
+    if (signal?.aborted && err === signal.reason) return;
     if (injectionFailed) return;
     injectionFailed = true;
     injectionFailure = err;
     signalInjectionFailure?.();
   };
   let writeChain = injection === void 0 ? null : Promise.resolve();
-  const write = injection === void 0 ? (chunk, terminal) => sink.write(chunk, terminal) : (chunk, terminal) => {
-    const operation = writeChain.then(() => sink.write(chunk, terminal));
+  const write = injection === void 0 ? (chunk, terminal) => sink.write(chunk, terminal) : (chunk, terminal, onUnaccepted) => {
+    const operation = writeChain.then(() => sink.write(chunk, terminal, onUnaccepted));
     writeChain = operation.then(NOOP, NOOP);
     return operation;
   };
@@ -5033,11 +5113,34 @@ async function runStream(component, props, options, sink, resolved) {
       return;
     }
     if (!html) return;
-    return write(html);
+    return write(html, false, rememberUnaccepted);
+  };
+  const recoveryInjection = injection === void 0 ? void 0 : async () => {
+    if (signal?.aborted) {
+      await writeChain;
+      for (const html of unacceptedInjection) {
+        const replay = write(html, "recovery");
+        if (replay !== void 0) await replay;
+      }
+      unacceptedInjection.length = 0;
+    }
+    if (injectionFailed) return "";
+    let queued;
+    try {
+      queued = injection.take();
+    } catch {
+      return "";
+    }
+    if (queued !== "" && signal?.aborted) {
+      const replay = write(queued, "recovery");
+      if (replay !== void 0) await replay;
+      return "";
+    }
+    return queued;
   };
   const notifyInjection = () => {
     const drained = drainInjection();
-    if (drained !== void 0) drained.catch(NOOP);
+    if (drained !== void 0) drained.catch(failInjection);
   };
   const waitForInjectionDone = () => new Promise((resolve, reject) => {
     let settled = false;
@@ -5140,12 +5243,24 @@ async function runStream(component, props, options, sink, resolved) {
     }
     pruneStreamBoundariesAbsentFromShell(stream, shellBoundaryKeys);
   } catch (err) {
+    try {
+      completeInjection();
+    } catch {
+    }
     const reports = signal?.aborted ? Math.max(1, preShellSuspended.length) : 1;
     for (let i = 0; i < reports; i++) options?.onError?.(err);
     sink.shellError(err);
     return;
   }
-  reportRecoverableBoundaryErrors();
+  try {
+    reportRecoverableBoundaryErrors();
+  } catch (err) {
+    try {
+      completeInjection();
+    } catch {
+    }
+    throw err;
+  }
   if (pass.sheets !== null) for (const key of pass.sheets.keys()) flushedSheets.add(key);
   let leadingStyles = "";
   for (const [hash, sheet] of pass.cssEntries) {
@@ -5153,7 +5268,17 @@ async function runStream(component, props, options, sink, resolved) {
     leadingStyles += '<style data-octane="' + hash + '"' + (sheet.nonce === void 0 ? nonceAttr : ' nonce="' + escapeAttr(sheet.nonce) + '"') + ">" + escapeEntireInlineStyleContent(sheet.css) + "</style>";
   }
   const separateHead = options?.headChannel === "separate";
-  if (separateHead) options?.onHeadReady?.(pass.vtCandidates ? vtSsrStrip(pass.head) : pass.head);
+  if (separateHead) {
+    try {
+      options?.onHeadReady?.(pass.vtCandidates ? vtSsrStrip(pass.head) : pass.head);
+    } catch (err) {
+      try {
+        completeInjection();
+      } catch {
+      }
+      throw err;
+    }
+  }
   const shellHead = separateHead ? "" : pass.head;
   const documentRoot = isDocumentRoot(pass.body);
   let shell = documentRoot ? "<!DOCTYPE html>" : "";
@@ -5180,11 +5305,23 @@ async function runStream(component, props, options, sink, resolved) {
     const shellWrite = write(pass.vtCandidates ? vtSsrStrip(shell) : shell);
     if (shellWrite !== void 0) await shellWrite;
   } catch (err) {
+    try {
+      completeInjection();
+    } catch {
+    }
     options?.onError?.(err);
     sink.shellError(err);
     return;
   }
-  sink.shellReady();
+  try {
+    sink.shellReady();
+  } catch (err) {
+    try {
+      completeInjection();
+    } catch {
+    }
+    throw err;
+  }
   if (injection !== void 0) {
     try {
       injectionUnsubscribe = injection.subscribe(notifyInjection);
@@ -5274,14 +5411,14 @@ async function runStream(component, props, options, sink, resolved) {
       injectionUnsubscribe?.();
       injectionUnsubscribe = void 0;
       try {
-        injection.renderComplete?.();
+        completeInjection();
       } catch {
       }
     }
     let tail = "";
-    if (injection !== void 0 && !injectionFailed) {
+    if (recoveryInjection !== void 0) {
       try {
-        tail += injection.take();
+        tail = await recoveryInjection();
       } catch {
       }
     }
@@ -5301,7 +5438,7 @@ async function runStream(component, props, options, sink, resolved) {
   }
   if (injection !== void 0) {
     try {
-      injection.renderComplete?.();
+      completeInjection();
     } catch (err) {
       failInjection(err);
     }
@@ -5309,11 +5446,14 @@ async function runStream(component, props, options, sink, resolved) {
       await waitForInjectionDone();
       const finalDrain = drainInjection();
       if (finalDrain !== void 0) await finalDrain;
+      await writeChain;
       if (injectionFailed) throw injectionFailure;
       if (heldDocumentTail !== "") {
         const tailChunk = heldDocumentTail;
         heldDocumentTail = "";
-        const tailWrite = write(tailChunk);
+        const tailWrite = write(tailChunk, false, (unaccepted) => {
+          heldDocumentTail = unaccepted;
+        });
         if (tailWrite !== void 0) await tailWrite;
       }
     } catch (err) {
@@ -5321,11 +5461,9 @@ async function runStream(component, props, options, sink, resolved) {
       injectionUnsubscribe?.();
       injectionUnsubscribe = void 0;
       let terminal = "";
-      if (!injectionFailed) {
-        try {
-          terminal = injection.take();
-        } catch {
-        }
+      try {
+        terminal = await recoveryInjection();
+      } catch {
       }
       terminal += heldDocumentTail;
       if (terminal !== "") {
@@ -5390,7 +5528,8 @@ function renderToPipeableStream(entryComponent, props, options) {
       destinationFailure(err);
     }
   };
-  const waitForDrain = (dest) => {
+  const waitForDrain = (dest, allowAborted = false) => {
+    if (allowAborted && closed) return Promise.reject(new Error((0, import_error_codes_server_generated.formatServerError)(38)));
     if (dest.once === void 0) {
       return Promise.reject(new TypeError((0, import_error_codes_server_generated.formatServerError)(39)));
     }
@@ -5426,14 +5565,17 @@ function renderToPipeableStream(entryComponent, props, options) {
       dest.once("drain", onDrain);
       dest.once("error", onError);
       dest.once("close", onClose);
-      if (controller.signal.aborted) onAbort();
-      else controller.signal.addEventListener("abort", onAbort, { once: true });
+      if (!allowAborted) {
+        if (controller.signal.aborted) onAbort();
+        else controller.signal.addEventListener("abort", onAbort, { once: true });
+      }
     });
   };
-  const writeNow = (chunk, terminal) => {
+  const writeNow = (chunk, terminal, onUnaccepted) => {
     const dest = destination;
     if (closed) return Promise.reject(new Error((0, import_error_codes_server_generated.formatServerError)(40)));
-    if (!terminal && controller.signal.aborted) {
+    if (terminal === false && controller.signal.aborted) {
+      onUnaccepted?.(chunk);
       return Promise.reject(controller.signal.reason);
     }
     let accepted;
@@ -5443,7 +5585,7 @@ function renderToPipeableStream(entryComponent, props, options) {
       destinationFailure(err);
       return Promise.reject(err);
     }
-    return accepted === false && !terminal ? waitForDrain(dest) : void 0;
+    return accepted === false && terminal !== true ? waitForDrain(dest, terminal === "recovery") : void 0;
   };
   const trackWrite = (operation) => {
     const gate = operation.then(
@@ -5464,16 +5606,18 @@ function renderToPipeableStream(entryComponent, props, options) {
     });
     return operation;
   };
-  const queueWrite = (chunk, terminal = false) => {
+  const queueWrite = (chunk, terminal = false, onUnaccepted) => {
     if (destination === null) {
-      buffered.push({ chunk, terminal });
+      buffered.push(
+        onUnaccepted === void 0 ? { chunk, terminal } : { chunk, terminal, onUnaccepted }
+      );
       return;
     }
     if (writeGate !== null) {
-      const operation2 = writeGate.then(() => writeNow(chunk, terminal));
+      const operation2 = writeGate.then(() => writeNow(chunk, terminal, onUnaccepted));
       return trackWrite(operation2);
     }
-    const operation = writeNow(chunk, terminal);
+    const operation = writeNow(chunk, terminal, onUnaccepted);
     return operation === void 0 ? void 0 : trackWrite(operation);
   };
   const flushEnd = () => {
@@ -5493,8 +5637,8 @@ function renderToPipeableStream(entryComponent, props, options) {
       props,
       renderOptions,
       {
-        write(chunk, terminal) {
-          return queueWrite(chunk, terminal);
+        write(chunk, terminal, onUnaccepted) {
+          return queueWrite(chunk, terminal, onUnaccepted);
         },
         shellReady() {
           options?.onShellReady?.();
@@ -5538,7 +5682,11 @@ function renderToPipeableStream(entryComponent, props, options) {
         });
       }
       for (const item of buffered) {
-        queueWrite(item.chunk, item.terminal || controller.signal.aborted);
+        queueWrite(
+          item.chunk,
+          item.terminal === "recovery" ? "recovery" : item.terminal || controller.signal.aborted,
+          item.onUnaccepted
+        );
       }
       buffered.length = 0;
       finishEnd();
@@ -5604,7 +5752,10 @@ function renderToReadableStream(entryComponent, props, options) {
     });
     stream.allReady = allReady;
     let shellDone = false;
-    const waitForDemand = () => new Promise((resolve, reject) => {
+    let terminal = false;
+    let released = false;
+    let callbackFailure;
+    const waitForDemand = (allowAborted = false) => new Promise((resolve, reject) => {
       let settled = false;
       const cleanup = () => {
         renderController.signal.removeEventListener("abort", onAbort);
@@ -5619,18 +5770,21 @@ function renderToReadableStream(entryComponent, props, options) {
       const onDemand = () => finish(resolve);
       const onAbort = () => finish(() => reject(renderController.signal.reason));
       wakeDemand = onDemand;
-      if (renderController.signal.aborted) onAbort();
-      else renderController.signal.addEventListener("abort", onAbort, { once: true });
+      if (!allowAborted) {
+        if (renderController.signal.aborted) onAbort();
+        else renderController.signal.addEventListener("abort", onAbort, { once: true });
+      }
     });
-    const writeReadable = (chunk, terminal = false) => {
+    const writeReadable = (chunk, terminal2 = false, onUnaccepted) => {
       if (closed || consumerCancelled) {
         return Promise.reject(cancelReason ?? new Error((0, import_error_codes_server_generated.formatServerError)(44)));
       }
-      if (!terminal && renderController.signal.aborted) {
+      if (terminal2 === false && renderController.signal.aborted) {
+        onUnaccepted?.(chunk);
         return Promise.reject(renderController.signal.reason);
       }
       const bytes = encoder.encode(chunk);
-      if (terminal) {
+      if (terminal2 === true) {
         readableController.enqueue(bytes);
         return;
       }
@@ -5639,13 +5793,18 @@ function renderToReadableStream(entryComponent, props, options) {
         return;
       }
       return (async () => {
-        while ((readableController.desiredSize ?? 0) <= 0) {
-          await waitForDemand();
-          if (closed || consumerCancelled) {
-            throw cancelReason ?? new Error((0, import_error_codes_server_generated.formatServerError)(44));
+        try {
+          while ((readableController.desiredSize ?? 0) <= 0) {
+            await waitForDemand(terminal2 === "recovery");
+            if (closed || consumerCancelled) {
+              throw cancelReason ?? new Error((0, import_error_codes_server_generated.formatServerError)(44));
+            }
           }
+          readableController.enqueue(bytes);
+        } catch (err) {
+          if (!consumerCancelled && renderController.signal.aborted) onUnaccepted?.(chunk);
+          throw err;
         }
-        readableController.enqueue(bytes);
       })();
     };
     const closeReadable = () => {
@@ -5659,46 +5818,80 @@ function renderToReadableStream(entryComponent, props, options) {
       }
     };
     const renderOptions = { ...options, signal: renderController.signal };
+    if (options?.onError !== void 0) {
+      renderOptions.onError = (error) => {
+        try {
+          options.onError(error);
+        } catch (err) {
+          callbackFailure ??= { error: err };
+        }
+      };
+    }
     const resolved = newResolvedMap(renderOptions);
+    const release = () => {
+      if (released) return;
+      released = true;
+      releaseServerRenderResources(resolved);
+    };
+    const settleFailure = (error) => {
+      if (terminal) return;
+      terminal = true;
+      try {
+        release();
+      } catch (err) {
+        error = err;
+      }
+      const reason = callbackFailure === void 0 ? error : callbackFailure.error;
+      if (!shellDone) rejectShell(reason);
+      allReadyReject(reason);
+      closeReadable();
+    };
     runStream(
       component,
       props,
       renderOptions,
       {
-        write(chunk, terminal) {
-          return writeReadable(chunk, terminal);
+        write(chunk, terminal2, onUnaccepted) {
+          return writeReadable(chunk, terminal2, onUnaccepted);
         },
         shellReady() {
-          shellDone = true;
           options?.onShellReady?.();
+          shellDone = true;
           resolveShell(stream);
         },
         shellError(err) {
-          releaseServerRenderResources(resolved);
-          options?.onShellError?.(err);
-          if (!shellDone) rejectShell(err);
-          allReadyReject(err);
-          closeReadable();
+          try {
+            release();
+            options?.onShellError?.(err);
+          } catch (callbackError) {
+            settleFailure(callbackError);
+            return;
+          }
+          settleFailure(err);
         },
         allReady() {
-          releaseServerRenderResources(resolved);
-          options?.onAllReady?.();
-          allReadyResolve();
+          if (terminal) return;
+          try {
+            release();
+            options?.onAllReady?.();
+          } catch (err) {
+            renderOptions.onError?.(err);
+            settleFailure(err);
+            return;
+          }
+          terminal = true;
+          if (callbackFailure === void 0) allReadyResolve();
+          else allReadyReject(callbackFailure.error);
           closeReadable();
         },
         fatal(err) {
-          releaseServerRenderResources(resolved);
-          allReadyReject(err);
-          closeReadable();
+          settleFailure(err);
         }
       },
       resolved
     ).catch((err) => {
-      releaseServerRenderResources(resolved);
-      options?.onError?.(err);
-      if (!shellDone) rejectShell(err);
-      allReadyReject(err);
-      closeReadable();
+      renderOptions.onError?.(err);
+      settleFailure(err);
     });
   });
 }
@@ -6088,6 +6281,8 @@ function preinitModule(href, options) {
   ssrValueAttr,
   ssrVoidContent,
   startTransition,
+  styleMap,
+  touchStyleMap,
   use,
   useActionState,
   useCallback,

package/dist/cjs/server/index.cjs

@@ -123,7 +123,9 @@ __export(server_exports, {
   ssrValueAttr: () => import_runtime_server.ssrValueAttr,
   ssrVoidContent: () => import_runtime_server.ssrVoidContent,
   startTransition: () => import_runtime_server.startTransition,
+  styleMap: () => import_runtime_server.styleMap,
   subSlot: () => import_sub_slot.subSlot,
+  touchStyleMap: () => import_runtime_server.touchStyleMap,
   unstable_Activity: () => import_runtime_server.Activity,
   unstable_ViewTransition: () => import_runtime_server.ViewTransition,
   unstable_addTransitionType: () => import_runtime_server.addTransitionType,
@@ -269,7 +271,9 @@ var import_runtime_server = require("../runtime.server.cjs");
   ssrValueAttr,
   ssrVoidContent,
   startTransition,
+  styleMap,
   subSlot,
+  touchStyleMap,
   unstable_Activity,
   unstable_ViewTransition,
   unstable_addTransitionType,

package/dist/cjs/version.cjs

@@ -21,7 +21,7 @@ __export(version_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(version_exports);
-const version = "0.2.3";
+const version = "0.2.4";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version

package/dist/compiler/bundler.js

@@ -471,6 +471,13 @@ export function findDescriptorChildrenImports(source, id) {
 		if (jsxBindings.has(local)) candidates.push({ ...imported, local });
 	}
 	for (const node of ast.body || []) {
+		if (node.type === 'ExportDefaultDeclaration') {
+			if (node.declaration?.type === 'Identifier') {
+				const imported = importedBindings.get(node.declaration.name);
+				if (imported !== undefined) candidates.push({ ...imported, exported: 'default' });
+			}
+			continue;
+		}
 		if (node.type !== 'ExportNamedDeclaration') continue;
 		for (const specifier of node.specifiers || []) {
 			const exported = specifier.exported?.name ?? specifier.exported?.value;