@stencil/core 4.28.2-dev.1742303553.90ea840 → 4.28.2-dev.1742318817.ddf403c

package/internal/hydrate/index.js

@@ -1,5 +1,5 @@
 /*
- Stencil Hydrate Platform v4.28.2-dev.1742303553.90ea840 | MIT Licensed | https://stenciljs.com
+ Stencil Hydrate Platform v4.28.2-dev.1742318817.ddf403c | MIT Licensed | https://stenciljs.com
  */
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -138,6 +138,131 @@ import { BUILD as BUILD18 } from "@stencil/core/internal/app-data";
 // src/runtime/client-hydrate.ts
 import { BUILD as BUILD6 } from "@stencil/core/internal/app-data";
 
+// src/hydrate/runner/serialize.ts
+var PrimitiveType = /* @__PURE__ */ ((PrimitiveType2) => {
+  PrimitiveType2["Undefined"] = "undefined";
+  PrimitiveType2["Null"] = "null";
+  PrimitiveType2["String"] = "string";
+  PrimitiveType2["Number"] = "number";
+  PrimitiveType2["SpecialNumber"] = "number";
+  PrimitiveType2["Boolean"] = "boolean";
+  PrimitiveType2["BigInt"] = "bigint";
+  return PrimitiveType2;
+})(PrimitiveType || {});
+var NonPrimitiveType = /* @__PURE__ */ ((NonPrimitiveType2) => {
+  NonPrimitiveType2["Array"] = "array";
+  NonPrimitiveType2["Date"] = "date";
+  NonPrimitiveType2["Map"] = "map";
+  NonPrimitiveType2["Object"] = "object";
+  NonPrimitiveType2["RegularExpression"] = "regexp";
+  NonPrimitiveType2["Set"] = "set";
+  NonPrimitiveType2["Channel"] = "channel";
+  NonPrimitiveType2["Symbol"] = "symbol";
+  return NonPrimitiveType2;
+})(NonPrimitiveType || {});
+var TYPE_CONSTANT = "type";
+var VALUE_CONSTANT = "value";
+var SERIALIZED_PREFIX = "serialized:";
+function deserializeProperty(value) {
+  if (typeof value !== "string" || !value.startsWith(SERIALIZED_PREFIX)) {
+    return value;
+  }
+  return RemoteValue.fromLocalValue(JSON.parse(atob(value.slice(SERIALIZED_PREFIX.length))));
+}
+var RemoteValue = class _RemoteValue {
+  /**
+   * Deserializes a LocalValue serialized object back to its original JavaScript representation
+   *
+   * @param serialized The serialized LocalValue object
+   * @returns The original JavaScript value/object
+   */
+  static fromLocalValue(serialized) {
+    const type = serialized[TYPE_CONSTANT];
+    const value = VALUE_CONSTANT in serialized ? serialized[VALUE_CONSTANT] : void 0;
+    switch (type) {
+      case "string" /* String */:
+        return value;
+      case "boolean" /* Boolean */:
+        return value;
+      case "bigint" /* BigInt */:
+        return BigInt(value);
+      case "undefined" /* Undefined */:
+        return void 0;
+      case "null" /* Null */:
+        return null;
+      case "number" /* Number */:
+        if (value === "NaN") return NaN;
+        if (value === "-0") return -0;
+        if (value === "Infinity") return Infinity;
+        if (value === "-Infinity") return -Infinity;
+        return value;
+      case "array" /* Array */:
+        return value.map((item) => _RemoteValue.fromLocalValue(item));
+      case "date" /* Date */:
+        return new Date(value);
+      case "map" /* Map */:
+        const map2 = /* @__PURE__ */ new Map();
+        for (const [key, val] of value) {
+          const deserializedKey = typeof key === "object" && key !== null ? _RemoteValue.fromLocalValue(key) : key;
+          const deserializedValue = _RemoteValue.fromLocalValue(val);
+          map2.set(deserializedKey, deserializedValue);
+        }
+        return map2;
+      case "object" /* Object */:
+        const obj = {};
+        for (const [key, val] of value) {
+          obj[key] = _RemoteValue.fromLocalValue(val);
+        }
+        return obj;
+      case "regexp" /* RegularExpression */:
+        const { pattern, flags } = value;
+        return new RegExp(pattern, flags);
+      case "set" /* Set */:
+        const set = /* @__PURE__ */ new Set();
+        for (const item of value) {
+          set.add(_RemoteValue.fromLocalValue(item));
+        }
+        return set;
+      case "symbol" /* Symbol */:
+        return Symbol(value);
+      default:
+        throw new Error(`Unsupported type: ${type}`);
+    }
+  }
+  /**
+   * Utility method to deserialize multiple LocalValues at once
+   *
+   * @param serializedValues Array of serialized LocalValue objects
+   * @returns Array of deserialized JavaScript values
+   */
+  static fromLocalValueArray(serializedValues) {
+    return serializedValues.map((value) => _RemoteValue.fromLocalValue(value));
+  }
+  /**
+   * Verifies if the given object matches the structure of a serialized LocalValue
+   *
+   * @param obj Object to verify
+   * @returns boolean indicating if the object has LocalValue structure
+   */
+  static isLocalValueObject(obj) {
+    if (typeof obj !== "object" || obj === null) {
+      return false;
+    }
+    if (!obj.hasOwnProperty(TYPE_CONSTANT)) {
+      return false;
+    }
+    const type = obj[TYPE_CONSTANT];
+    const hasTypeProperty = Object.values({ ...PrimitiveType, ...NonPrimitiveType }).includes(type);
+    if (!hasTypeProperty) {
+      return false;
+    }
+    if (type !== "null" /* Null */ && type !== "undefined" /* Undefined */) {
+      return obj.hasOwnProperty(VALUE_CONSTANT);
+    }
+    return true;
+  }
+};
+
 // src/runtime/dom-extras.ts
 import { BUILD as BUILD3 } from "@stencil/core/internal/app-data";
 
@@ -912,6 +1037,7 @@ var validateInputProperties = (inputElm) => {
 
 // src/runtime/client-hydrate.ts
 var initializeClientHydrate = (hostElm, tagName, hostId, hostRef) => {
+  var _a;
   const endHydrate = createTime("hydrateClient", tagName);
   const shadowRoot = hostElm.shadowRoot;
   const childRenderNodes = [];
@@ -920,6 +1046,29 @@ var initializeClientHydrate = (hostElm, tagName, hostId, hostRef) => {
   const shadowRootNodes = BUILD6.shadowDom && shadowRoot ? [] : null;
   const vnode = newVNode(tagName, null);
   vnode.$elm$ = hostElm;
+  let attributes;
+  const members = Object.entries(((_a = hostRef.$cmpMeta$) == null ? void 0 : _a.$members$) || {});
+  members.forEach(([memberName, [memberFlags, metaAttributeName]]) => {
+    if (!(memberFlags & 31 /* Prop */)) {
+      return;
+    }
+    const attributeName = metaAttributeName || memberName;
+    let attrValue = hostElm.getAttribute(attributeName);
+    if ((attrValue == null ? void 0 : attrValue.startsWith("{")) && attrValue.endsWith("}") || (attrValue == null ? void 0 : attrValue.startsWith("[")) && attrValue.endsWith("]")) {
+      try {
+        attrValue = JSON.parse(attrValue);
+      } catch (e) {
+      }
+    } else if (attrValue == null ? void 0 : attrValue.startsWith(SERIALIZED_PREFIX)) {
+      attrValue = deserializeProperty(attrValue);
+    }
+    if (!attributes) {
+      attributes = {};
+    }
+    attributes[attributeName] = attrValue;
+    hostRef.$instanceValues$.set(attributeName, attrValue);
+  });
+  vnode.$attrs$ = attributes;
   let scopeId2;
   if (BUILD6.scoped) {
     const cmpMeta = hostRef.$cmpMeta$;
@@ -2452,7 +2601,11 @@ var renderVdom = (hostRef, renderFnResults, isInitialLoad = false) => {
   const hostElm = hostRef.$hostElement$;
   const cmpMeta = hostRef.$cmpMeta$;
   const oldVNode = hostRef.$vnode$ || newVNode(null, null);
-  const rootVnode = isHost(renderFnResults) ? renderFnResults : h(null, null, renderFnResults);
+  const isHostElem = isHost(renderFnResults);
+  const rootVnode = isHostElem ? renderFnResults : h(null, null, renderFnResults);
+  if (isInitialLoad && !isHostElem && hostRef.$vnode$) {
+    rootVnode.$attrs$ = hostRef.$vnode$.$attrs$ || {};
+  }
   hostTagName = hostElm.tagName;
   if (BUILD13.isDev && Array.isArray(renderFnResults) && renderFnResults.some(isHost)) {
     throw new Error(`The <Host> must be the single root component.
@@ -3853,129 +4006,6 @@ import { globalScripts } from "@stencil/core/internal/app-globals";
 
 // src/hydrate/platform/proxy-host-element.ts
 import { BUILD as BUILD23 } from "@stencil/core/internal/app-data";
-
-// src/hydrate/runner/serialize.ts
-var PrimitiveType = /* @__PURE__ */ ((PrimitiveType2) => {
-  PrimitiveType2["Undefined"] = "undefined";
-  PrimitiveType2["Null"] = "null";
-  PrimitiveType2["String"] = "string";
-  PrimitiveType2["Number"] = "number";
-  PrimitiveType2["SpecialNumber"] = "number";
-  PrimitiveType2["Boolean"] = "boolean";
-  PrimitiveType2["BigInt"] = "bigint";
-  return PrimitiveType2;
-})(PrimitiveType || {});
-var NonPrimitiveType = /* @__PURE__ */ ((NonPrimitiveType2) => {
-  NonPrimitiveType2["Array"] = "array";
-  NonPrimitiveType2["Date"] = "date";
-  NonPrimitiveType2["Map"] = "map";
-  NonPrimitiveType2["Object"] = "object";
-  NonPrimitiveType2["RegularExpression"] = "regexp";
-  NonPrimitiveType2["Set"] = "set";
-  NonPrimitiveType2["Channel"] = "channel";
-  NonPrimitiveType2["Symbol"] = "symbol";
-  return NonPrimitiveType2;
-})(NonPrimitiveType || {});
-var TYPE_CONSTANT = "type";
-var VALUE_CONSTANT = "value";
-function deserializeProperty(value) {
-  return RemoteValue.fromLocalValue(value);
-}
-var RemoteValue = class _RemoteValue {
-  /**
-   * Deserializes a LocalValue serialized object back to its original JavaScript representation
-   *
-   * @param serialized The serialized LocalValue object
-   * @returns The original JavaScript value/object
-   */
-  static fromLocalValue(serialized) {
-    const type = serialized[TYPE_CONSTANT];
-    const value = VALUE_CONSTANT in serialized ? serialized[VALUE_CONSTANT] : void 0;
-    switch (type) {
-      case "string" /* String */:
-        return value;
-      case "boolean" /* Boolean */:
-        return value;
-      case "bigint" /* BigInt */:
-        return BigInt(value);
-      case "undefined" /* Undefined */:
-        return void 0;
-      case "null" /* Null */:
-        return null;
-      case "number" /* Number */:
-        if (value === "NaN") return NaN;
-        if (value === "-0") return -0;
-        if (value === "Infinity") return Infinity;
-        if (value === "-Infinity") return -Infinity;
-        return value;
-      case "array" /* Array */:
-        return value.map((item) => _RemoteValue.fromLocalValue(item));
-      case "date" /* Date */:
-        return new Date(value);
-      case "map" /* Map */:
-        const map2 = /* @__PURE__ */ new Map();
-        for (const [key, val] of value) {
-          const deserializedKey = typeof key === "object" && key !== null ? _RemoteValue.fromLocalValue(key) : key;
-          const deserializedValue = _RemoteValue.fromLocalValue(val);
-          map2.set(deserializedKey, deserializedValue);
-        }
-        return map2;
-      case "object" /* Object */:
-        const obj = {};
-        for (const [key, val] of value) {
-          obj[key] = _RemoteValue.fromLocalValue(val);
-        }
-        return obj;
-      case "regexp" /* RegularExpression */:
-        const { pattern, flags } = value;
-        return new RegExp(pattern, flags);
-      case "set" /* Set */:
-        const set = /* @__PURE__ */ new Set();
-        for (const item of value) {
-          set.add(_RemoteValue.fromLocalValue(item));
-        }
-        return set;
-      case "symbol" /* Symbol */:
-        return Symbol(value);
-      default:
-        throw new Error(`Unsupported type: ${type}`);
-    }
-  }
-  /**
-   * Utility method to deserialize multiple LocalValues at once
-   *
-   * @param serializedValues Array of serialized LocalValue objects
-   * @returns Array of deserialized JavaScript values
-   */
-  static fromLocalValueArray(serializedValues) {
-    return serializedValues.map((value) => _RemoteValue.fromLocalValue(value));
-  }
-  /**
-   * Verifies if the given object matches the structure of a serialized LocalValue
-   *
-   * @param obj Object to verify
-   * @returns boolean indicating if the object has LocalValue structure
-   */
-  static isLocalValueObject(obj) {
-    if (typeof obj !== "object" || obj === null) {
-      return false;
-    }
-    if (!obj.hasOwnProperty(TYPE_CONSTANT)) {
-      return false;
-    }
-    const type = obj[TYPE_CONSTANT];
-    const hasTypeProperty = Object.values({ ...PrimitiveType, ...NonPrimitiveType }).includes(type);
-    if (!hasTypeProperty) {
-      return false;
-    }
-    if (type !== "null" /* Null */ && type !== "undefined" /* Undefined */) {
-      return obj.hasOwnProperty(VALUE_CONSTANT);
-    }
-    return true;
-  }
-};
-
-// src/hydrate/platform/proxy-host-element.ts
 function proxyHostElement(elm, cstr) {
   const cmpMeta = cstr.cmpMeta;
   if (typeof elm.componentOnReady !== "function") {
@@ -4005,11 +4035,10 @@ function proxyHostElement(elm, cstr) {
         if ((attrValue == null ? void 0 : attrValue.startsWith("{")) && attrValue.endsWith("}") || (attrValue == null ? void 0 : attrValue.startsWith("[")) && attrValue.endsWith("]")) {
           try {
             attrValue = JSON.parse(attrValue);
-            if (TYPE_CONSTANT in attrValue) {
-              attrValue = deserializeProperty(attrValue);
-            }
           } catch (e) {
           }
+        } else if (attrValue == null ? void 0 : attrValue.startsWith(SERIALIZED_PREFIX)) {
+          attrValue = deserializeProperty(attrValue);
         }
         const { get: origGetter, set: origSetter } = Object.getOwnPropertyDescriptor(cstr.prototype, memberName) || {};
         let attrPropVal;

package/internal/hydrate/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stencil/core/internal/hydrate",
-  "version": "4.28.2-dev.1742303553.90ea840",
+  "version": "4.28.2-dev.1742318817.ddf403c",
   "description": "Stencil internal hydrate platform to be imported by the Stencil Compiler. Breaking changes can and will happen at any time.",
   "main": "./index.js",
   "private": true

package/internal/hydrate/runner.d.ts

@@ -255,66 +255,17 @@ export declare function renderToString(html: string | any, options: SerializeDoc
 export declare function hydrateDocument(doc: any | string, options?: HydrateDocumentOptions): Promise<HydrateResults>;
 export declare function hydrateDocument(doc: any | string, options: HydrateDocumentOptions | undefined, asStream?: boolean): Readable;
 export declare function serializeDocumentToString(doc: Document, opts: HydrateFactoryOptions): string;
-export type ScriptLocalValue = ScriptPrimitiveProtocolValue | ScriptArrayLocalValue | ScriptDateLocalValue | ScriptSymbolValue | ScriptMapLocalValue | ScriptObjectLocalValue | ScriptRegExpLocalValue | ScriptSetLocalValue;
-export type ScriptListLocalValue = ScriptLocalValue[];
-export interface ScriptArrayLocalValue {
-	type: "array";
-	value: ScriptListLocalValue;
-}
-export interface ScriptDateLocalValue {
-	type: "date";
-	value: string;
-}
-export type ScriptMappingLocalValue = (ScriptLocalValue | ScriptLocalValue)[];
-export interface ScriptMapLocalValue {
-	type: "map";
-	value: ScriptMappingLocalValue;
-}
-export interface ScriptObjectLocalValue {
-	type: "object";
-	value: ScriptMappingLocalValue;
-}
-export interface ScriptRegExpValue {
-	pattern: string;
-	flags?: string;
-}
-export interface ScriptRegExpLocalValue {
-	type: "regexp";
-	value: ScriptRegExpValue;
-}
-export interface ScriptSetLocalValue {
-	type: "set";
-	value: ScriptListLocalValue;
-}
-export type ScriptPrimitiveProtocolValue = ScriptUndefinedValue | ScriptNullValue | ScriptStringValue | ScriptNumberValue | ScriptBooleanValue | ScriptBigIntValue;
-export interface ScriptUndefinedValue {
-	type: "undefined";
-}
-export interface ScriptNullValue {
-	type: "null";
-}
-export interface ScriptStringValue {
-	type: "string";
-	value: string;
-}
-export interface ScriptSymbolValue {
-	type: "symbol";
-	value: string;
-}
-export type ScriptSpecialNumber = "NaN" | "-0" | "Infinity" | "-Infinity";
-export interface ScriptNumberValue {
-	type: "number";
-	value: number | ScriptSpecialNumber;
-}
-export interface ScriptBooleanValue {
-	type: "boolean";
-	value: boolean;
-}
-export interface ScriptBigIntValue {
-	type: "bigint";
-	value: string;
-}
-export declare function serializeProperty(value: unknown): string;
-export declare function deserializeProperty(value: ScriptLocalValue): any;
+/**
+ * Serialize a value to a string that can be deserialized later.
+ * @param {unknown} value - The value to serialize.
+ * @returns {string} A string that can be deserialized later.
+ */
+export declare function serializeProperty(value: unknown): string | number | boolean;
+/**
+ * Deserialize a value from a string that was serialized earlier.
+ * @param {string} value - The string to deserialize.
+ * @returns {unknown} The deserialized value.
+ */
+export declare function deserializeProperty(value: string): any;
 
 export {};