import { addUniqueItem, removeItem } from 'motion-utils';

class NodeStack {
    constructor() {
        this.members = [];
    }
    add(node) {
        addUniqueItem(this.members, node);
        for (let i = this.members.length - 1; i >= 0; i--) {
            const m = this.members[i];
            if (m === node || m === this.lead || m === this.prevLead)
                continue;
            const inst = m.instance;
            if (inst && inst.isConnected === false && m.isPresent !== false && !m.snapshot) {
                removeItem(this.members, m);
            }
        }
        node.scheduleRender();
    }
    remove(node) {
        removeItem(this.members, node);
        if (node === this.prevLead) {
            this.prevLead = undefined;
        }
        if (node === this.lead) {
            const prevLead = this.members[this.members.length - 1];
            if (prevLead) {
                this.promote(prevLead);
            }
        }
    }
    relegate(node) {
        const indexOfNode = this.members.findIndex((member) => node === member);
        if (indexOfNode === 0)
            return false;
        /**
         * Find the next projection node that is present
         */
        let prevLead;
        for (let i = indexOfNode; i >= 0; i--) {
            const member = this.members[i];
            const inst = member.instance;
            if (member.isPresent !== false && (!inst || inst.isConnected !== false)) {
                prevLead = member;
                break;
            }
        }
        if (prevLead) {
            this.promote(prevLead);
            return true;
        }
        else {
            return false;
        }
    }
    promote(node, preserveFollowOpacity) {
        const prevLead = this.lead;
        if (node === prevLead)
            return;
        this.prevLead = prevLead;
        this.lead = node;
        node.show();
        if (prevLead) {
            prevLead.instance && prevLead.scheduleRender();
            node.scheduleRender();
            /**
             * If both the new and previous lead have the same defined layoutDependency,
             * skip the shared layout animation. This allows components with layoutId
             * to opt-out of animations when their layoutDependency hasn't changed,
             * even when the component unmounts and remounts in a different location.
             */
            const prevDep = prevLead.options.layoutDependency;
            const nextDep = node.options.layoutDependency;
            const dependencyMatches = prevDep !== undefined &&
                nextDep !== undefined &&
                prevDep === nextDep;
            if (!dependencyMatches) {
                const prevInstance = prevLead.instance;
                const isStale = prevInstance && prevInstance.isConnected === false && !prevLead.snapshot;
                if (!isStale) {
                    node.resumeFrom = prevLead;
                    if (preserveFollowOpacity) {
                        node.resumeFrom.preserveOpacity = true;
                    }
                    if (prevLead.snapshot) {
                        node.snapshot = prevLead.snapshot;
                        node.snapshot.latestValues =
                            prevLead.animationValues || prevLead.latestValues;
                    }
                    if (node.root && node.root.isUpdating) {
                        node.isLayoutDirty = true;
                    }
                }
            }
            const { crossfade } = node.options;
            if (crossfade === false) {
                prevLead.hide();
            }
        }
    }
    exitAnimationComplete() {
        this.members.forEach((node) => {
            const { options, resumingFrom } = node;
            options.onExitComplete && options.onExitComplete();
            if (resumingFrom) {
                resumingFrom.options.onExitComplete &&
                    resumingFrom.options.onExitComplete();
            }
        });
    }
    scheduleRender() {
        this.members.forEach((node) => {
            node.instance && node.scheduleRender(false);
        });
    }
    /**
     * Clear any leads that have been removed this render to prevent them from being
     * used in future animations and to prevent memory leaks
     */
    removeLeadSnapshot() {
        if (this.lead && this.lead.snapshot) {
            this.lead.snapshot = undefined;
        }
    }
}

export { NodeStack };
//# sourceMappingURL=stack.mjs.map