@absolutejs/absolute 0.19.0-beta.1022 → 0.19.0-beta.1024

package/dist/cli/config/server.js

@@ -35275,7 +35275,6 @@ var ensureConfigCert = (host) => {
 };
 // src/constants.ts
 var BASE_36_RADIX = 36;
-var BYTES_PER_KILOBYTE = 1024;
 var CONFIG_DEFAULT_HOST = "config.absolute.localhost";
 var CONFIG_DEFAULT_PORT = 4099;
 var HTTP_STATUS_BAD_REQUEST = 400;
@@ -35410,61 +35409,69 @@ var pipeStreamWithHeadInjection = (stream, markup) => {
 var pipeStreamWithIslandMarkerDetection = (stream, markup) => {
   const encoder = new TextEncoder;
   const decoder = new TextDecoder;
-  const lookbehind = Math.max(ISLAND_MARKER.length, BYTES_PER_KILOBYTE);
-  const processPending = (controller, pending, injected) => {
-    if (injected) {
-      controller.enqueue(encoder.encode(pending));
-      return { injected, pending: "" };
+  const headLookbehind = CLOSING_HEAD_TAG.length - 1;
+  const enqueue = (controller, text) => {
+    if (text.length > 0) {
+      controller.enqueue(encoder.encode(text));
     }
-    const markerIndex = pending.indexOf(ISLAND_MARKER);
-    if (markerIndex >= 0) {
-      const tagStart = pending.lastIndexOf("<", markerIndex);
-      const injectAt = tagStart >= 0 ? tagStart : markerIndex;
-      const next = `${pending.slice(0, injectAt)}${markup}${pending.slice(injectAt)}`;
-      controller.enqueue(encoder.encode(next));
-      return { injected: true, pending: "" };
+  };
+  const processHolding = (controller, held) => {
+    if (!held.includes(ISLAND_MARKER)) {
+      return { held, injected: false, pending: "", sawHead: true };
     }
-    return {
-      injected,
-      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
-    };
+    enqueue(controller, `${markup}${held}`);
+    return { held: "", injected: true, pending: "", sawHead: true };
   };
-  const finishIslandMarkerStream = (controller, pending) => {
-    const finalPending = pending + decoder.decode();
-    if (finalPending.length > 0) {
-      controller.enqueue(encoder.encode(finalPending));
+  const processHead = (controller, pending) => {
+    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
+    if (headIndex < 0) {
+      return {
+        held: "",
+        injected: false,
+        pending: flushSafePendingText(controller, encoder, pending, headLookbehind),
+        sawHead: false
+      };
     }
-    controller.close();
+    enqueue(controller, pending.slice(0, headIndex));
+    return processHolding(controller, pending.slice(headIndex));
   };
-  const consumeIslandChunk = async (controller, reader, pending, injected) => {
-    const { done, value } = await readStreamChunk(reader);
-    if (done || !value) {
-      return { done, injected, pending };
+  const processChunk = (controller, state, chunk) => {
+    if (state.injected) {
+      enqueue(controller, chunk);
+      return state;
     }
-    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
-    return {
-      done,
-      injected: processed.injected,
-      pending: processed.pending
-    };
+    if (!state.sawHead) {
+      return processHead(controller, state.pending + chunk);
+    }
+    return processHolding(controller, state.held + chunk);
   };
-  const runIslandMarkerLoop = async (controller, reader) => {
-    const consumeNextIslandChunk = async (injected, pending) => {
-      const consumed = await consumeIslandChunk(controller, reader, pending, injected);
-      const nextState = updateInjectedState(consumed, injected, pending);
-      if (nextState.done) {
-        return { injected, pending };
+  const finishMarkerStream = (controller, state) => {
+    const tail = decoder.decode();
+    const remainder = state.injected ? tail : (state.sawHead ? state.held : state.pending) + tail;
+    enqueue(controller, remainder);
+    controller.close();
+  };
+  const runMarkerLoop = (controller, reader) => {
+    const consumeNext = async (state) => {
+      const { done, value } = await readStreamChunk(reader);
+      if (done || !value) {
+        return state;
       }
-      return consumeNextIslandChunk(nextState.injected, nextState.pending);
+      return consumeNext(processChunk(controller, state, streamChunkToString(value, decoder)));
     };
-    return consumeNextIslandChunk(false, "");
+    return consumeNext({
+      held: "",
+      injected: false,
+      pending: "",
+      sawHead: false
+    });
   };
   return new ReadableStream({
     async start(controller) {
       const reader = stream.getReader();
       try {
-        const { pending } = await runIslandMarkerLoop(controller, reader);
-        finishIslandMarkerStream(controller, pending);
+        const finalState = await runMarkerLoop(controller, reader);
+        finishMarkerStream(controller, finalState);
       } catch (error) {
         controller.error(error);
       }

package/dist/client/index.js

@@ -259,12 +259,20 @@ __export(exports_react, {
 });
 import { createElement } from "react";
 import { hydrateRoot } from "react-dom/client";
-var reactIslandRoots, isPropsRecord = (value) => typeof value === "object" && value !== null, isReactComponent = (value) => typeof value === "function", hydrateReactIsland = (component, element, props) => {
+var reactIslandRoots, isPropsRecord = (value) => typeof value === "object" && value !== null, HOST_REACT_EXPANDO_PREFIXES, detachFromHostReactRoot = (element) => {
+  for (const key of Object.keys(element)) {
+    const isHostExpando = HOST_REACT_EXPANDO_PREFIXES.some((prefix) => key.startsWith(prefix));
+    if (!isHostExpando)
+      continue;
+    Reflect.deleteProperty(element, key);
+  }
+}, isReactComponent = (value) => typeof value === "function", hydrateReactIsland = (component, element, props) => {
   const existingRoot = reactIslandRoots.get(element);
   if (existingRoot) {
     existingRoot.render(isPropsRecord(props) ? createElement(component, props) : createElement(component));
     return;
   }
+  detachFromHostReactRoot(element);
   if (!isPropsRecord(props)) {
     reactIslandRoots.set(element, hydrateRoot(element, createElement(component)));
     return;
@@ -273,6 +281,14 @@ var reactIslandRoots, isPropsRecord = (value) => typeof value === "object" && va
 };
 var init_react = __esm(() => {
   reactIslandRoots = new WeakMap;
+  HOST_REACT_EXPANDO_PREFIXES = [
+    "__reactFiber$",
+    "__reactProps$",
+    "__reactContainer$",
+    "__reactEvents$",
+    "__reactListeners$",
+    "__reactHandles$"
+  ];
 });
 
 // src/client/hydrators/svelte.ts
@@ -524,9 +540,12 @@ var initDominoAdapter = (platformServer) => {
   return {
     APP_BASE_HREF: common.APP_BASE_HREF,
     bootstrapApplication: platformBrowser.bootstrapApplication,
+    Component: core.Component,
     DomSanitizer: platformBrowser.DomSanitizer,
     ENVIRONMENT_INITIALIZER: core.ENVIRONMENT_INITIALIZER,
     inject: core.inject,
+    InjectionToken: core.InjectionToken,
+    NgComponentOutlet: common.NgComponentOutlet,
     provideClientHydration: platformBrowser.provideClientHydration,
     provideServerRendering: platformServer.provideServerRendering,
     provideZonelessChangeDetection: core.provideZonelessChangeDetection,
@@ -782,9 +801,8 @@ var angularIslandSelector = "abs-angular-island", isAngularComponent = (value) =
   const componentName = typeof component.name === "string" && component.name.length > 0 ? component.name : "AngularIsland";
   return `${componentName}:${JSON.stringify(props)}`;
 }, buildAngularIslandWrapperMetadata = async (component, islandId, wrapperKey) => {
-  const { Component, InjectionToken, inject } = await import("@angular/core");
-  const { NgComponentOutlet } = await import("@angular/common");
   const deps = await getAngularDeps();
+  const { Component, InjectionToken, NgComponentOutlet, inject } = deps;
   const selector = getAngularIslandSelector(islandId);
   const propsToken = new InjectionToken(`${wrapperKey}:props`);
 
@@ -1014,13 +1032,6 @@ init_islands();
 
 // src/client/preserveIslandMarkup.ts
 init_islandMarkupAttributes();
-var getClaimMap = () => {
-  if (typeof window === "undefined") {
-    return null;
-  }
-  window.__ABS_CLAIMED_ISLAND_MARKUP__ ??= new Map;
-  return window.__ABS_CLAIMED_ISLAND_MARKUP__;
-};
 var getSnapshotMap = () => {
   if (typeof window === "undefined") {
     return null;
@@ -1079,19 +1090,22 @@ var preserveIslandMarkup = (props) => {
       innerHTML: ""
     };
   }
-  const claimMap = getClaimMap();
   const snapshotMap = getSnapshotMap();
   const signature = getIslandSignature(props);
-  const claimedCount = claimMap?.get(signature) ?? 0;
-  const snapshotCandidate = snapshotMap?.get(signature)?.[claimedCount];
-  const candidates = Array.from(document.querySelectorAll('[data-island="true"]')).filter((element) => isMatchingIslandElement(element, props));
-  const candidate = candidates[claimedCount];
-  if (claimMap) {
-    claimMap.set(signature, claimedCount + 1);
+  const snapshotCandidate = snapshotMap?.get(signature)?.[0];
+  if (snapshotCandidate) {
+    return snapshotCandidate;
+  }
+  const liveCandidate = Array.from(document.querySelectorAll('[data-island="true"]')).find((element) => isMatchingIslandElement(element, props));
+  if (!liveCandidate) {
+    return {
+      attributes: getIslandMarkerAttributes(props),
+      innerHTML: ""
+    };
   }
   return {
-    attributes: snapshotCandidate?.attributes ?? getIslandMarkerAttributes(props),
-    innerHTML: snapshotCandidate?.innerHTML ?? candidate?.innerHTML ?? ""
+    attributes: Object.fromEntries(liveCandidate.getAttributeNames().map((name) => [name, liveCandidate.getAttribute(name) ?? ""])),
+    innerHTML: liveCandidate.innerHTML
   };
 };
 
@@ -1242,5 +1256,5 @@ export {
   createIslandManifestResolver
 };
 
-//# debugId=48A5E34EBDE550F464756E2164756E21
+//# debugId=07B15BB8DBC2C0A764756E2164756E21
 //# sourceMappingURL=index.js.map