zova-module-a-ssr 5.0.0 → 5.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-present Zova
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,658 @@
+import { BeanBase, BeanInfo, BeanScopeBase, BeanSimple, cast } from "zova";
+import { Scope, Sys } from "zova-module-a-bean";
+import { isNavigationFailure } from "@cabloy/vue-router";
+import { computed, normalizeClass, normalizeStyle, onActivated, onDeactivated, onUnmounted, ref, useSSRContext, watch } from "vue";
+import { includeBooleanAttr, isBooleanAttr, isString, stringifyStyle } from "@vue/shared";
+import { defu } from "defu";
+import { extend } from "@cabloy/extend";
+import * as devalue from "devalue";
+//#region src/bean/sys.ssrState.ts
+var _dec$1, _dec2$1, _class$1;
+var SymbolSSRState$1 = Symbol("SymbolSSRState");
+var SymbolSSRStateDefer = Symbol("SymbolSSRStateDefer");
+var SysSsrState = (_dec$1 = Sys(), _dec2$1 = BeanInfo({ module: "a-ssr" }), _dec$1(_class$1 = _dec2$1(_class$1 = class SysSsrState extends BeanBase {
+	constructor(...args) {
+		super(...args);
+		this[SymbolSSRState$1] = void 0;
+		this[SymbolSSRStateDefer] = void 0;
+	}
+	async __init__() {
+		if (process.env.CLIENT) {
+			if (cast(window).__INITIAL_STATE__) {
+				this[SymbolSSRState$1] = cast(window).__INITIAL_STATE__;
+				delete cast(window).__INITIAL_STATE__;
+				document.getElementById("ssr-state-init")?.remove();
+			} else this[SymbolSSRState$1] = {};
+			if (cast(window).__INITIAL_STATE_DEFER__) {
+				this[SymbolSSRStateDefer] = cast(window).__INITIAL_STATE_DEFER__;
+				delete cast(window).__INITIAL_STATE_DEFER__;
+				document.getElementById("ssr-state-defer-init")?.remove();
+			} else this[SymbolSSRStateDefer] = {};
+		}
+	}
+	get state() {
+		return this[SymbolSSRState$1];
+	}
+	get stateDefer() {
+		return this[SymbolSSRStateDefer];
+	}
+}) || _class$1) || _class$1);
+//#endregion
+//#region src/config/config.ts
+var config = (sys) => {
+	return {
+		cookieTheme: sys.env.SSR_COOKIE_THEME === "true",
+		cookieThemeDarkDefault: sys.env.SSR_COOKIE_THEMEDARK_DEFAULT === "true",
+		optimization: { bodyReadyObserver: sys.env.SSR_BODYREADYOBSERVER === "true" },
+		transferCache: sys.env.SSR_TRANSFERCACHE === "false" ? false : { expires: _normalizeExpires(sys.env.SSR_TRANSFERCACHE_EXPIRES) }
+	};
+};
+function _normalizeExpires(expires) {
+	if (!expires) return 0;
+	if (!Number.isNaN(Number(expires))) return Number(expires);
+	return expires;
+}
+//#endregion
+//#region src/lib/useMeta.ts
+function useMeta(ctx, metaOptions) {
+	if (process.env.SERVER) ctx.meta.$ssr.context.__qMetaList.push(typeof metaOptions === "function" ? metaOptions() : metaOptions);
+	else {
+		const meta = { active: true };
+		if (typeof metaOptions === "function") {
+			const content = computed(metaOptions);
+			meta.val = content.value;
+			watch(content, (val) => {
+				meta.val = val;
+				meta.active === true && ctx.meta.$ssr.metaStore.planClientUpdate();
+			});
+		} else meta.val = metaOptions;
+		ctx.meta.$ssr.metaStore.addMetaOptions(meta);
+		ctx.meta.$ssr.metaStore.planClientUpdate();
+		onActivated(() => {
+			try {
+				meta.active = true;
+				ctx.meta.$ssr.metaStore.planClientUpdate();
+			} catch (_err) {}
+		});
+		onDeactivated(() => {
+			try {
+				meta.active = false;
+				ctx.meta.$ssr.metaStore.planClientUpdate();
+			} catch (_err) {}
+		});
+		onUnmounted(() => {
+			try {
+				ctx.meta.$ssr.metaStore.removeMetaOptions(meta);
+				ctx.meta.$ssr.metaStore.planClientUpdate();
+			} catch (_err) {}
+		});
+	}
+}
+//#endregion
+//#region src/monkey.ts
+var Monkey = class extends BeanSimple {
+	appContextInitialize(ctx) {
+		ctx.meta.$ssr = ctx.app.ctx.meta.$ssr;
+	}
+	async appInitialize() {
+		if (process.env.SERVER) this._ssrErrorHandler();
+	}
+	async moduleLoading(_module) {}
+	async moduleLoaded(module) {
+		if (process.env.SERVER && process.env.PROD) {
+			if (!this.ctx.meta.$ssr.context.modules) this.ctx.meta.$ssr.context.modules = /* @__PURE__ */ new Set();
+			this.ctx.meta.$ssr.context.modules.add(`@@${module.info.relativeName}`);
+		}
+	}
+	async beanInit(bean, beanInstance) {
+		const self = this;
+		bean.defineProperty(beanInstance, "$ssr", {
+			enumerable: false,
+			configurable: true,
+			get() {
+				return self.app.ctx.meta.$ssr;
+			}
+		});
+		bean.defineProperty(beanInstance, "$useMeta", {
+			enumerable: false,
+			configurable: true,
+			get() {
+				return function(options) {
+					const ctx = cast(this).ctx;
+					ctx.util.instanceScope(() => {
+						useMeta(ctx, options);
+					});
+				};
+			}
+		});
+	}
+	_ssrErrorHandler() {
+		if (!process.env.SERVER) return;
+		const _eventErrorHandler = this.app.meta.event.on("app:errorHandler", (_data, next) => {
+			const err = next();
+			if (!err || !(err instanceof Error)) return err;
+			return this._errorHandlerDefaultServer(err);
+		});
+		this.ctx.meta.$ssr.context.onRendered((_err) => {
+			_eventErrorHandler();
+		});
+	}
+	_errorHandlerDefaultServer(err) {
+		if (!process.env.SERVER) return err;
+		if (isNavigationFailure(err)) {
+			if (!this.ctx.meta.$ssr.context._meta.renderError) this.ctx.meta.$ssr.context._meta.renderError = err;
+			return;
+		} else if (err.code === 401) try {
+			this.app.$gotoLogin();
+		} catch (err) {
+			this.ctx.meta.$ssr.context._meta.renderError = err;
+		}
+		else this.ctx.meta.$ssr.context._meta.renderError = err;
+	}
+};
+//#endregion
+//#region src/lib/utils.ts
+function unevalPatch(value) {
+	return devalue.uneval(value);
+}
+//#endregion
+//#region src/lib/ssrMetaStore.ts
+var CtxSSRMetaStore = class extends BeanSimple {
+	constructor(...args) {
+		super(...args);
+		this._updateId = 0;
+		this._currentClientMeta = void 0;
+		this._clientList = [];
+	}
+	__init__() {
+		if (process.env.SERVER) {
+			const ssrContext = this.ctx.meta.$ssr.context;
+			ssrContext.__qMetaList = [];
+			if (this.sys.env.SSR_BODYREADYOBSERVER === "true") ssrContext.__qMetaList.push({ bodyStyle: { display: "none" } });
+			ssrContext.rendered = () => {
+				this._onRenderedLast();
+				ssrContext.rendered = () => {};
+			};
+		}
+		if (process.env.CLIENT && this.ctx.meta.$ssr.isRuntimeSsrPreHydration) {
+			this._currentClientMeta = cast(window).__Q_META__;
+			document.getElementById("ssr-meta-init")?.remove();
+		}
+	}
+	_onRenderedLast(err) {
+		if (!err) {
+			const ssrContext = this.ctx.meta.$ssr.context;
+			this._injectContextState(ssrContext);
+			this._injectContextStateDefer(ssrContext);
+			this._injectServerMeta(ssrContext);
+		}
+		this.app.close();
+	}
+	addMetaOptions(metaOptionsWrapper) {
+		this._clientList.push(metaOptionsWrapper);
+	}
+	removeMetaOptions(metaOptionsWrapper) {
+		this._clientList.splice(this._clientList.indexOf(metaOptionsWrapper), 1);
+	}
+	planClientUpdate() {
+		if (this._updateId !== 0) clearTimeout(this._updateId);
+		this._updateId = window.setTimeout(() => {
+			this._updateId = 0;
+			this._updateClientMeta();
+		}, 50);
+	}
+	_updateClientMeta() {
+		const data = {
+			title: "",
+			titleTemplate: void 0,
+			meta: {},
+			link: {},
+			script: {},
+			htmlAttr: {},
+			bodyAttr: {}
+		};
+		for (let i = 0; i < this._clientList.length; i++) {
+			const { active, val } = this._clientList[i];
+			if (active === true) extend(true, data, val);
+		}
+		normalize(data);
+		apply(diff(this._currentClientMeta, data));
+		this._currentClientMeta = data;
+	}
+	_injectServerMeta(ssrContext) {
+		const data = {
+			title: "",
+			titleTemplate: void 0,
+			meta: {},
+			link: {},
+			htmlAttr: {},
+			bodyAttr: {},
+			bodyStyle: {},
+			bodyClass: {},
+			noscript: {}
+		};
+		const list = ssrContext.__qMetaList;
+		for (let i = 0; i < list.length; i++) extend(true, data, list[i]);
+		normalize(data);
+		const nonce = ssrContext.nonce !== void 0 ? ` nonce="${ssrContext.nonce}"` : "";
+		const ctx = ssrContext._meta;
+		const htmlAttr = Object.keys(data.htmlAttr).filter(htmlFilter);
+		if (htmlAttr.length !== 0) ctx.htmlAttrs += (ctx.htmlAttrs.length !== 0 ? " " : "") + htmlAttr.map(getAttr(data.htmlAttr)).join(" ");
+		ctx.headTags += getHead(data);
+		const bodyAttr = Object.keys(data.bodyAttr).filter(bodyFilter);
+		if (bodyAttr.length !== 0) ctx.bodyAttrs += (ctx.bodyAttrs.length !== 0 ? " " : "") + bodyAttr.map(getAttr(data.bodyAttr)).join(" ");
+		const bodyStyle = Object.keys(data.bodyStyle).filter((name) => !!data.bodyStyle[name]).map((name) => `${name}:${data.bodyStyle[name]};`).join("");
+		if (bodyStyle) ctx.bodyAttrs += `${ctx.bodyAttrs.length !== 0 ? " " : ""}style="${bodyStyle}"`;
+		const _bodyClass = ctx.bodyClasses.split(" ").filter((item) => !!item);
+		const bodyClass = {};
+		_bodyClass.forEach((item) => bodyClass[item] = true);
+		extend(true, bodyClass, data.bodyClass);
+		ctx.bodyClasses = Object.keys(bodyClass).filter((name) => bodyClass[name]).map((name) => name).join(" ");
+		data.title = "'\"`";
+		ctx.endingHeadTags += `${Object.keys(data.noscript).map((name) => `<noscript data-qmeta="${name}">${data.noscript[name]}</noscript>`).join("")}<script${nonce} id="ssr-meta-init">window.__Q_META__=${delete data.bodyStyle && delete data.bodyClass && delete data.noscript && unevalPatch(data)}<\/script>`;
+		let ssr_local_themedark = this.sys.env.SSR_COOKIE_THEME === "true" ? `let ssr_cookie_themedark=document.cookie.split('; ')?.find(item=>item.indexOf('themedark=')>-1)?.split('=')[1];
+        ssr_cookie_themedark=ssr_cookie_themedark==='true'?true:ssr_cookie_themedark==='false'?false:${this.sys.env.SSR_COOKIE_THEMEDARK_DEFAULT};
+        window.ssr_themedark=window.ssr_cookie_themedark=ssr_cookie_themedark;` : `let ssr_local_themedark=window.ssr_load_local('themedark');
+        if(ssr_local_themedark===undefined || ssr_local_themedark==='auto'){
+          ssr_local_themedark=window.matchMedia('(prefers-color-scheme: dark)').matches;
+        }
+        window.ssr_themedark=window.ssr_local_themedark=ssr_local_themedark;`;
+		ssr_local_themedark += `Object.defineProperty(window, 'ssr_themedark_data', {
+          get: () => {
+            let _data=document.body.getAttribute('data-ssr-theme-dark-'+window.ssr_themedark);
+            if(_data===undefined || _data===null){
+              _data=window.__INITIAL_STATE__ && window.__INITIAL_STATE__['data-ssr-theme-dark-'+window.ssr_themedark];
+            }
+            return _data;
+          },
+        });`;
+		const ssr_local_themename = this.sys.env.SSR_COOKIE_THEME === "true" ? "" : "window.ssr_local_themename=window.ssr_load_local('themename');";
+		ctx.endingHeadTags += `<script id="ssr-prefers-color-schema-dark">
+        window.ssr_load_local=function(key){
+          const __ssr_local=localStorage.getItem(key);
+          return __ssr_local?JSON.parse(__ssr_local):undefined;
+        };
+        ${ssr_local_themedark}
+        ${ssr_local_themename}
+        document.querySelector('#ssr-prefers-color-schema-dark').remove();
+    <\/script>`.replaceAll("\n", "");
+		if (this.sys.env.SSR_BODYREADYOBSERVER === "true") ctx.bodyTags += `<script id="ssr-body-ready-observer">
+        window.ssr_bodyReadyObserverClear=()=>{
+          if(window.ssr_bodyReadyObserver){
+            window.ssr_body_ready_condition=undefined;
+            window.ssr_body_ready_callback=undefined;
+            window.ssr_bodyReadyObserver.disconnect();
+            window.ssr_bodyReadyObserver=undefined;
+            document.body.style.display='block';
+            document.querySelector('#ssr-body-ready-observer').remove();
+          }
+        };
+        window.ssr_bodyReadyObserver = new MutationObserver(() => {
+          if(window.ssr_body_ready_condition && window.ssr_body_ready_condition()){
+            window.ssr_body_ready_callback();
+            window.ssr_bodyReadyObserverClear();
+          }
+        });
+        window.ssr_bodyReadyObserver.observe(document.body, {
+          subtree: true,
+          childList: true,
+        });
+        document.addEventListener("DOMContentLoaded", () => {
+          window.ssr_bodyReadyObserverClear();
+        });
+      <\/script>`.replaceAll("\n", "");
+	}
+	_injectContextState(ssrContext) {
+		const ctx = ssrContext._meta;
+		const nonce = ssrContext.nonce !== void 0 ? ` nonce="${ssrContext.nonce}"` : "";
+		ctx.endingHeadTags += `<script${nonce} id="ssr-state-init">window.__INITIAL_STATE__=${unevalPatch(ssrContext.state)}<\/script>`;
+	}
+	_injectContextStateDefer(ssrContext) {
+		const ctx = ssrContext._meta;
+		const nonce = ssrContext.nonce !== void 0 ? ` nonce="${ssrContext.nonce}"` : "";
+		ctx.endingBodyTags += `<script${nonce} id="ssr-state-defer-init">window.__INITIAL_STATE_DEFER__=${unevalPatch(ssrContext.stateDefer)}<\/script>`;
+	}
+};
+function normalize(meta) {
+	if (meta.title) {
+		meta.title = meta.titleTemplate ? meta.titleTemplate(meta.title) : meta.title;
+		delete meta.titleTemplate;
+	}
+	[["meta", "content"], ["link", "href"]].forEach((type) => {
+		const metaType = meta[type[0]];
+		const metaProp = type[1];
+		for (const name in metaType) {
+			const metaLink = metaType[name];
+			if (metaLink.template) if (Object.keys(metaLink).length === 1) delete metaType[name];
+			else {
+				metaLink[metaProp] = metaLink.template(metaLink[metaProp] || "");
+				delete metaLink.template;
+			}
+		}
+	});
+}
+function changed(old, def) {
+	if (Object.keys(old).length !== Object.keys(def).length) return true;
+	for (const key in old) if (old[key] !== def[key]) return true;
+}
+function bodyFilter(name) {
+	return ["class", "style"].includes(name) === false;
+}
+function htmlFilter(_name) {
+	return true;
+}
+function diff(meta, other) {
+	const add = {};
+	const remove = {};
+	if (meta === void 0) return {
+		add: other,
+		remove
+	};
+	if (meta.title !== other.title) add.title = other.title;
+	[
+		"meta",
+		"link",
+		"script",
+		"htmlAttr",
+		"bodyAttr"
+	].forEach((type) => {
+		const old = meta[type];
+		const cur = other[type];
+		remove[type] = [];
+		if (old === void 0 || old === null) {
+			add[type] = cur;
+			return;
+		}
+		add[type] = {};
+		for (const key in old) if (Object.prototype.hasOwnProperty.call(cur, key) === false) remove[type].push(key);
+		for (const key in cur) if (Object.prototype.hasOwnProperty.call(old, key) === false) add[type][key] = cur[key];
+		else if (changed(old[key], cur[key]) === true) {
+			remove[type].push(key);
+			add[type][key] = cur[key];
+		}
+	});
+	return {
+		add,
+		remove
+	};
+}
+function apply({ add, remove }) {
+	if (add.title) document.title = add.title;
+	if (Object.keys(remove).length !== 0) {
+		[
+			"meta",
+			"link",
+			"script"
+		].forEach((type) => {
+			remove[type].forEach((name) => {
+				document.head.querySelector(`${type}[data-qmeta="${name}"]`)?.remove();
+			});
+		});
+		remove.htmlAttr.filter(htmlFilter).forEach((name) => {
+			document.documentElement.removeAttribute(name);
+		});
+		remove.bodyAttr.filter(bodyFilter).forEach((name) => {
+			document.body.removeAttribute(name);
+		});
+	}
+	[
+		"meta",
+		"link",
+		"script"
+	].forEach((type) => {
+		const metaType = add[type];
+		for (const name in metaType) {
+			const tag = document.createElement(type);
+			for (const att in metaType[name]) if (att !== "innerHTML") tag.setAttribute(att, metaType[name][att]);
+			tag.setAttribute("data-qmeta", name);
+			if (type === "script") tag.innerHTML = metaType[name].innerHTML || "";
+			document.head.appendChild(tag);
+		}
+	});
+	Object.keys(add.htmlAttr).filter(htmlFilter).forEach((name) => {
+		document.documentElement.setAttribute(name, add.htmlAttr[name] || "");
+	});
+	Object.keys(add.bodyAttr).filter(bodyFilter).forEach((name) => {
+		document.body.setAttribute(name, add.bodyAttr[name] || "");
+	});
+}
+function getAttr(seed) {
+	return (att) => {
+		const val = seed[att];
+		return att + (val !== true && val !== void 0 ? `="${val}"` : "");
+	};
+}
+function getHead(meta) {
+	let output = "";
+	if (meta.title) output += `<title>${meta.title}</title>`;
+	[
+		"meta",
+		"link",
+		"script"
+	].forEach((type) => {
+		const metaType = meta[type];
+		for (const att in metaType) {
+			const attrs = Object.keys(metaType[att]).filter((att) => att !== "innerHTML").map(getAttr(metaType[att]));
+			output += `<${type} ${attrs.join(" ")} data-qmeta="${att}">`;
+			if (type === "script") output += `${metaType[att].innerHTML || ""}<\/script>`;
+		}
+	});
+	return output;
+}
+//#endregion
+//#region src/lib/ssr.ts
+var SymbolIsRuntimeSsrPreHydration = Symbol("SymbolIsRuntimeSsrPreHydration");
+var SymbolSSRContext = Symbol("SymbolSSRContext");
+var SymbolSSRState = Symbol("SymbolSSRState");
+var SymbolOnHydrateds = Symbol("SymbolOnHydrateds");
+var SymbolOnHydratePropHasMismatches = Symbol("SymbolOnHydratePropHasMismatches");
+var SymbolInstanceUpdates = Symbol("SymbolInstanceUpdates");
+var SymbolHydratingCounter = Symbol("SymbolHydratingCounter");
+var CtxSSR = class extends BeanSimple {
+	constructor(...args) {
+		super(...args);
+		this[SymbolIsRuntimeSsrPreHydration] = ref(false);
+		this[SymbolSSRContext] = void 0;
+		this[SymbolSSRState] = void 0;
+		this[SymbolOnHydrateds] = [];
+		this[SymbolOnHydratePropHasMismatches] = [];
+		this[SymbolInstanceUpdates] = [];
+		this[SymbolHydratingCounter] = 0;
+		this.metaStore = void 0;
+	}
+	/** @internal */
+	initialize() {
+		this[SymbolSSRState] = this.sys.bean._getBeanSyncOnly("a-ssr.sys.ssrState");
+		if (process.env.SERVER) this[SymbolIsRuntimeSsrPreHydration].value = true;
+		else if (process.env.CLIENT && document.body.getAttribute("data-server-rendered") !== null) this[SymbolIsRuntimeSsrPreHydration].value = true;
+		if (process.env.CLIENT && this.isRuntimeSsrPreHydration) this.onHydratePropHasMismatch((el, key, clientValue, vnode, instance) => {
+			return this._onHydratePropHasMismatchDefault(el, key, clientValue, vnode, instance);
+		});
+		this.metaStore = this.bean._newBeanSimple(CtxSSRMetaStore, false);
+		if (process.env.CLIENT && this.isRuntimeSsrPreHydration) this.onHydrated(() => {
+			document.querySelectorAll("style[vite-css-module-id]").forEach((node) => node.remove());
+		});
+	}
+	get isRuntimeSsrPreHydration() {
+		return this[SymbolIsRuntimeSsrPreHydration].value;
+	}
+	set isRuntimeSsrPreHydration(value) {
+		this[SymbolIsRuntimeSsrPreHydration].value = value;
+	}
+	get context() {
+		if (process.env.CLIENT) throw new Error("cannot called in client");
+		if (!this[SymbolSSRContext]) this.ctx.util.instanceScope(() => {
+			this[SymbolSSRContext] = useSSRContext();
+			this._initContext();
+		});
+		return this[SymbolSSRContext];
+	}
+	get state() {
+		if (process.env.SERVER) return this.context.state;
+		else return this[SymbolSSRState].state;
+	}
+	get stateDefer() {
+		if (process.env.SERVER) return this.context.stateDefer;
+		else return this[SymbolSSRState].stateDefer;
+	}
+	getPerformAction(baseURL) {
+		if (process.env.SERVER && baseURL === this.sys.env.SSR_API_BASE_URL) return this.context.performAction;
+	}
+	_initContext() {
+		const ssrContext = this[SymbolSSRContext];
+		ssrContext._meta = defu(ssrContext._meta, {
+			htmlAttrs: "",
+			headTags: "",
+			endingHeadTags: "",
+			bodyClasses: "",
+			bodyAttrs: "data-server-rendered",
+			bodyTags: "",
+			endingBodyTags: "",
+			baseUrl: this.sys.util.getAbsoluteUrlFromPagePath(void 0, false, true)
+		});
+		ssrContext.state = ssrContext.state || {};
+		ssrContext.stateDefer = ssrContext.stateDefer || {};
+	}
+	onHydrated(fn) {
+		this[SymbolOnHydrateds].push(fn);
+	}
+	onHydratePropHasMismatch(fn) {
+		this[SymbolOnHydratePropHasMismatches].push(fn);
+	}
+	handleDirectOrOnHydrated(fn) {
+		if (process.env.CLIENT && this.isRuntimeSsrPreHydration) this.onHydrated(fn);
+		else return fn();
+	}
+	_onHydratePropHasMismatchDefault(el, key, clientValue, _vnode, _instance) {
+		let ignore = false;
+		let expected;
+		if (key === "class") {
+			ignore = true;
+			if (clientValue !== void 0) {
+				expected = normalizeClass(clientValue);
+				el.setAttribute(key, expected);
+			}
+		} else if (key === "style") {
+			ignore = true;
+			if (clientValue !== void 0) {
+				expected = isString(clientValue) ? clientValue : stringifyStyle(normalizeStyle(clientValue));
+				el.setAttribute(key, expected);
+			}
+		} else if (key === "for") {
+			ignore = true;
+			if (clientValue !== void 0) {
+				expected = String(clientValue);
+				el.setAttribute(key, expected);
+			}
+		} else if (key === "id") {
+			ignore = true;
+			if (clientValue !== void 0) {
+				expected = String(clientValue);
+				el.setAttribute(key, expected);
+			}
+		} else if (key === "d") {
+			ignore = true;
+			if (clientValue !== void 0) {
+				expected = String(clientValue);
+				el.setAttribute(key, expected);
+			}
+		} else if (key === "value") {
+			ignore = true;
+			if (clientValue !== void 0) {
+				expected = String(clientValue);
+				if (el.tagName === "TEXTAREA") el.value = expected;
+				else el.setAttribute(key, expected);
+			}
+		} else if (isBooleanAttr(key)) {
+			ignore = true;
+			if (clientValue !== void 0) if (includeBooleanAttr(clientValue)) el.setAttribute(key, "");
+			else el.removeAttribute(key);
+		} else if (el.getAttribute(`data-hydrate-ignore-${key}`) !== null) {
+			ignore = true;
+			if (clientValue !== void 0) {
+				expected = String(clientValue);
+				el.setAttribute(key, expected);
+			}
+		}
+		if (!ignore) return { clientValue };
+		return { ignore: true };
+	}
+	_hydrated() {
+		if (!this.isRuntimeSsrPreHydration) return;
+		this.isRuntimeSsrPreHydration = false;
+		this[SymbolInstanceUpdates].forEach((instance) => {
+			if (!instance.isUnmounted && instance.zova) try {
+				instance.update();
+			} catch (err) {
+				if (!err.message.includes("'insertBefore'")) throw err;
+			}
+		});
+		this[SymbolInstanceUpdates] = [];
+		this[SymbolOnHydrateds].forEach((fn) => fn());
+		this[SymbolOnHydrateds] = [];
+		this[SymbolOnHydratePropHasMismatches] = [];
+	}
+	/** @internal */
+	_hydratePropHasMismatch(el, key, clientValue, vnode, instance) {
+		for (const fn of this[SymbolOnHydratePropHasMismatches]) {
+			const res = fn(el, key, clientValue, vnode, instance);
+			if (res.ignore) return res;
+			clientValue = res.clientValue;
+		}
+		return {
+			ignore: false,
+			clientValue
+		};
+	}
+	/** @internal */
+	_hydratingInc() {
+		++this[SymbolHydratingCounter];
+	}
+	/** @internal */
+	_hydratingDec() {
+		if (--this[SymbolHydratingCounter] === 0) this._hydrated();
+	}
+	/** @internal */
+	_hydratingInstanceRecord(instance) {
+		if (!this[SymbolInstanceUpdates].includes(instance)) {
+			this[SymbolInstanceUpdates].push(instance);
+			return true;
+		}
+		return false;
+	}
+};
+//#endregion
+//#region src/monkeySys.ts
+var MonkeySys = class extends BeanSimple {
+	constructor(moduleSelf) {
+		super();
+		this._moduleSelf = void 0;
+		this._sysSsrState = void 0;
+		this._moduleSelf = moduleSelf;
+	}
+	async getSysSsrState() {
+		if (!this._sysSsrState) this._sysSsrState = await this.bean._getBean("a-ssr.sys.ssrState", false);
+		return this._sysSsrState;
+	}
+	async moduleLoading(module) {
+		if (this._moduleSelf === module) return;
+		await this.getSysSsrState();
+	}
+	async moduleLoaded(_module) {}
+	async configLoaded(_module, _config) {}
+	sysContextInitialize(ctx) {
+		ctx.meta.$ssr = ctx.bean._newBeanSimple(CtxSSR, false);
+		ctx.meta.$ssr.initialize();
+	}
+};
+//#endregion
+//#region src/.metadata/index.ts
+/** monkeySys: end */
+/** scope: begin */
+var _dec, _dec2, _class;
+var ScopeModuleASsr = (_dec = Scope(), _dec2 = BeanInfo({ module: "a-ssr" }), _dec(_class = _dec2(_class = class ScopeModuleASsr extends BeanScopeBase {}) || _class) || _class);
+/** scope: end */
+//#endregion
+export { CtxSSR, CtxSSRMetaStore, Monkey, MonkeySys, ScopeModuleASsr, SysSsrState, config, unevalPatch };
+
+//# sourceMappingURL=index.js.map