const executeScripts = (newDoc) => {
    const scripts = newDoc.querySelectorAll('script');
    scripts.forEach((oldScript) => {
        const newScript = document.createElement('script');
  
        // 复制所有属性
        Array.from(oldScript.attributes).forEach((attr) => {
            newScript.setAttribute(attr.name, attr.value);
        });
  
        // 如果是外部脚本，直接插入
        if (oldScript.src) {
            newScript.src = oldScript.src;
            newScript.async = false; // 维持同步执行
        } else {
            // 如果是内联脚本，复制内容
            newScript.textContent = oldScript.textContent;
        }
  
        // 替换旧的 script
        oldScript.replaceWith(newScript);
    });
};

// @/store/useBroadcast
import { create } from 'zustand';

export const useBroadcast = create((set, get) => ({
    callbacks: [],

    registerCallback: (callback) => {
        set((state) => ({
            callbacks: [...state.callbacks, callback],
        }));
    },

    broadcast: (message) => {
        get().callbacks.forEach((callback) => callback(message));
    },

    unregisterCallback: (callback) => {
        set((state) => ({
            callbacks: state.callbacks.filter((cb) => cb !== callback),
        }));
    },
}));

if (target.pathname === location.pathname) return;

router.prefetch(href);
setTimeout(() => {
    router.push(href);
}, 300);

// @/components/Pjax.jsx
'use client';

import { useEffect, useState } from 'react';
import { usePathname, useRouter } from 'next/navigation';
import { useBroadcast } from '@/store/useBroadcast';

const Pjax = ({ children }) => {
    const [loadStart, setLoadStart] = useState(false);
    const router = useRouter();
    const broadcast = useBroadcast((state) => state.broadcast);
    const pathname = usePathname();

    useEffect(() => {
        const handleClick = (e) => {
            const target = e.target.closest('a');
            if (
                !target ||
                e.ctrlKey ||
                e.metaKey ||
                e.shiftKey ||
                target.target === '_blank' ||
                target.target === '_self'
            ) {
                return;
            }

            const href = target.href;
            if (
                !href ||
                new URL(href).origin !== location.origin ||
                href.replace(location.origin + '/', '').startsWith('#')
            )
                return;

            e.preventDefault();
            if (target.pathname === location.pathname) return;
            broadcast({ type: 'LOAD', action: 'loadStart' });
            setLoadStart(true);

      
            router.push(href);
  
        };

        document.addEventListener('click', handleClick);
        return () => {
            document.removeEventListener('click', handleClick);
        };
    }, [router, broadcast]);

    useEffect(() => {
        if (!loadStart) return;
        broadcast({ type: 'LOAD', action: 'loadEnd' });
        setLoadStart(false);
    }, [pathname]);

    useEffect(() => {
        const handlePopState = (e) => {
            broadcast({ type: 'LOAD', action: 'loadEnd' });
        };

        window.addEventListener('popstate', handlePopState);
        return () => {
            window.removeEventListener('popstate', handlePopState);
        };
    }, [router, broadcast]);

    return children || null;
};

export default Pjax;

import { useBroadcast } from '@/store/useBroadcast';
export default function LoadingShade() {
    const registerBroadcast = useBroadcast((state) => state.registerCallback);
    const unregisterBroadcast = useBroadcast((state) => state.unregisterCallback);

    useEffect(() => {
        const handlePageLoad = (message) => {
            if (message.action === 'loadStart') {
                // 开始Pjax加载了
            }
            if (message.action === 'loadEnd') {
                // Pjax加载完了
            }
        };
        registerBroadcast(handlePageLoad);
        return () => {
            unregisterBroadcast();
        };
    }, [registerBroadcast, unregisterBroadcast]);
	return <></>;
}

import Pjax from '@/components/Pjax';

export default function RootLayout({ children }) {
	return (
		<Pjax />
		{children}
	)
}