@dooboostore/dom-render 1.0.111 → 1.0.113

package/dist/cjs/DomRenderProxy.js

@@ -26,7 +26,6 @@ __export(DomRenderProxy_exports, {
 module.exports = __toCommonJS(DomRenderProxy_exports);
 var import_RawSet = require("./rawsets/RawSet");
 var import_EventManager = require("./events/EventManager");
-var import_ScriptUtils = require("@dooboostore/core-web/script/ScriptUtils");
 var import_Types = require("./types/Types");
 var import_RawSetType = require("./rawsets/RawSetType");
 var import_DrThisProperty = require("./operators/DrThisProperty");
@@ -37,27 +36,28 @@ var import_OnCreateRender = require("./lifecycle/OnCreateRender");
 var import_OnInitRender = require("./lifecycle/OnInitRender");
 var import_OnCreateRenderData = require("./lifecycle/OnCreateRenderData");
 var import_OnChangeAttrRender = require("./lifecycle/OnChangeAttrRender");
-var import_DocumentUtils = require("@dooboostore/core-web/document/DocumentUtils");
-var import_types = require("@dooboostore/core/types");
+var import_core_web = require("@dooboostore/core-web");
 var import_OnBeforeReturnSet = require("./lifecycle/OnBeforeReturnSet");
 var import_OnChildRenderedByProperty = require("./lifecycle/OnChildRenderedByProperty");
-var import_ObjectUtils = require("@dooboostore/core/object/ObjectUtils");
-var import_ValidUtils = require("@dooboostore/core/valid/ValidUtils");
+var import_core = require("@dooboostore/core");
+var import_core2 = require("@dooboostore/core");
 var import_OnProxyDomRender = require("./lifecycle/OnProxyDomRender");
 var import_OnRawSetRendered = require("./lifecycle/OnRawSetRendered");
+var import_OnChildRawSetRendered = require("./lifecycle/OnChildRawSetRendered");
+var import_rawsets = require("./rawsets");
 const excludeGetSetPropertys = [
-  "onBeforeReturnGet",
-  "onBeforeReturnSet",
-  "__domrender_components",
-  "__render",
-  "_DomRender_isFinal",
-  "_domRender_ref",
-  "_rawSets",
-  "_domRender_proxy",
-  "_targets",
-  "_DomRender_origin",
-  "_DomRender_ref",
-  "_DomRender_proxy"
+  import_rawsets.DomRenderComponentMetaKey.DOMRENDER_COMPONENTS_KEY,
+  import_rawsets.DomRenderProxyMetaKey.onBeforeReturnGet,
+  import_rawsets.DomRenderProxyMetaKey.onBeforeReturnSet,
+  import_rawsets.DomRenderProxyMetaKey.__render,
+  import_rawsets.DomRenderProxyMetaKey._rawSets,
+  import_rawsets.DomRenderProxyMetaKey._targets,
+  import_rawsets.DomRenderProxyMetaKey._domRender_proxy,
+  import_rawsets.DomRenderProxyMetaKey._DomRender_isFinal,
+  import_rawsets.DomRenderProxyMetaKey._domRender_ref,
+  import_rawsets.DomRenderProxyMetaKey._DomRender_origin,
+  import_rawsets.DomRenderProxyMetaKey._DomRender_ref,
+  import_rawsets.DomRenderProxyMetaKey._DomRender_proxy
 ];
 const isWrapProxyDomRenderProxy = (obj) => {
   return obj && typeof obj === "object" && "_DomRender_isProxy" in obj;
@@ -81,12 +81,12 @@ const getDomRenderProxy = (obj) => {
   return void 0;
 };
 class DomRenderProxy {
+  // public name = Math.random();
   constructor(_domRender_origin, target, _domRender_config) {
     this._domRender_origin = _domRender_origin;
     this._domRender_config = _domRender_config;
     this._domRender_ref = /* @__PURE__ */ new Map();
     this._rawSets = /* @__PURE__ */ new Map();
-    // public _firstTarget: Node;
     this._targets = /* @__PURE__ */ new Set();
     if (target) {
       this._targets.add(target);
@@ -99,7 +99,16 @@ class DomRenderProxy {
     return import_Types.DomRenderFinalProxy.final(obj);
   }
   static isFinal(obj) {
-    return import_ValidUtils.ValidUtils.isNull(obj) || import_Types.DomRenderFinalProxy.isFinal(obj);
+    return import_core2.ValidUtils.isNull(obj) || import_Types.DomRenderFinalProxy.isFinal(obj);
+  }
+  static isProxy(obj) {
+    return import_core2.ValidUtils.isNull(obj) || isWrapProxyDomRenderProxy(obj);
+  }
+  static getOriginalObject(obj) {
+    if (isWrapProxyDomRenderProxy(obj)) {
+      return obj._domRender_origin;
+    }
+    return obj;
   }
   async run(objProxy) {
     this._domRender_proxy = objProxy;
@@ -137,7 +146,7 @@ class DomRenderProxy {
     const onCreate = target.getAttribute?.(import_RawSet.RawSet.DR_ON_CREATE_ARGUMENTS_OPTIONNAME);
     let createParam = [];
     if (onCreate) {
-      createParam = import_ObjectUtils.ObjectUtils.Script.evaluateReturn(onCreate, this._domRender_proxy);
+      createParam = import_core.ObjectUtils.Script.evaluateReturn(onCreate, this._domRender_proxy);
       if (!Array.isArray(createParam)) {
         createParam = [createParam];
       }
@@ -167,10 +176,9 @@ class DomRenderProxy {
     });
     const targetRawSets = await this.render(this.getRawSets());
     for (let targetRawSet of targetRawSets) {
-      const onInit = target.getAttribute?.(import_RawSet.RawSet.DR_ON_INIT_ARGUMENTS_OPTIONNAME);
       let initParam;
       if (onCreate) {
-        initParam = import_ScriptUtils.ScriptUtils.evaluateReturn(onCreate, this._domRender_proxy);
+        initParam = import_core.ObjectUtils.Script.evaluateReturn(onCreate, this._domRender_proxy);
       }
       if ((0, import_OnInitRender.isOnInitRender)(this._domRender_proxy)) {
         await this._domRender_proxy.onInitRender(
@@ -199,50 +207,63 @@ class DomRenderProxy {
     }
     const removeRawSets = [];
     const rawSets = raws ?? this.getRawSets();
-    for (const it of rawSets) {
-      it.getUsingTriggerVariables(this._domRender_config).forEach((path) => {
-        this.addRawSet(path, it);
-      });
-      let renderResult;
-      if (it.isConnected) {
-        const targetAttrMap = it.point.node?.getAttribute?.(import_EventManager.EventManager.normalAttrMapAttrName);
-        if (it.detect?.action) {
-          it.detect.action();
-        } else if (it.type === import_RawSetType.RawSetType.TARGET_ELEMENT && it.dataSet?.render?.currentThis && fullPathStr && targetAttrMap) {
-          new Map(JSON.parse(targetAttrMap)).forEach((v, k) => {
-            var _a;
-            const isUsing = v.variablePaths.some((it2) => import_EventManager.EventManager.isUsingThisVar(it2.inner, `this.${fullPathStr}`));
-            if (isUsing) {
-              const targetAttrObject = import_RawSet.RawSet.getAttributeObject(it.point.node, {
-                script: it.dataSet?.render?.renderScript ?? "",
-                obj: Object.assign(this._domRender_proxy ?? {}, { __render: it.dataSet?.render })
-              });
-              (_a = it.dataSet).render ?? (_a.render = {});
-              it.dataSet.render.attribute = targetAttrObject;
-              if ((0, import_OnChangeAttrRender.isOnChangeAttrRender)(it.dataSet?.render?.currentThis)) {
-                it.dataSet?.render?.currentThis?.onChangeAttrRender?.(k, targetAttrObject[k], { rawSet: it });
-              }
+    const CHUNK_SIZE = 50;
+    const chunks = [];
+    let rawSetsArray = Array.from(rawSets);
+    for (const rawSet of rawSetsArray) {
+      await this.renderExecute(rawSet, fullPathStr, removeRawSets);
+    }
+    if ((0, import_OnChildRawSetRendered.isOnChildRawSetRendered)(this._domRender_proxy)) {
+      await this._domRender_proxy.onChildRawSetRendered();
+    }
+    if (removeRawSets.length > 0) {
+      this.removeRawSet(...removeRawSets);
+    }
+    return this.getRawSets();
+  }
+  async renderExecute(it, fullPathStr, removeRawSets) {
+    it.getUsingTriggerVariables(this._domRender_config).forEach((path) => {
+      this.addRawSet(path, it);
+    });
+    let renderResult;
+    if (it.isConnected) {
+      const targetAttrMap = it.point.node?.getAttribute?.(import_EventManager.EventManager.normalAttrMapAttrName);
+      if (it.detect?.action) {
+        it.detect.action();
+      } else if (it.type === import_RawSetType.RawSetType.TARGET_ELEMENT && it.dataSet?.render?.currentThis && fullPathStr && targetAttrMap) {
+        const attrStart = performance.now();
+        new Map(JSON.parse(targetAttrMap)).forEach((v, k) => {
+          var _a;
+          const isUsing = v.variablePaths.some((it2) => import_EventManager.EventManager.isUsingThisVar(it2.inner, `this.${fullPathStr}`));
+          if (isUsing) {
+            const targetAttrObject = import_RawSet.RawSet.getAttributeObject(it.point.node, {
+              script: it.dataSet?.render?.renderScript ?? "",
+              obj: Object.assign(this._domRender_proxy ?? {}, { __render: it.dataSet?.render })
+            });
+            (_a = it.dataSet).render ?? (_a.render = {});
+            it.dataSet.render.attribute = targetAttrObject;
+            if ((0, import_OnChangeAttrRender.isOnChangeAttrRender)(it.dataSet?.render?.currentThis)) {
+              it.dataSet?.render?.currentThis?.onChangeAttrRender?.(k, targetAttrObject[k], { rawSet: it });
             }
-          });
-        } else {
-          const rawSets2 = await it.render(this._domRender_proxy, this._domRender_config);
-          renderResult = rawSets2;
-          if (rawSets2 && rawSets2.raws.length > 0) {
-            await this.render(rawSets2.raws);
           }
-        }
+        });
+        const attrEnd = performance.now();
       } else {
-        removeRawSets.push(it);
-      }
-      const t = it.findNearThis(this._domRender_proxy);
-      if ((0, import_OnRawSetRendered.isOnRawSetRendered)(t)) {
-        await t.onRawSetRendered(it, { path: fullPathStr, renderResult });
+        const renderStart = performance.now();
+        const rawSets = await it.render(this._domRender_proxy, this._domRender_config);
+        const renderEnd = performance.now();
+        renderResult = rawSets;
+        if (rawSets && rawSets.raws.length > 0) {
+          await this.render(rawSets.raws);
+        }
       }
+    } else {
+      removeRawSets.push(it);
     }
-    if (removeRawSets.length > 0) {
-      this.removeRawSet(...removeRawSets);
+    const t = it.findNearThis(this._domRender_proxy);
+    if ((0, import_OnRawSetRendered.isOnRawSetRendered)(t)) {
+      await t.onRawSetRendered(it, { path: fullPathStr, value: import_core.ObjectUtils.Script.evaluateReturn(`this.${fullPathStr}`, this._domRender_proxy), root: this._domRender_proxy, renderResult });
     }
-    return this.getRawSets();
   }
   // domrender_ref로 찾는걸로 바꿈
   // public findRootDomRenderProxy(): DomRenderProxy<any> {
@@ -253,12 +274,15 @@ class DomRenderProxy {
   //   return current;
   // }
   root(pathInfos, value, lastDoneExecute = true) {
+    const rootStartTime = Date.now();
+    const pathKey = pathInfos.flat().map((i) => i.path).join(".");
     const fullPaths = [];
     if (this._domRender_ref.size > 0) {
       this._domRender_ref.forEach((it, key) => {
-        if ("_DomRender_isProxy" in key) {
+        if (import_rawsets.DomRenderProxyMetaKey._DomRender_isProxy in key) {
           it.forEach((sit) => {
             try {
+              const recursiveStartTime = Date.now();
               const concat = pathInfos.concat([[{ path: sit, obj: key }]]);
               const items = key._DomRender_proxy?.root(
                 concat,
@@ -272,17 +296,21 @@ class DomRenderProxy {
         }
       });
     } else {
-      const strings = pathInfos.reverse().map((it) => it.map((it2) => it2.path).join(","));
-      const fullPathStr = strings.map((it) => isNaN(Number(it)) ? "." + it : `[${it}]`).join("").slice(1);
+      const pathProcessStartTime = Date.now();
+      const shortPaths = pathInfos.reverse().map((it) => it.map((it2) => it2.path).join(","));
+      const fullPathStr = shortPaths.map((it) => isNaN(Number(it)) ? "." + it : `[${it}]`).join("").slice(1);
       if (lastDoneExecute) {
         const iterable = this._rawSets.get(fullPathStr);
-        const front = strings.slice(0, strings.length - 1).map((it) => isNaN(Number(it)) ? "." + it : `[${it}]`).join("");
-        const lastPropertyName = strings[strings.length - 1];
+        const front = shortPaths.slice(0, shortPaths.length - 1).map((it) => isNaN(Number(it)) ? "." + it : `[${it}]`).join("");
+        const lastPropertyName = shortPaths[shortPaths.length - 1];
         const path = "this" + front;
-        const data = import_ScriptUtils.ScriptUtils.evaluateReturn(import_ObjectUtils.ObjectUtils.Path.toOptionalChainPath(path), this._domRender_proxy);
+        const data = import_core.ObjectUtils.Script.evaluateReturn(import_core.ObjectUtils.Path.toOptionalChainPath(path), this._domRender_proxy);
+        const promiseStartTime = Date.now();
         new Promise(async (resolve) => {
+          const promiseInnerStartTime = Date.now();
           let rData = [];
           const firstPathStr = front.slice(1);
+          const dictionaryCheckStartTime = Date.now();
           const firstTargets = this._rawSets.get(firstPathStr);
           const firstTargetDictionary = [];
           firstTargets?.forEach((it) => {
@@ -324,6 +352,7 @@ class DomRenderProxy {
               rData = await this.render(rawSets);
             }
           }
+          const renderStartTime = Date.now();
           if (lastPropertyName === "length" && Array.isArray(data)) {
             const aIterable = this._rawSets.get(firstPathStr);
             if (aIterable) {
@@ -332,13 +361,17 @@ class DomRenderProxy {
           } else if (iterable) {
             rData = await this.render(Array.from(iterable), fullPathStr);
           }
+          const eventProcessStartTime = Date.now();
           const Node = this._domRender_config.window.Node;
           this._targets.forEach((it) => {
             if (it.nodeType === Node.DOCUMENT_FRAGMENT_NODE || it.nodeType === Node.ELEMENT_NODE) {
+              const findAttrStartTime = Date.now();
               const targets = this._domRender_config.eventManager.findAttrElements(
                 it,
                 this._domRender_config
               );
+              const targetCount = targets?.size || targets?.length || 0;
+              const changeVarStartTime = Date.now();
               this._domRender_config.eventManager.changeVar(
                 this._domRender_proxy,
                 targets,
@@ -348,7 +381,7 @@ class DomRenderProxy {
             }
           });
           if (rData?.length > 0 && (0, import_OnChildRenderedByProperty.isOnChildRenderedByProperty)(data)) {
-            const propertyValue = import_ScriptUtils.ScriptUtils.evaluateReturn(`this.${lastPropertyName}`, data);
+            const propertyValue = import_core.ObjectUtils.Script.evaluateReturn(`this.${lastPropertyName}`, data);
             data.onChildRenderedByProperty(lastPropertyName, propertyValue);
           }
           resolve(rData);
@@ -360,10 +393,11 @@ class DomRenderProxy {
     return fullPaths;
   }
   set(target, p, value, receiver) {
-    if (typeof p === "string" && p !== "__domrender_components" && excludeGetSetPropertys.includes(p) || Reflect.getMetadata(import_DomRenderNoProxy.DomRenderNoProxyKey, target, p)) {
+    if (typeof p === "string" && p !== import_rawsets.DomRenderComponentMetaKey.DOMRENDER_COMPONENTS_KEY && excludeGetSetPropertys.includes(p) || Reflect.getMetadata(import_DomRenderNoProxy.DomRenderNoProxyKey, target, p)) {
       target[p] = value;
       return true;
     }
+    let start = performance.now();
     if (typeof p === "string") {
       value = this.proxy(receiver, value, p);
     }
@@ -376,12 +410,12 @@ class DomRenderProxy {
       fullPathInfo = this.root([[{ path: p, obj: this._domRender_proxy }]], value);
     }
     const rootElement = this._domRender_config.rootElement ?? this._domRender_config.window.document;
-    import_DocumentUtils.DocumentUtils.querySelectorAllByAttributeName(rootElement, import_EventManager.EventManager.normalAttrMapAttrName)?.forEach(
+    import_core_web.DocumentUtils.querySelectorAllByAttributeName(rootElement, import_EventManager.EventManager.normalAttrMapAttrName)?.forEach(
       (elementInfo) => {
         const targets = new Map(
-          import_ObjectUtils.ObjectUtils.Script.evaluateReturn(elementInfo.value)
+          import_core.ObjectUtils.Script.evaluateReturn(elementInfo.value)
         );
-        Array.from(targets.entries()).filter(import_types.isDefined).flatMap(([key, valueScript]) => {
+        Array.from(targets.entries()).filter(import_core2.ValidUtils.isDefined).flatMap(([key, valueScript]) => {
           return fullPathInfo.flat().filter((it) => valueScript.variablePaths?.some((vit) => vit.inner.includes(`this.${it.path}`))).flatMap((it) => ({ key, valueScript, pathInfo: it }));
         }).forEach((it) => {
           const variablePaths = it.valueScript.variablePaths;
@@ -389,21 +423,20 @@ class DomRenderProxy {
           let script;
           if (it.valueScript.isStringTemplate) {
             variablePaths.forEach((it2) => {
-              let r = import_ObjectUtils.ObjectUtils.Path.toOptionalChainPath(it2.inner);
+              let r = import_core.ObjectUtils.Path.toOptionalChainPath(it2.inner);
               targetScript = targetScript.replaceAll(it2.origin, `\${${r}}`);
             });
             script = "`" + targetScript + "`";
           } else {
             variablePaths.forEach((it2) => {
-              let r = import_ObjectUtils.ObjectUtils.Path.toOptionalChainPath(it2.inner);
+              let r = import_core.ObjectUtils.Path.toOptionalChainPath(it2.inner);
               targetScript = targetScript.replaceAll(it2.origin, `${r}`);
             });
             script = targetScript;
           }
-          const value1 = import_ObjectUtils.ObjectUtils.Script.evaluateReturn(script, it.pathInfo.obj);
-          if (value1 === null) {
+          const value1 = import_core.ObjectUtils.Script.evaluateReturn(script, it.pathInfo.obj);
+          if (value1 === null || value1 === void 0) {
             elementInfo.element.removeAttribute(it.key);
-            elementInfo.element[it.key] = null;
           } else {
             elementInfo.element.setAttribute(it.key, value1);
             elementInfo.element[it.key] = value1;
@@ -411,13 +444,13 @@ class DomRenderProxy {
         });
       }
     );
-    import_DocumentUtils.DocumentUtils.querySelectorAllByAttributeName(rootElement, import_EventManager.EventManager.linkTargetMapAttrName)?.forEach(
+    import_core_web.DocumentUtils.querySelectorAllByAttributeName(rootElement, import_EventManager.EventManager.linkTargetMapAttrName)?.forEach(
       (elementInfo) => {
-        const targets = new Map(import_ScriptUtils.ScriptUtils.evaluateReturn(elementInfo.value));
-        Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(import_types.isDefined).flatMap(([key, valueScript]) => {
+        const targets = new Map(import_core.ObjectUtils.Script.evaluateReturn(elementInfo.value));
+        Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(import_core2.ValidUtils.isDefined).flatMap(([key, valueScript]) => {
           return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
         }).forEach((info) => {
-          const value1 = import_ScriptUtils.ScriptUtils.evaluateReturn(info.valueScript, info.pathInfo.obj);
+          const value1 = import_core.ObjectUtils.Script.evaluateReturn(info.valueScript, info.pathInfo.obj);
           const applyAttributeName = import_EventManager.EventManager.linkAttrs.find((it) => it.name === info.key);
           if (applyAttributeName) {
             if (value1 === null) {
@@ -427,7 +460,7 @@ class DomRenderProxy {
             }
           }
         });
-        Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(import_types.isDefined).flatMap(([key, valueScript]) => {
+        Array.from(targets.entries()).filter(([key, value2]) => value2.trim()).filter(import_core2.ValidUtils.isDefined).flatMap(([key, valueScript]) => {
           return fullPathInfo.flat().filter((it) => valueScript.includes(`this.${it.path}`)).flatMap((it) => ({ key, valueScript, pathInfo: it }));
         }).forEach((info) => {
           const linkInfo = import_EventManager.EventManager.linkAttrs.find((it) => it.name === info.key);
@@ -437,7 +470,7 @@ class DomRenderProxy {
         });
       }
     );
-    if ("onBeforeReturnSet" in receiver && typeof p === "string" && !(this._domRender_config.proxyExcludeOnBeforeReturnSets ?? []).concat(excludeGetSetPropertys).includes(p)) {
+    if (import_rawsets.DomRenderProxyMetaKey.onBeforeReturnSet in receiver && typeof p === "string" && !(this._domRender_config.proxyExcludeOnBeforeReturnSets ?? []).concat(excludeGetSetPropertys).includes(p)) {
       if ((0, import_OnBeforeReturnSet.isOnBeforeReturnSet)(receiver)) {
         receiver.onBeforeReturnSet?.(
           p,
@@ -449,20 +482,20 @@ class DomRenderProxy {
     return true;
   }
   get(target, p, receiver) {
-    if (p === "_DomRender_origin" || p === "_domRender_origin") {
+    if (p === import_rawsets.DomRenderProxyMetaKey._DomRender_origin || p === import_rawsets.DomRenderProxyMetaKey._domRender_origin) {
       return this._domRender_origin;
-    } else if (p === "_DomRender_ref" || p === "_domRender_ref") {
+    } else if (p === import_rawsets.DomRenderProxyMetaKey._DomRender_ref || p === import_rawsets.DomRenderProxyMetaKey._domRender_ref) {
       return this._domRender_ref;
-    } else if (p === "_DomRender_config" || p === "_domRender_config") {
+    } else if (p === import_rawsets.DomRenderProxyMetaKey._DomRender_config || p === import_rawsets.DomRenderProxyMetaKey._domRender_config) {
       return this._domRender_config;
-    } else if (p === "_DomRender_proxy" || p === "_domRender_proxy") {
+    } else if (p === import_rawsets.DomRenderProxyMetaKey._DomRender_proxy || p === import_rawsets.DomRenderProxyMetaKey._domRender_proxy) {
       return this;
     } else {
       let it = target[p];
-      if (it && typeof it === "object" && "_DomRender_isProxy" in it && Object.prototype.toString.call(it._DomRender_origin) === "[object Date]") {
+      if (it && typeof it === "object" && import_rawsets.DomRenderProxyMetaKey._DomRender_isProxy in it && Object.prototype.toString.call(it._DomRender_origin) === "[object Date]") {
         it = it._DomRender_origin;
       }
-      if ("onBeforeReturnGet" in receiver && typeof p === "string" && !(this._domRender_config.proxyExcludeOnBeforeReturnGets ?? []).concat(excludeGetSetPropertys).includes(p)) {
+      if (import_rawsets.DomRenderProxyMetaKey.onBeforeReturnGet in receiver && typeof p === "string" && !(this._domRender_config.proxyExcludeOnBeforeReturnGets ?? []).concat(excludeGetSetPropertys).includes(p)) {
         receiver?.onBeforeReturnGet?.(
           p,
           it,
@@ -480,7 +513,7 @@ class DomRenderProxy {
     return true;
   }
   has(target, p) {
-    return p === "_DomRender_isProxy" || p in target;
+    return p === import_rawsets.DomRenderProxyMetaKey._DomRender_isProxy || p in target;
   }
   proxy(parentProxy, obj, p) {
     try {
@@ -490,7 +523,7 @@ class DomRenderProxy {
       const isFinal = isObject && DomRenderProxy.isFinal(obj);
       const isFrozen = Object.isFrozen(obj);
       const isShield = obj instanceof import_Types.Shield;
-      if (obj === void 0 || obj === null || isNoProxy || isExclude || import_ValidUtils.ValidUtils.isNullOrUndefined(obj) || !isObject || isFinal || isFrozen || isShield) {
+      if (obj === void 0 || obj === null || isNoProxy || isExclude || import_core2.ValidUtils.isNullOrUndefined(obj) || !isObject || isFinal || isFrozen || isShield) {
         return obj;
       }
     } catch (e) {
@@ -544,6 +577,27 @@ class DomRenderProxy {
     });
     this.targetGarbageRawSet();
   }
+  // 특정 경로로 시작하는 모든 child RawSet들을 제거
+  // 예: path가 'users'이면 'users[0]', 'users[0].imgUrl', 'users.length' 등 모두 제거
+  removeChildRawSetsByPath(parentPath) {
+    const pathsToRemove = [];
+    this._rawSets.forEach((rawSetSet, path) => {
+      if (path === parentPath || path.startsWith(parentPath + "[") || path.startsWith(parentPath + ".")) {
+        pathsToRemove.push(path);
+      }
+    });
+    if (pathsToRemove.length > 0) {
+      pathsToRemove.forEach((path) => {
+        const rawSetSet = this._rawSets.get(path);
+        if (rawSetSet) {
+          rawSetSet.forEach((rawSet) => {
+            rawSet.remove?.();
+          });
+          this._rawSets.delete(path);
+        }
+      });
+    }
+  }
   targetGarbageRawSet() {
     this._targets.forEach((it) => {
       if (!it.isConnected) {