@stencil/core 5.0.0-beta.34 → 5.0.0-beta.36

package/dist/runtime/server/runner.mjs

@@ -6772,7 +6772,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-const HYDRATE_ID = "s-id";
 const XML_NS = "http://www.w3.org/XML/1998/namespace";
 const XMLNS_NS = "http://www.w3.org/2000/xmlns/";
 /**
@@ -7767,19 +7766,7 @@ function* streamToHtml(node, opts, output) {
 						const isWithinWhitespaceSensitiveNode = opts.newLines || (opts.indentSpaces ?? 0) > 0 ? isWithinWhitespaceSensitive(node) : false;
 						if (!isWithinWhitespaceSensitiveNode && (opts.indentSpaces ?? 0) > 0 && ignoreTag === false) output.indent = output.indent + (opts.indentSpaces ?? 0);
 						for (let i = 0; i < childNodeLength; i++) {
-							/**
-							* In cases where a user would pass in a declarative shadow dom of a
-							* Stencil component, we want to skip over the template tag as we
-							* will be parsing the shadow root of the component again.
-							*
-							* We know it is a hydrated Stencil component by checking if the `HYDRATE_ID`
-							* is set on the node.
-							*/
-							const sId = node.attributes.getNamedItem(HYDRATE_ID);
-							if (childNodes[i].nodeName.toLowerCase() === "template" && sId) {
-								yield `\n${" ".repeat(output.indent)}<!--r.${sId.value}-->`;
-								continue;
-							}
+							if (childNodes[i].nodeName.toLowerCase() === "template" && node.attributes.getNamedItem("s-id")) continue;
 							yield* streamToHtml(childNodes[i], opts, output);
 						}
 						if (ignoreTag === false) {
@@ -11910,6 +11897,77 @@ function constrainTimeouts(win) {
 	win.__allowInterval = false;
 	win.__maxTimeout = 0;
 }
+/**
+* Reset a window so the same object can be used for another render, then parse `html` into its
+* document.
+*
+* Code that captured the window's sub-objects (e.g. an SSR platform holding `win.location`,
+* `win.console` or `win.document`) keeps working: those objects are kept and reset in place,
+* rather than replaced. Everything else on the window - including anything a previous render
+* added - is removed.
+* @param win the window to reset
+* @param html the HTML for the next render
+*/
+function resetWindowForReuse(win, html) {
+	const retained = {
+		console: win.console,
+		document: win.document,
+		eventCounts: win.performance.eventCounts,
+		history: win.history,
+		localStorage: win.localStorage,
+		location: win.location,
+		navigator: win.navigator,
+		orientation: win.screen.orientation,
+		performance: win.performance,
+		screen: win.screen,
+		sessionStorage: win.sessionStorage
+	};
+	if (win.__timeouts) win.__timeouts.forEach((timeoutId) => {
+		nativeClearInterval(timeoutId);
+		nativeClearTimeout(timeoutId);
+	});
+	resetObject(retained.console, createConsole());
+	resetObject(retained.history, new MockHistory());
+	resetObject(retained.location, new MockLocation());
+	resetObject(retained.navigator, new MockNavigator());
+	retained.localStorage.clear();
+	retained.sessionStorage.clear();
+	retained.eventCounts.clear();
+	resetObject(retained.performance, {
+		eventCounts: retained.eventCounts,
+		interactionCount: 0,
+		timeOrigin: Date.now()
+	});
+	for (const key of Reflect.ownKeys(win)) delete win[key];
+	resetWindowDefaults(win);
+	resetWindowDimensions(win);
+	const defaultScreen = win.screen;
+	resetObject(retained.orientation, defaultScreen.orientation);
+	resetObject(retained.screen, {
+		...defaultScreen,
+		orientation: retained.orientation
+	});
+	win.console = retained.console;
+	win.customElements = null;
+	win.document = retained.document;
+	win.history = retained.history;
+	win.localStorage = retained.localStorage;
+	win.location = retained.location;
+	win.navigator = retained.navigator;
+	win.performance = retained.performance;
+	win.screen = retained.screen;
+	win.sessionStorage = retained.sessionStorage;
+	resetDocumentForReuse(retained.document, win, html);
+}
+/**
+* Replace every own property of `target` with those of `defaults`, keeping the object itself.
+* @param target the object to reset in place
+* @param defaults the properties it should have afterwards
+*/
+function resetObject(target, defaults) {
+	for (const key of Reflect.ownKeys(target)) delete target[key];
+	Object.assign(target, defaults);
+}
 function resetWindow(win) {
 	if (win != null) {
 		if (win.__timeouts) {
@@ -12210,6 +12268,37 @@ function resetDocument(doc) {
 		} catch {}
 	}
 }
+/**
+* Reset a document so the same object can be used for another render, then parse `html` into
+* it. The document object itself is kept (code holding a reference to it stays valid), but its
+* whole element tree is replaced with freshly parsed elements - so caches keyed on elements, like
+* the runtime's applied-styles cache keyed on `<head>`, start empty.
+* @param doc the document to reset
+* @param win the window that owns the document
+* @param html the HTML to parse into the document
+*/
+function resetDocumentForReuse(doc, win, html) {
+	resetDocument(doc);
+	for (const key of Reflect.ownKeys(doc)) if (typeof key !== "string" || !REUSABLE_DOC_KEY_KEEPERS.has(key)) delete doc[key];
+	doc.defaultView = win;
+	doc.documentElement = parseDocumentUtil(doc, html).documentElement;
+}
+/** Structural document properties kept by {@link resetDocumentForReuse}; everything else is per-render state. */
+const REUSABLE_DOC_KEY_KEEPERS = /* @__PURE__ */ new Set([
+	"_nodeValue",
+	"nodeName",
+	"nodeType",
+	"ownerDocument",
+	"parentNode",
+	"_childNodes",
+	"__namespaceURI",
+	"__localName",
+	"defaultView",
+	"cookie",
+	"referrer",
+	"compatMode",
+	"contentType"
+]);
 const DOC_KEY_KEEPERS = /* @__PURE__ */ new Set([
 	"nodeName",
 	"nodeType",
@@ -13360,6 +13449,90 @@ function renderCatchError(results, err) {
 	return diagnostic;
 }
 //#endregion
+//#region src/server/runner/reusable-window.ts
+/**
+* A canonical key for a `serializeShadowRoot` value: values that render every component the same
+* way get the same key.
+*
+* Rendering shadow components as scoped permanently changes their metadata inside the SSR platform
+* that rendered them, so a platform (and a reusable window) can only be shared by renders whose
+* `serializeShadowRoot` marks the same components as scoped. Which components that is depends
+* only on this value: for the object form, on `default` and the two tag lists - so those are
+* normalized (lowercased, de-duplicated, sorted) to give equivalent objects one key.
+* @param serializeShadowRoot the render's `serializeShadowRoot` option
+* @returns the key
+*/
+function serializeShadowRootKey(serializeShadowRoot) {
+	if (serializeShadowRoot === null || typeof serializeShadowRoot !== "object") return `${typeof serializeShadowRoot}:${serializeShadowRoot}`;
+	const opts = serializeShadowRoot;
+	const tags = (list) => Array.isArray(list) ? [...new Set(list.map((tag) => String(tag).toLowerCase()))].sort().join(",") : "";
+	return `object:default=${opts.default};dsd=${tags(opts["declarative-shadow-dom"])};scoped=${tags(opts.scoped)}`;
+}
+/** The most reusable windows kept at once (one per distinct `serializeShadowRoot` key). */
+const MAX_REUSABLE_WINDOWS = 16;
+/** Long-lived windows used by `reuseWindow` renders, by `serializeShadowRoot` key. */
+const reusableWindows = /* @__PURE__ */ new Map();
+/** Renders sharing a reusable window must not overlap, so each key has a queue. */
+const renderQueues = /* @__PURE__ */ new Map();
+const NOOP$1 = () => {};
+/**
+* Run `render` once every earlier render using the same reusable window has finished.
+* @param key the render's {@link serializeShadowRootKey}
+* @param render the render to run
+* @returns the render's result
+*/
+function enqueueReusableRender(key, render) {
+	const queued = (renderQueues.get(key) ?? Promise.resolve()).then(render, render);
+	renderQueues.set(key, queued.then(NOOP$1, NOOP$1));
+	return queued;
+}
+/**
+* Get the reusable window for a `serializeShadowRoot` key, reset and holding `html`.
+* @param html the HTML to render
+* @param key the render's {@link serializeShadowRootKey}
+* @returns the window to render into
+*/
+function getReusableWindow(html, key) {
+	let win = reusableWindows.get(key);
+	if (!win) {
+		if (reusableWindows.size >= MAX_REUSABLE_WINDOWS) reusableWindows.delete(reusableWindows.keys().next().value);
+		win = new MockWindow(html);
+		reusableWindows.set(key, win);
+		return win;
+	}
+	try {
+		resetWindowForReuse(win, html);
+		return win;
+	} catch (e) {
+		discardReusableWindow(key);
+		throw e;
+	}
+}
+/**
+* Stop reusing the window for a key, e.g. after a render failed and may have left it in a bad
+* state. The next render with that key creates a new one.
+* @param key the render's {@link serializeShadowRootKey}
+*/
+function discardReusableWindow(key) {
+	const win = reusableWindows.get(key);
+	reusableWindows.delete(key);
+	try {
+		win?.close();
+	} catch {}
+}
+/**
+* Drop every reusable window and render queue. For hosts where a render can be abandoned without
+* ever settling (the `ssr-wasm` plugin, when a call ends with a render still waiting), so the
+* next render doesn't queue behind it forever.
+*/
+function resetReusableWindows() {
+	for (const win of reusableWindows.values()) try {
+		win.close();
+	} catch {}
+	reusableWindows.clear();
+	renderQueues.clear();
+}
+//#endregion
 //#region src/server/runner/runtime-log.ts
 function runtimeLogging(win, opts, results) {
 	try {
@@ -13464,6 +13637,29 @@ function initializeWindow(win, doc, opts, results) {
 //#region src/server/runner/render.ts
 const NOOP = () => {};
 /**
+* Render into the long-lived window for this render's `serializeShadowRoot` mode, once any
+* earlier render using that window has finished. See the `reuseWindow` option.
+* @param html the HTML to render
+* @param opts the normalized render options
+* @param results the results object to fill in
+* @returns the render results
+*/
+function renderInReusableWindow(html, opts, results) {
+	opts.destroyWindow = false;
+	opts.destroyDocument = false;
+	const key = opts.serializeShadowRootKey;
+	const run = async () => {
+		try {
+			await render(getReusableWindow(html, key), opts, results);
+		} catch (e) {
+			discardReusableWindow(key);
+			renderCatchError(results, e);
+		}
+		return results;
+	};
+	return enqueueReusableRender(key, run);
+}
+/**
 * Renders HTML to a string, returning the full hydration results.
 * This is the primary SSR function and is portable (no Node.js dependencies).
 * @param html - the HTML string or document to render
@@ -13516,9 +13712,11 @@ function ssrDocument(doc, options) {
 	* Defines whether we render the shadow root as a declarative shadow root or as scoped shadow root.
 	*/
 	opts.serializeShadowRoot = typeof opts.serializeShadowRoot === "undefined" ? "declarative-shadow-dom" : opts.serializeShadowRoot;
+	opts.serializeShadowRootKey = serializeShadowRootKey(opts.serializeShadowRoot);
 	let win = null;
 	const results = generateHydrateResults(opts);
 	if (hasError(results.diagnostics)) return Promise.resolve(results);
+	if (typeof doc === "string" && opts.reuseWindow) return renderInReusableWindow(doc, opts, results);
 	if (typeof doc === "string") try {
 		opts.destroyWindow = true;
 		opts.destroyDocument = true;
@@ -13682,4 +13880,21 @@ function removeScripts(elm) {
 	}
 }
 //#endregion
-export { createWindowFromHtml, hydrateDocument, renderToString, resetSsrDocData, serializeDocumentToString, setTagTransformer, ssrDocument, streamToString, transformTag };
+//#region src/server/runner/index.ts
+/**
+* Render components under transformed tag names, to match tag transformation on the client.
+*
+* Components are registered under their transformed names when a window's SSR platform is set up,
+* so this also discards the reusable windows (see the `reuseWindow` option): later renders set up
+* new ones that use the new transformer.
+*
+* (A function declaration with its own name, so the runtime's `setTagTransformer` keeps its name in
+* the bundle - the SSR build looks for it - and this is hoisted.)
+* @param transformer the tag transformer
+*/
+function setTagTransformerForSsr(transformer) {
+	setTagTransformer(transformer);
+	resetReusableWindows();
+}
+//#endregion
+export { createWindowFromHtml, hydrateDocument, renderToString, resetReusableWindows, resetSsrDocData, serializeDocumentToString, setTagTransformerForSsr as setTagTransformer, ssrDocument, streamToString, transformTag };

package/dist/sys/node/index.d.mts

@@ -1,4 +1,4 @@
-import { Bt as Logger, nt as CompilerSystem } from "../../index-B0NfYeIA.mjs";
+import { Bt as Logger, nt as CompilerSystem } from "../../index-DG4wtfhx.mjs";
 //#region src/sys/node/logger/index.d.ts
 /**
  * Create a logger to run in a Node environment

package/dist/sys/node/index.mjs

@@ -1,2 +1,2 @@
-import { n as setupNodeProcess, r as createNodeLogger, t as createNodeSys } from "../../node-eg7pofz5.mjs";
+import { n as setupNodeProcess, r as createNodeLogger, t as createNodeSys } from "../../node-DwwBX_GL.mjs";
 export { createNodeLogger, createNodeSys, setupNodeProcess };

package/dist/sys/node/worker.mjs

@@ -1,5 +1,5 @@
-import { l as createWorkerMessageHandler } from "../../compiler-CVL510L-.mjs";
-import { t as createNodeSys } from "../../node-eg7pofz5.mjs";
+import { l as createWorkerMessageHandler } from "../../compiler-DHNkXDvK.mjs";
+import { t as createNodeSys } from "../../node-DwwBX_GL.mjs";
 //#region src/sys/node/node-worker-thread.ts
 /**
 * Initialize a worker thread, setting up various machinery for managing

package/dist/testing/index.mjs

@@ -33,7 +33,7 @@ import "@rollup/pluginutils";
 import { createHash } from "crypto";
 import { afterAll, vi } from "vitest";
 //#region src/version.ts
-const version = "5.0.0-beta.34";
+const version = "5.0.0-beta.36";
 const MEMBER_FLAGS = {
 	String: 1,
 	Number: 2,
@@ -1184,6 +1184,13 @@ const NODE_TYPE = {
 const HYDRATE_ID = "s-id";
 const HYDRATED_STYLE_ID = "sty-id";
 const HYDRATE_CHILD_ID = "c-id";
+/**
+* Starts an attribute value written by the `ssr` output's `ssrProp()` on a server: a reference to
+* a value it put in the registry below, for the SSR runtime to take out and set as the prop.
+*/
+const SSR_PROP_REF_PREFIX = "__stencil_ssr_ref:";
+/** `Symbol.for()` key of the `ssrProp()` registry on the server's real global object. */
+const SSR_PROPS_REGISTRY_KEY = "stencil.ssrProps";
 const HYDRATED_CSS = "{visibility:hidden}.hydrated{visibility:inherit}";
 const STENCIL_DOC_DATA = "_stencilDocData";
 const DEFAULT_DOC_DATA = {
@@ -1631,7 +1638,9 @@ const patchTextContent = (hostElementPrototype) => {
 	Object.defineProperty(hostElementPrototype, "textContent", {
 		get: function() {
 			let text = "";
-			(this.__childNodes ? this.childNodes : getSlottedChildNodes(this.childNodes)).forEach((node) => text += node.textContent || "");
+			(this.__childNodes ? this.childNodes : getSlottedChildNodes(this.childNodes)).forEach((node) => {
+				if (node.nodeType !== NODE_TYPE.CommentNode) text += node.textContent || "";
+			});
 			return text;
 		},
 		set: function(value) {
@@ -1639,7 +1648,7 @@ const patchTextContent = (hostElementPrototype) => {
 				if (node["s-ol"]) node["s-ol"].remove();
 				node.remove();
 			});
-			this.insertAdjacentHTML("beforeend", value);
+			if (value != null && value !== "") this.append(this.ownerDocument.createTextNode(String(value)));
 		}
 	});
 };
@@ -2171,7 +2180,7 @@ const effect = (fn, options) => getCore().effect(fn, options);
 function signal(value, options) {
 	return getCore().signal(value, options);
 }
-const getRegistry = () => customElements;
+const getRegistry = () => globalThis.customElements;
 /**
 * @param elm a defined component host
 * @returns the registry the host's class was defined in, else the active registry
@@ -4146,6 +4155,11 @@ const addSlottedNodes = (slottedNodes, slotNodeId, slotName, slotNode, hostId) =
 * @returns the first corresponding node of the type
 */
 const findCorrespondingNode = (node, type) => {
+	if (type === NODE_TYPE.TextNode) {
+		const next = node.nextSibling;
+		if (next?.nodeType === NODE_TYPE.TextNode) return next;
+		return node.parentNode.insertBefore(node.ownerDocument.createTextNode(""), next);
+	}
 	let sibling = node;
 	do
 		sibling = sibling.nextSibling;
@@ -5615,7 +5629,10 @@ const insertVNodeAnnotations = (doc, hostElm, vnode, docData, cmpData) => {
 	if (vnode != null) {
 		const hostId = ++docData.hostIds;
 		hostElm.setAttribute(HYDRATE_ID, hostId);
-		if (hostElm["s-cr"] != null) hostElm["s-cr"].nodeValue = `r.${hostId}`;
+		if (hostElm["s-cr"] != null) {
+			if (hostElm.shadowRoot) hostElm["s-cr"].remove();
+			else hostElm["s-cr"].nodeValue = `r.${hostId}`;
+		}
 		if (vnode.$children$ != null) {
 			const depth = 0;
 			vnode.$children$.forEach((vnodeChild, index) => {
@@ -5975,6 +5992,7 @@ new RegExp(`^(${[.../* @__PURE__ */ new Set([
 	"vm",
 	"zlib"
 ])].join("|")})$`);
+`${JSON.stringify(SSR_PROP_REF_PREFIX)}${JSON.stringify(SSR_PROPS_REGISTRY_KEY)}`;
 promisify(execFile);
 process.platform;
 new Set([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stencil/core",
-  "version": "5.0.0-beta.34",
+  "version": "5.0.0-beta.36",
   "description": "A Compiler for Web Components and Progressive Web Apps",
   "keywords": [
     "components",
@@ -126,9 +126,9 @@
     "terser": "^5.50.0",
     "tinyglobby": "^0.2.17",
     "typescript": ">5.0.0 <7.0.0",
-    "@stencil/cli": "5.0.0-beta.34",
-    "@stencil/dev-server": "5.0.0-beta.34",
-    "@stencil/mock-doc": "5.0.0-beta.34"
+    "@stencil/dev-server": "5.0.0-beta.36",
+    "@stencil/cli": "5.0.0-beta.36",
+    "@stencil/mock-doc": "5.0.0-beta.36"
   },
   "devDependencies": {
     "@ionic/prettier-config": "^4.0.0",