haori 0.6.0 → 0.6.2

package/dist/src/core.js

@@ -5,6 +5,7 @@
  * アプリケーションの中心的な機能を提供します。
  */
 import Env from './env';
+import Dev from './dev';
 import Expression from './expression';
 import Form from './form';
 import Fragment, { ElementFragment, TextFragment } from './fragment';
@@ -296,20 +297,80 @@ class Core {
         if (!fragment) {
             return Promise.resolve();
         }
-        // DOMに組み込まれている場合はmountedをtrueにする
-        if (element.parentNode) {
-            const parentFragment = Fragment.get(element.parentNode);
-            if (parentFragment?.isMounted()) {
-                fragment.setMounted(true);
-            }
-            else if (document.body.contains(element)) {
-                // document.bodyに含まれている場合はマウント済みとする
-                fragment.setMounted(true);
+        return Core.initializeElementFragment(fragment, false);
+    }
+    /**
+     * 新規 each 行を局所初期化します。
+     * 既存 scan の属性順序を保ちつつ、Fragment 木を直接たどります。
+     *
+     * @param fragment 新規挿入された行フラグメント
+     * @returns 初期化完了の Promise
+     */
+    static initializeFreshEachRow(fragment) {
+        return Core.initializeElementFragment(fragment, true).then(() => {
+            if (Core.needsScheduledEvaluateAll(fragment)) {
+                Core.scheduleEvaluateAll(fragment);
             }
-            else {
-                fragment.setMounted(false);
+            return undefined;
+        });
+    }
+    /**
+     * ElementFragment とその子孫を初期化します。
+     *
+     * @param fragment 対象フラグメント
+     * @param stopAtEach true の場合、data-each 要素では通常再帰を止める
+     * @returns 初期化完了の Promise
+     */
+    static initializeElementFragment(fragment, stopAtEach) {
+        Core.syncMountedState(fragment);
+        if (stopAtEach && fragment.isFreshInitializationSkippable()) {
+            return Promise.resolve();
+        }
+        return Core.initializeElementAttributes(fragment).then(() => {
+            if (Core.shouldSkipChildInitialization(fragment, stopAtEach)) {
+                Core.refreshDerivedSubtreeSignature(fragment);
+                return undefined;
             }
+            const childPromises = [];
+            fragment.getChildren().forEach(child => {
+                if (child instanceof ElementFragment) {
+                    childPromises.push(Core.initializeElementFragment(child, stopAtEach));
+                }
+                else if (child instanceof TextFragment) {
+                    childPromises.push(Core.evaluateText(child));
+                }
+            });
+            return Promise.all(childPromises).then(() => {
+                Core.refreshDerivedSubtreeSignature(fragment);
+                return undefined;
+            });
+        });
+    }
+    /**
+     * 要素初期化時の mounted 状態を同期します。
+     *
+     * @param fragment 対象フラグメント
+     */
+    static syncMountedState(fragment) {
+        const parent = fragment.getParent();
+        if (parent?.isMounted()) {
+            fragment.setMounted(true);
+            return;
         }
+        const target = fragment.getTarget();
+        if (target.parentNode && document.body.contains(target)) {
+            fragment.setMounted(true);
+            return;
+        }
+        fragment.setMounted(false);
+    }
+    /**
+     * scan と fresh clone 初期化で共有する属性初期化を行います。
+     *
+     * @param fragment 対象フラグメント
+     * @returns 属性初期化完了の Promise
+     */
+    static initializeElementAttributes(fragment) {
         let attributeChain = Promise.resolve();
         const processedAttributes = new Set();
         for (const suffix of Core.PRIORITY_ATTRIBUTE_SUFFIXES) {
@@ -338,28 +399,25 @@ class Core {
                 processedAttributes.add(name);
             }
         }
-        return attributeChain
-            .then(() => {
-            const condition = fragment.getAttribute(`${Env.prefix}if`);
-            if (fragment.hasAttribute(`${Env.prefix}if`) &&
-                (condition === false ||
-                    condition === undefined ||
-                    condition === null ||
-                    Number.isNaN(condition))) {
-                return undefined;
-            }
-            const childPromises = [];
-            fragment.getChildren().forEach(child => {
-                if (child instanceof ElementFragment) {
-                    childPromises.push(Core.scan(child.getTarget()));
-                }
-                else if (child instanceof TextFragment) {
-                    childPromises.push(Core.evaluateText(child));
-                }
-            });
-            return Promise.all(childPromises).then(() => undefined);
-        })
-            .then(() => undefined);
+        return attributeChain.then(() => undefined);
+    }
+    /**
+     * 子孫初期化をスキップすべきかどうかを返します。
+     *
+     * @param fragment 対象フラグメント
+     * @param stopAtEach true の場合、data-each 要素で通常再帰を止める
+     * @returns 子孫初期化をスキップするなら true
+     */
+    static shouldSkipChildInitialization(fragment, stopAtEach) {
+        const condition = fragment.getAttribute(`${Env.prefix}if`);
+        if (fragment.hasAttribute(`${Env.prefix}if`) &&
+            (condition === false ||
+                condition === undefined ||
+                condition === null ||
+                Number.isNaN(condition))) {
+            return true;
+        }
+        return stopAtEach && fragment.hasAttribute(`${Env.prefix}each`);
     }
     /**
      * エレメントに属性を設定します。
@@ -380,6 +438,8 @@ class Core {
             return fragment.setAliasedAttribute(name, aliasedAttributeName, value, fromObserver);
         }
         const promises = [];
+        let deriveChangedPromise = null;
+        let nextDeriveInputSignature = null;
         switch (name) {
             case `${Env.prefix}bind`: {
                 if (value === null) {
@@ -392,10 +452,14 @@ class Core {
                 break;
             }
             case `${Env.prefix}derive`:
-                promises.push(Core.evaluateDerive(fragment, value, fragment.getRawAttribute(`${Env.prefix}derive-name`)));
+                nextDeriveInputSignature = Core.createDeriveInputSignature(fragment, value, fragment.getRawAttribute(`${Env.prefix}derive-name`));
+                deriveChangedPromise = Core.evaluateDerive(fragment, value, fragment.getRawAttribute(`${Env.prefix}derive-name`));
+                promises.push(deriveChangedPromise.then(() => undefined));
                 break;
             case `${Env.prefix}derive-name`:
-                promises.push(Core.evaluateDerive(fragment, fragment.getRawAttribute(`${Env.prefix}derive`), value));
+                nextDeriveInputSignature = Core.createDeriveInputSignature(fragment, fragment.getRawAttribute(`${Env.prefix}derive`), value);
+                deriveChangedPromise = Core.evaluateDerive(fragment, fragment.getRawAttribute(`${Env.prefix}derive`), value);
+                promises.push(deriveChangedPromise.then(() => undefined));
                 break;
             case `${Env.prefix}if`:
                 promises.push(Core.evaluateIf(fragment));
@@ -433,9 +497,14 @@ class Core {
         }
         return Promise.all(promises)
             .then(() => {
-            if (name === `${Env.prefix}derive` ||
-                name === `${Env.prefix}derive-name`) {
-                return Core.reevaluateChildren(fragment);
+            if (deriveChangedPromise !== null) {
+                fragment.setDeriveInputSignature(nextDeriveInputSignature);
+                return deriveChangedPromise.then(changed => {
+                    if (!changed) {
+                        return undefined;
+                    }
+                    return Core.reevaluateChildren(fragment);
+                });
             }
             return undefined;
         })
@@ -628,28 +697,90 @@ class Core {
         const hasDerive = fragment.hasAttribute(`${Env.prefix}derive`);
         const hasIf = fragment.hasAttribute(`${Env.prefix}if`);
         const hasEach = fragment.hasAttribute(`${Env.prefix}each`);
+        const deriveExpression = fragment.getRawAttribute(`${Env.prefix}derive`);
+        const deriveName = fragment.getRawAttribute(`${Env.prefix}derive-name`);
+        let shouldSkipDerivedSubtree = false;
+        let shouldRecordDerivedSubtreeSignature = false;
+        let nextDerivedSubtreeSignature = null;
+        if (!hasDerive && fragment.getDeriveSubtreeSignature() !== null) {
+            fragment.setDeriveSubtreeSignature(null);
+        }
+        if (!hasDerive && fragment.getDeriveInputSignature() !== null) {
+            fragment.setDeriveInputSignature(null);
+        }
         if (hasDerive) {
-            chain = chain.then(() => Core.evaluateDerive(fragment));
+            const nextDeriveInputSignature = Core.createDeriveInputSignature(fragment, deriveExpression, deriveName);
+            if (nextDeriveInputSignature === null) {
+                if (fragment.getDeriveInputSignature() !== null) {
+                    fragment.setDeriveInputSignature(null);
+                }
+                chain = chain.then(() => Core.evaluateDerive(fragment, deriveExpression, deriveName).then(() => undefined));
+            }
+            else if (fragment.getDeriveInputSignature() !== nextDeriveInputSignature) {
+                chain = chain.then(() => {
+                    return Core.evaluateDerive(fragment, deriveExpression, deriveName).then(() => {
+                        fragment.setDeriveInputSignature(nextDeriveInputSignature);
+                        return undefined;
+                    });
+                });
+            }
         }
         if (hasIf) {
             chain = chain.then(() => Core.evaluateIf(fragment));
         }
         if (hasEach) {
+            if (fragment.getDeriveSubtreeSignature() !== null) {
+                fragment.setDeriveSubtreeSignature(null);
+            }
             return chain.then(() => Core.evaluateEach(fragment));
         }
         if (hasIf) {
+            if (fragment.getDeriveSubtreeSignature() !== null) {
+                fragment.setDeriveSubtreeSignature(null);
+            }
             return chain.then(() => undefined);
         }
-        const promises = [];
-        fragment.getChildren().forEach(child => {
-            if (child instanceof ElementFragment) {
-                promises.push(Core.evaluateAll(child, skipFragments));
+        if (hasDerive) {
+            chain = chain.then(() => {
+                if (!Core.canSkipStableDerivedSubtree(fragment)) {
+                    fragment.setDeriveSubtreeSignature(null);
+                    Core.logDerivedSubtreeProfileSnapshot(fragment, 'skip-ineligible');
+                    return;
+                }
+                nextDerivedSubtreeSignature = Core.createDescendantBindingSignature(fragment, 'evaluateAll');
+                shouldRecordDerivedSubtreeSignature = true;
+                shouldSkipDerivedSubtree =
+                    fragment.getDeriveSubtreeSignature() !== null &&
+                        fragment.getDeriveSubtreeSignature() === nextDerivedSubtreeSignature;
+                Core.logDerivedSubtreeProfileSnapshot(fragment, shouldSkipDerivedSubtree ? 'skip-hit' : 'skip-miss');
+            });
+        }
+        return chain
+            .then(() => {
+            if (shouldSkipDerivedSubtree) {
+                return undefined;
             }
-            else if (child instanceof TextFragment) {
-                promises.push(Core.evaluateText(child));
+            const promises = [];
+            fragment.getChildren().forEach(child => {
+                if (child instanceof ElementFragment) {
+                    if (Core.canSkipUnchangedNestedEach(child)) {
+                        return;
+                    }
+                    promises.push(Core.evaluateAll(child, skipFragments));
+                }
+                else if (child instanceof TextFragment) {
+                    promises.push(Core.evaluateText(child));
+                }
+            });
+            return Promise.all(promises).then(() => undefined);
+        })
+            .then(() => {
+            if (shouldRecordDerivedSubtreeSignature &&
+                nextDerivedSubtreeSignature !== null) {
+                fragment.setDeriveSubtreeSignature(nextDerivedSubtreeSignature);
             }
+            return undefined;
         });
-        return chain.then(() => Promise.all(promises)).then(() => undefined);
     }
     /**
      * data-derive / data-derive-name を評価し、子孫要素向けの派生値を更新します。
@@ -660,22 +791,32 @@ class Core {
      * @returns Promise (評価完了時に解決)
      */
     static evaluateDerive(fragment, deriveExpression = fragment.getRawAttribute(`${Env.prefix}derive`), deriveName = fragment.getRawAttribute(`${Env.prefix}derive-name`)) {
-        const normalizedName = typeof deriveName === 'string'
-            ? deriveName.trim()
-            : '';
+        const previousDerivedBindingData = fragment.getRawDerivedBindingData();
+        const normalizedName = typeof deriveName === 'string' ? deriveName.trim() : '';
         if (!deriveExpression || normalizedName === '') {
+            if (previousDerivedBindingData === null) {
+                return Promise.resolve(false);
+            }
             fragment.setDerivedBindingData(null);
-            return Promise.resolve();
+            return Promise.resolve(true);
         }
         const result = Expression.evaluateDetailed(deriveExpression, fragment.getBindingData());
         if (result.unresolvedReference) {
+            if (previousDerivedBindingData === null) {
+                return Promise.resolve(false);
+            }
             fragment.setDerivedBindingData(null);
-            return Promise.resolve();
+            return Promise.resolve(true);
         }
-        fragment.setDerivedBindingData({
+        const nextDerivedBindingData = {
             [normalizedName]: result.value,
-        });
-        return Promise.resolve();
+        };
+        if (Core.createBindingSignature(previousDerivedBindingData) ===
+            Core.createBindingSignature(nextDerivedBindingData)) {
+            return Promise.resolve(false);
+        }
+        fragment.setDerivedBindingData(nextDerivedBindingData);
+        return Promise.resolve(true);
     }
     /**
      * テキストフラグメントを評価します。
@@ -739,6 +880,11 @@ class Core {
             return Promise.reject(new Error('Invalid each attribute.'));
         }
         let template = fragment.getTemplate();
+        const keyArg = fragment.getAttribute(`${Env.prefix}each-key`);
+        const nextEachInputSignature = Core.createBindingSignature({
+            key: keyArg ? String(keyArg) : null,
+            items: data,
+        });
         if (template === null) {
             // テンプレートの作成
             let found = false;
@@ -753,6 +899,7 @@ class Core {
                     }
                     // 最初のElementFragmentをテンプレートとして採用
                     template = child.clone();
+                    Core.markFreshInitializationSkippable(template);
                     fragment.setTemplate(template);
                     found = true;
                     // 元のchildはchildrenから除外
@@ -767,9 +914,16 @@ class Core {
                 // TextNodeやCommentNodeはテンプレートにならないので無視
             });
             // テンプレートのunmount完了後にupdateDiffを実行
-            return this.updateDiff(fragment, data);
+            return this.updateDiff(fragment, data).then(() => {
+                fragment.setEachInputSignature(nextEachInputSignature);
+            });
         }
-        return this.updateDiff(fragment, data);
+        if (fragment.getEachInputSignature() === nextEachInputSignature) {
+            return Promise.resolve();
+        }
+        return this.updateDiff(fragment, data).then(() => {
+            fragment.setEachInputSignature(nextEachInputSignature);
+        });
     }
     /**
      * data-each 属性値を仕様に従って配列へ正規化します。
@@ -792,6 +946,307 @@ class Core {
         Log.error('[Haori]', 'Invalid each attribute:', data);
         return null;
     }
+    /**
+     * nested data-each の入力が同値で、要素自身に他の動的要素が無い場合は
+     * evaluateAll の子走査を省略できるかどうかを返します。
+     *
+     * @param fragment 判定対象フラグメント
+     * @returns 省略可能なら true
+     */
+    static canSkipUnchangedNestedEach(fragment) {
+        if (!fragment.hasAttribute(`${Env.prefix}each`)) {
+            return false;
+        }
+        if (fragment.getEachInputSignature() === null) {
+            return false;
+        }
+        const parent = fragment.getParent();
+        if (parent?.closestByAttribute(`${Env.prefix}derive`) ||
+            parent?.closestByAttribute(`${Env.prefix}derive-name`) ||
+            parent?.closestByAttribute(`${Env.prefix}if`) ||
+            parent?.closestByAttribute(`${Env.prefix}fetch`) ||
+            parent?.closestByAttribute(`${Env.prefix}import`)) {
+            return false;
+        }
+        if (Core.hasNonEachDynamicElementState(fragment)) {
+            return false;
+        }
+        const data = Core.resolveEachItems(fragment);
+        if (data === null) {
+            return false;
+        }
+        const keyArg = fragment.getAttribute(`${Env.prefix}each-key`);
+        const nextEachInputSignature = Core.createBindingSignature({
+            key: keyArg ? String(keyArg) : null,
+            items: data,
+        });
+        return fragment.getEachInputSignature() === nextEachInputSignature;
+    }
+    /**
+     * data-derive subtree の入力が同値で、保守条件も満たす場合に
+     * 子走査を省略できるかどうかを返します。
+     *
+     * @param fragment 判定対象フラグメント
+     * @returns 省略可能なら true
+     */
+    static canSkipStableDerivedSubtree(fragment) {
+        if (!fragment.hasAttribute(`${Env.prefix}derive`)) {
+            return false;
+        }
+        if (fragment.hasAttribute(`${Env.prefix}if`) ||
+            fragment.hasAttribute(`${Env.prefix}each`) ||
+            fragment.hasAttribute(`${Env.prefix}fetch`) ||
+            fragment.hasAttribute(`${Env.prefix}import`)) {
+            return false;
+        }
+        return !Core.hasDisallowedDerivedSubtreeDescendant(fragment);
+    }
+    /**
+     * data-derive subtree skip の初期 PoC で扱わない子孫要素を含むかを返します。
+     *
+     * @param fragment 判定対象フラグメント
+     * @returns 含むなら true
+     */
+    static hasDisallowedDerivedSubtreeDescendant(fragment) {
+        return fragment.getChildren().some(child => {
+            if (!(child instanceof ElementFragment)) {
+                return false;
+            }
+            if (child.hasAttribute(`${Env.prefix}derive`) ||
+                child.hasAttribute(`${Env.prefix}derive-name`) ||
+                child.hasAttribute(`${Env.prefix}fetch`) ||
+                child.hasAttribute(`${Env.prefix}import`)) {
+                return true;
+            }
+            return Core.hasDisallowedDerivedSubtreeDescendant(child);
+        });
+    }
+    /**
+     * data-derive host が子孫要素へ公開している binding の署名を返します。
+     *
+     * @param fragment 対象フラグメント
+     * @returns binding 署名
+     */
+    static createDescendantBindingSignature(fragment, source) {
+        Core.recordDerivedSubtreeSignatureComputation(fragment, source);
+        return Core.createBindingSignature(fragment.getDescendantBindingData());
+    }
+    /**
+     * data-derive 実行前の入力署名を返します。
+     *
+     * @param fragment 対象フラグメント
+     * @param deriveExpression 導出式
+     * @param deriveName 導出名
+     * @returns 入力署名。導出が無効なら null
+     */
+    static createDeriveInputSignature(fragment, deriveExpression, deriveName) {
+        const normalizedName = typeof deriveName === 'string' ? deriveName.trim() : '';
+        if (!deriveExpression || normalizedName === '') {
+            return null;
+        }
+        return Core.createBindingSignature({
+            expression: deriveExpression,
+            name: normalizedName,
+            scope: fragment.getBindingData(),
+        });
+    }
+    /**
+     * data-derive subtree skip 用の署名を現在状態で更新します。
+     *
+     * @param fragment 対象フラグメント
+     */
+    static refreshDerivedSubtreeSignature(fragment) {
+        if (!Core.canSkipStableDerivedSubtree(fragment)) {
+            fragment.setDeriveSubtreeSignature(null);
+            Core.logDerivedSubtreeProfileSnapshot(fragment, 'skip-ineligible');
+            return;
+        }
+        fragment.setDeriveSubtreeSignature(Core.createDescendantBindingSignature(fragment, 'refresh'));
+        Core.logDerivedSubtreeProfileSnapshot(fragment, 'refresh');
+    }
+    /**
+     * data-derive subtree skip のプロファイルを取得または初期化します。
+     *
+     * @param fragment 対象フラグメント
+     * @returns プロファイル
+     */
+    static getOrCreateDerivedSubtreeProfile(fragment) {
+        if (!Dev.isEnabled() || !fragment.hasAttribute(`${Env.prefix}derive`)) {
+            return null;
+        }
+        const existing = Core.DERIVE_SUBTREE_PROFILES.get(fragment);
+        if (existing) {
+            return existing;
+        }
+        const profile = {
+            hostId: Core.createDerivedSubtreeHostId(fragment),
+            signatureComputeTotal: 0,
+            signatureComputeFromEvaluateAll: 0,
+            signatureComputeFromRefresh: 0,
+            skipHitCount: 0,
+            skipMissCount: 0,
+            skipIneligibleCount: 0,
+        };
+        Core.DERIVE_SUBTREE_PROFILES.set(fragment, profile);
+        return profile;
+    }
+    /**
+     * data-derive subtree host の識別子を作成します。
+     *
+     * @param fragment 対象フラグメント
+     * @returns host 識別子
+     */
+    static createDerivedSubtreeHostId(fragment) {
+        const segments = [];
+        let current = fragment;
+        while (current) {
+            const target = current.getTarget();
+            if (!(target instanceof HTMLElement)) {
+                break;
+            }
+            let segment = target.tagName.toLowerCase();
+            if (target.id.trim() !== '') {
+                segment += `#${target.id.trim()}`;
+                segments.unshift(segment);
+                break;
+            }
+            const deriveName = current.getRawAttribute(`${Env.prefix}derive-name`);
+            if (typeof deriveName === 'string' && deriveName.trim() !== '') {
+                segment += `[${Env.prefix}derive-name="${deriveName.trim()}"]`;
+            }
+            const parent = current.getParent();
+            if (parent) {
+                const siblingIndex = parent
+                    .getChildren()
+                    .filter(child => child instanceof ElementFragment)
+                    .findIndex(child => child === current);
+                segment += `:nth-child(${siblingIndex + 1})`;
+            }
+            segments.unshift(segment);
+            current = parent;
+        }
+        return segments.join(' > ');
+    }
+    /**
+     * data-derive subtree の署名計算回数を記録します。
+     *
+     * @param fragment 対象フラグメント
+     * @param source 計算元
+     */
+    static recordDerivedSubtreeSignatureComputation(fragment, source) {
+        const profile = Core.getOrCreateDerivedSubtreeProfile(fragment);
+        if (profile === null) {
+            return;
+        }
+        profile.signatureComputeTotal += 1;
+        if (source === 'refresh') {
+            profile.signatureComputeFromRefresh += 1;
+            return;
+        }
+        profile.signatureComputeFromEvaluateAll += 1;
+    }
+    /**
+     * data-derive subtree の現在プロファイルをログ出力します。
+     *
+     * @param fragment 対象フラグメント
+     * @param reason ログ理由
+     */
+    static logDerivedSubtreeProfileSnapshot(fragment, reason) {
+        const profile = Core.getOrCreateDerivedSubtreeProfile(fragment);
+        if (profile === null) {
+            return;
+        }
+        if (reason === 'skip-hit') {
+            profile.skipHitCount += 1;
+        }
+        else if (reason === 'skip-miss') {
+            profile.skipMissCount += 1;
+        }
+        else if (reason === 'skip-ineligible') {
+            profile.skipIneligibleCount += 1;
+        }
+        Log.info('[Haori][derive-profile]', {
+            reason,
+            hostId: profile.hostId,
+            signatureComputeTotal: profile.signatureComputeTotal,
+            signatureComputeFromEvaluateAll: profile.signatureComputeFromEvaluateAll,
+            signatureComputeFromRefresh: profile.signatureComputeFromRefresh,
+            skipHitCount: profile.skipHitCount,
+            skipMissCount: profile.skipMissCount,
+            skipIneligibleCount: profile.skipIneligibleCount,
+        });
+    }
+    /**
+     * data-each 以外の動的要素状態を持つかどうかを返します。
+     *
+     * @param fragment 判定対象フラグメント
+     * @returns 該当するなら true
+     */
+    static hasNonEachDynamicElementState(fragment) {
+        const allowedEachAttributes = new Set([
+            `${Env.prefix}each`,
+            `${Env.prefix}each-key`,
+            `${Env.prefix}each-arg`,
+            `${Env.prefix}each-index`,
+        ]);
+        const hasDynamicAttributes = fragment.getAttributeNames().some(name => {
+            if (allowedEachAttributes.has(name)) {
+                return false;
+            }
+            if (name.startsWith(`${Env.prefix}attr-`)) {
+                return true;
+            }
+            if (name.startsWith(Env.prefix)) {
+                return true;
+            }
+            const value = fragment.getRawAttribute(name);
+            return typeof value === 'string' && value.includes('{{');
+        });
+        if (hasDynamicAttributes) {
+            return true;
+        }
+        return fragment.getChildren().some(child => child instanceof TextFragment && child.hasDynamicContent());
+    }
+    /**
+     * fresh clone 初期化を subtree ごと省略できるかどうかを事前計算します。
+     *
+     * @param fragment 判定対象フラグメント
+     * @returns subtree 全体を省略可能なら true
+     */
+    static markFreshInitializationSkippable(fragment) {
+        const hasDynamicAttributes = fragment
+            .getAttributeNames()
+            .some(name => Core.isFreshInitializationDynamicAttribute(fragment, name));
+        const hasDynamicChildren = fragment.getChildren().some(child => {
+            if (child instanceof ElementFragment) {
+                return !Core.markFreshInitializationSkippable(child);
+            }
+            if (child instanceof TextFragment) {
+                return child.hasDynamicContent();
+            }
+            return false;
+        });
+        const skippable = !hasDynamicAttributes && !hasDynamicChildren;
+        fragment.setFreshInitializationSkippable(skippable);
+        return skippable;
+    }
+    /**
+     * fresh clone 初期化で再評価が必要な属性かどうかを返します。
+     *
+     * @param fragment 判定対象フラグメント
+     * @param name 属性名
+     * @returns 再評価が必要なら true
+     */
+    static isFreshInitializationDynamicAttribute(fragment, name) {
+        if (name.startsWith(`${Env.prefix}attr-`)) {
+            return true;
+        }
+        if (name.startsWith(Env.prefix)) {
+            return true;
+        }
+        const value = fragment.getRawAttribute(name);
+        return typeof value === 'string' && value.includes('{{');
+    }
     /**
      * 差分を更新します。
      *
@@ -817,50 +1272,59 @@ class Core {
             newKeys.push(listKey);
             keyDataMap.set(listKey, { item, itemIndex });
         });
+        const newKeySet = new Set(newKeys);
         const removalPromises = [];
         let childElements = parent
             .getChildren()
             .filter(child => child instanceof ElementFragment)
             .filter(child => !child.hasAttribute(`${Env.prefix}each-before`) &&
             !child.hasAttribute(`${Env.prefix}each-after`));
+        const previousKeys = childElements.map(child => child.getListKey());
         childElements = childElements.filter(child => {
-            const index = newKeys.indexOf(String(child.getListKey()));
-            if (index === -1) {
+            if (!newKeySet.has(String(child.getListKey()))) {
                 removalPromises.push(child.remove());
                 return false;
             }
             return true;
         });
         const srcKeys = childElements.map(child => child.getListKey());
-        const baseInsertIndex = parent
-            .getChildren()
-            .filter(child => child instanceof ElementFragment)
-            .filter(child => child.hasAttribute(`${Env.prefix}each-before`)).length;
+        const childElementsByKey = new Map();
+        childElements.forEach(child => {
+            const listKey = child.getListKey();
+            if (listKey !== null && !childElementsByKey.has(listKey)) {
+                childElementsByKey.set(listKey, child);
+            }
+        });
+        const insertTargets = parent.getChildElementFragments().slice();
+        const baseInsertIndex = insertTargets.filter(child => child.hasAttribute(`${Env.prefix}each-before`)).length;
         let chain = Promise.resolve();
         newKeys.forEach((newKey, loopIndex) => {
-            const srcIndex = srcKeys.indexOf(newKey);
             const { item, itemIndex } = keyDataMap.get(newKey);
             let child;
-            if (srcIndex !== -1) {
+            const reusedChild = childElementsByKey.get(newKey);
+            if (reusedChild) {
                 // 既存の要素を再利用
-                child = childElements[srcIndex];
-                // 既存要素にも必ずバインドデータを再セットし、キャッシュもクリア
-                chain = chain.then(() => Core.updateRowFragment(child, item, indexKey, itemIndex, itemArg ? String(itemArg) : null, newKey)
-                    .then(() => Core.evaluateAll(child))
-                    .then(() => Core.scheduleEvaluateAll(child)));
+                child = reusedChild;
+                // 行の入力が同一なら子孫の再評価をスキップする。
+                chain = chain.then(() => Core.updateRowFragment(child, item, indexKey, itemIndex, itemArg ? String(itemArg) : null, newKey).then(changed => {
+                    if (!changed) {
+                        return undefined;
+                    }
+                    return Core.evaluateAll(child);
+                }));
             }
             else {
                 // 新しい要素を追加
                 child = template.clone();
                 const currentInsertIndex = baseInsertIndex + loopIndex;
                 chain = chain.then(() => Core.updateRowFragment(child, item, indexKey, itemIndex, itemArg ? String(itemArg) : null, newKey).then(() => {
-                    const referenceChild = parent
-                        .getChildren()
-                        .filter(currentChild => currentChild instanceof ElementFragment)[currentInsertIndex] || null;
+                    const referenceChild = insertTargets[currentInsertIndex] ?? null;
                     return parent
                         .insertBefore(child, referenceChild)
-                        .then(() => Core.evaluateAll(child))
-                        .then(() => Core.scheduleEvaluateAll(child));
+                        .then(() => {
+                        insertTargets.splice(currentInsertIndex, 0, child);
+                    })
+                        .then(() => Core.initializeFreshEachRow(child));
                 }));
             }
         });
@@ -870,8 +1334,10 @@ class Core {
             // eachupdateイベントを発火
             const validNewKeys = newKeys.filter((key) => key !== null);
             const validSrcKeys = srcKeys.filter((key) => key !== null);
-            const addedKeys = validNewKeys.filter(key => !validSrcKeys.includes(key));
-            const removedKeys = validSrcKeys.filter(key => !validNewKeys.includes(key));
+            const validSrcKeySet = new Set(validSrcKeys);
+            const addedKeys = validNewKeys.filter(key => !validSrcKeySet.has(key));
+            const previousValidKeys = previousKeys.filter((key) => key !== null);
+            const removedKeys = previousValidKeys.filter(key => !newKeySet.has(key));
             HaoriEvent.eachUpdate(parent.getTarget(), addedKeys, removedKeys, validNewKeys);
             return undefined;
         });
@@ -944,12 +1410,112 @@ class Core {
             }
             else {
                 Log.error('[Haori]', `Primitive value requires '${Env.prefix}each-arg' attribute: ${data}`);
-                return Promise.resolve();
+                return Promise.resolve(false);
             }
         }
+        const normalizedBindingData = bindingData;
+        const nextRenderSignature = Core.createBindingSignature({
+            listKey,
+            bindingData: normalizedBindingData,
+        });
+        if (rowFragment.getListKey() === listKey &&
+            rowFragment.getRenderSignature() === nextRenderSignature) {
+            return Promise.resolve(false);
+        }
         rowFragment.setListKey(listKey);
-        rowFragment.setBindingData(bindingData);
-        return rowFragment.setAttribute(`${Env.prefix}row`, listKey);
+        rowFragment.setRenderSignature(nextRenderSignature);
+        rowFragment.setBindingData(normalizedBindingData);
+        return rowFragment
+            .setAttribute(`${Env.prefix}row`, listKey)
+            .then(() => true);
+    }
+    /**
+     * 新規挿入行に遅延再評価が必要かどうかを判定します。
+     *
+     * @param fragment 判定対象の行フラグメント
+     * @returns 遅延再評価が必要なら true
+     */
+    static needsScheduledEvaluateAll(fragment) {
+        const stack = [fragment];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            current.getChildElementFragments().forEach(child => {
+                stack.push(child);
+            });
+            if (current !== fragment &&
+                !current.isMounted() &&
+                Core.hasMountSensitiveAttribute(current)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * mounted 状態に依存して再評価が必要になりやすい属性を持つかどうかを返します。
+     *
+     * @param fragment 判定対象フラグメント
+     * @returns 該当属性を持つなら true
+     */
+    static hasMountSensitiveAttribute(fragment) {
+        return ['fetch', 'import'].some(suffix => fragment.hasAttribute(`${Env.prefix}${suffix}`));
+    }
+    /**
+     * バインド値が同一かどうかを再帰的に判定します。
+     *
+     * @param left 比較元の値
+     * @param right 比較先の値
+     * @param visited 循環参照対策用の訪問済みペア
+     * @returns 同一なら true
+     */
+    static createBindingSignature(value, seen = new WeakMap(), nextId = { value: 0 }) {
+        if (value === null) {
+            return 'null';
+        }
+        if (value === undefined) {
+            return 'undefined';
+        }
+        if (typeof value === 'string') {
+            return JSON.stringify(value);
+        }
+        if (typeof value === 'number' ||
+            typeof value === 'boolean' ||
+            typeof value === 'bigint') {
+            return String(value);
+        }
+        if (typeof value === 'function') {
+            return `[Function:${value.name || 'anonymous'}]`;
+        }
+        if (typeof value === 'symbol') {
+            return value.toString();
+        }
+        if (value instanceof Date) {
+            return `[Date:${value.toISOString()}]`;
+        }
+        if (Array.isArray(value)) {
+            if (seen.has(value)) {
+                return `[Circular:${seen.get(value)}]`;
+            }
+            const marker = `array-${nextId.value}`;
+            nextId.value += 1;
+            seen.set(value, marker);
+            return `[${value
+                .map(item => Core.createBindingSignature(item, seen, nextId))
+                .join(',')}]`;
+        }
+        if (typeof value === 'object') {
+            if (seen.has(value)) {
+                return `[Circular:${seen.get(value)}]`;
+            }
+            const marker = `object-${nextId.value}`;
+            nextId.value += 1;
+            seen.set(value, marker);
+            const record = value;
+            return `{${Object.keys(record)
+                .sort()
+                .map(key => `${JSON.stringify(key)}:${Core.createBindingSignature(record[key], seen, nextId)}`)
+                .join(',')}}`;
+        }
+        return String(value);
     }
     /**
      * フラグメントの再評価を次のイベントループで実行します。
@@ -992,5 +1558,7 @@ Core.ATTRIBUTE_PLACEHOLDER_REGEX = /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/;
 Core.REACTIVE_FETCH_STATES = new WeakMap();
 /** data-import の自動再評価状態 */
 Core.REACTIVE_IMPORT_STATES = new WeakMap();
+/** data-derive subtree skip の開発用プロファイル */
+Core.DERIVE_SUBTREE_PROFILES = new WeakMap();
 export default Core;
 //# sourceMappingURL=core.js.map