@yeying-community/web3-bs 1.0.7 → 1.0.10

package/dist/web3-bs.umd.js

@@ -7,10 +7,46 @@
     const YEYING_RDNS = 'io.github.yeying';
     const DEFAULT_TIMEOUT = 1000;
     const DEFAULT_ACCOUNT_STORAGE_KEY = 'yeying:last_account';
+    const DEFAULT_PROVIDER_POLL_INTERVAL = 100;
+    const DEFAULT_PROVIDER_MAX_POLLS = 20;
+    const requestAccountsInFlight = new WeakMap();
+    function isProvider(value) {
+        return !!value && typeof value.request === 'function';
+    }
     function getWindowEthereum() {
         if (typeof window === 'undefined')
             return null;
-        return window.ethereum || null;
+        const ethereum = window.ethereum;
+        return isProvider(ethereum) ? ethereum : null;
+    }
+    function getWindowProviderCandidates() {
+        if (typeof window === 'undefined')
+            return [];
+        const source = window;
+        const candidates = [];
+        const addProvider = (provider) => {
+            if (isProvider(provider) && !candidates.includes(provider)) {
+                candidates.push(provider);
+            }
+        };
+        for (const name of [
+            'ethereum',
+            'yeeying',
+            'yeying',
+            'coinbaseWallet',
+            'bitkeep',
+            'tokenpocket',
+            '__YEYING_PROVIDER__',
+        ]) {
+            addProvider(source[name]);
+        }
+        const ethereum = getWindowEthereum();
+        if (Array.isArray(ethereum?.providers)) {
+            for (const provider of ethereum.providers) {
+                addProvider(provider);
+            }
+        }
+        return candidates;
     }
     function readStoredAccount(storageKey) {
         if (typeof localStorage === 'undefined')
@@ -54,7 +90,7 @@
     }
     function selectBestProvider(candidates, preferYeYing) {
         if (candidates.length === 0)
-            return null;
+            return selectBestWindowProvider(preferYeYing);
         if (preferYeYing) {
             const yeying = candidates.find(c => isYeYingProvider(c.provider, c.info));
             if (yeying)
@@ -62,10 +98,21 @@
         }
         return candidates[0].provider;
     }
+    function selectBestWindowProvider(preferYeYing) {
+        const candidates = getWindowProviderCandidates();
+        if (candidates.length === 0)
+            return null;
+        if (preferYeYing) {
+            const yeying = candidates.find(provider => isYeYingProvider(provider));
+            if (yeying)
+                return yeying;
+        }
+        return candidates[0];
+    }
     async function getProvider(options = {}) {
         const preferYeYing = options.preferYeYing !== false;
         const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT;
-        const windowProvider = getWindowEthereum();
+        const windowProvider = selectBestWindowProvider(preferYeYing);
         if (preferYeYing && isYeYingProvider(windowProvider)) {
             return windowProvider;
         }
@@ -98,7 +145,7 @@
                 }
             };
             const onEthereumInitialized = () => {
-                const injected = getWindowEthereum();
+                const injected = selectBestWindowProvider(preferYeYing);
                 if (preferYeYing && isYeYingProvider(injected)) {
                     safeResolve(injected);
                 }
@@ -110,7 +157,7 @@
                     return;
                 const best = selectBestProvider(discovered, preferYeYing) ||
                     windowProvider ||
-                    getWindowEthereum();
+                    selectBestWindowProvider(preferYeYing);
                 safeResolve(best || null);
             }, timeoutMs);
             try {
@@ -124,6 +171,107 @@
             }
         });
     }
+    function watchProvider(handler, options = {}) {
+        if (typeof window === 'undefined') {
+            handler({ provider: null, present: false });
+            return () => { };
+        }
+        const preferYeYing = options.preferYeYing !== false;
+        const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_PROVIDER_POLL_INTERVAL;
+        const maxPolls = options.maxPolls ?? DEFAULT_PROVIDER_MAX_POLLS;
+        let stopped = false;
+        let lastProvider;
+        let pollCount = 0;
+        let pollTimer = null;
+        const emit = () => {
+            if (stopped)
+                return;
+            const provider = selectBestWindowProvider(preferYeYing);
+            if (provider === lastProvider)
+                return;
+            lastProvider = provider;
+            handler({ provider, present: !!provider });
+        };
+        const poll = () => {
+            if (stopped)
+                return;
+            emit();
+            pollCount += 1;
+            if (lastProvider || pollCount >= maxPolls)
+                return;
+            pollTimer = setTimeout(poll, pollIntervalMs);
+        };
+        const handleProviderReady = () => {
+            emit();
+        };
+        window.addEventListener('ethereum#initialized', handleProviderReady);
+        window.addEventListener('eip6963:announceProvider', handleProviderReady);
+        try {
+            window.dispatchEvent(new Event('eip6963:requestProvider'));
+        }
+        catch {
+            // Ignore unsupported event dispatch environments.
+        }
+        poll();
+        return () => {
+            stopped = true;
+            if (pollTimer) {
+                clearTimeout(pollTimer);
+            }
+            window.removeEventListener('ethereum#initialized', handleProviderReady);
+            window.removeEventListener('eip6963:announceProvider', handleProviderReady);
+        };
+    }
+    function getWalletErrorMessage(error) {
+        if (!error)
+            return '';
+        if (typeof error === 'string')
+            return error;
+        if (error instanceof Error)
+            return error.message || String(error);
+        const message = error.message;
+        if (typeof message === 'string')
+            return message;
+        return String(error);
+    }
+    function getWalletErrorCode(error) {
+        const code = Number(error?.code);
+        if (!Number.isNaN(code))
+            return code;
+        const causeCode = Number(error?.cause?.code);
+        if (!Number.isNaN(causeCode))
+            return causeCode;
+        return null;
+    }
+    function classifyWalletError(error) {
+        const code = getWalletErrorCode(error);
+        const message = getWalletErrorMessage(error);
+        const lowerMessage = message.toLowerCase();
+        if (code === 4001 || lowerMessage.includes('user rejected')) {
+            return { type: 'userRejected', code, message };
+        }
+        if (code === 4900 ||
+            lowerMessage.includes('disconnected') ||
+            lowerMessage.includes('reconnect') ||
+            lowerMessage.includes('not connected')) {
+            return { type: 'disconnected', code, message };
+        }
+        if (lowerMessage.includes('timeout')) {
+            return { type: 'timeout', code, message };
+        }
+        if (lowerMessage.includes('no injected wallet provider') ||
+            lowerMessage.includes('未检测到钱包')) {
+            return { type: 'notFound', code, message };
+        }
+        return { type: 'unknown', code, message };
+    }
+    function isUserRejectedWalletAction(error) {
+        return classifyWalletError(error).type === 'userRejected';
+    }
+    function isWalletReconnectError(error) {
+        const type = classifyWalletError(error).type;
+        return type === 'disconnected' || type === 'timeout';
+    }
     async function requireProvider(options = {}) {
         const provider = await getProvider(options);
         if (!provider) {
@@ -133,10 +281,24 @@
     }
     async function requestAccounts(options = {}) {
         const provider = options.provider || (await requireProvider());
-        const accounts = (await provider.request({
+        const dedupe = options.dedupe !== false;
+        if (dedupe) {
+            const pending = requestAccountsInFlight.get(provider);
+            if (pending)
+                return pending;
+        }
+        const request = provider.request({
             method: 'eth_requestAccounts',
-        }));
-        return Array.isArray(accounts) ? accounts : [];
+        }).then(accounts => (Array.isArray(accounts) ? accounts : []));
+        if (!dedupe)
+            return request;
+        requestAccountsInFlight.set(provider, request);
+        try {
+            return await request;
+        }
+        finally {
+            requestAccountsInFlight.delete(provider);
+        }
     }
     async function getAccounts(provider) {
         const p = provider || (await requireProvider());
@@ -1441,6 +1603,9 @@
         const suffix = path.startsWith('/') ? path : `/${path}`;
         return `${base}${suffix}`;
     }
+    function isRecord(value) {
+        return typeof value === 'object' && value !== null;
+    }
     function resolveAuthHeader(auth, token) {
         if (auth?.type === 'bearer') {
             return `Bearer ${auth.token}`;
@@ -1629,6 +1794,72 @@
             }
             return await res.json();
         }
+        async requestApiJson(method, apiPath, body, options) {
+            const headers = this.buildHeaders({
+                auth: options?.auth,
+                token: options?.token,
+                contentType: body === undefined ? undefined : 'application/json',
+            });
+            const response = await this.fetcher(joinUrl(this.baseUrl, apiPath), {
+                method,
+                headers,
+                body: body === undefined ? undefined : JSON.stringify(body),
+                credentials: this.credentials,
+                signal: options?.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`WebDAV ${method} ${apiPath} failed: ${response.status} ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        getShareAccessUrl(token, fileName) {
+            const normalizedToken = encodeURIComponent(String(token || '').trim());
+            if (!normalizedToken) {
+                throw new Error('Share token is required');
+            }
+            const encodedFileName = String(fileName || '').trim()
+                ? `/${encodeURIComponent(String(fileName || '').trim())}`
+                : '';
+            return joinUrl(this.baseUrl, `/api/v1/public/share/${normalizedToken}${encodedFileName}`);
+        }
+        async createShareLink(options) {
+            const normalizedPath = String(options.path || '').trim();
+            if (!normalizedPath) {
+                throw new Error('Share path is required');
+            }
+            const payload = await this.requestApiJson('POST', '/api/v1/public/share/create', {
+                path: normalizedPath,
+                expiresIn: options.expiresIn,
+                expiresValue: options.expiresValue,
+                expiresUnit: options.expiresUnit,
+            }, options);
+            if (!isRecord(payload)) {
+                throw new Error('WebDAV share create response is invalid');
+            }
+            return payload;
+        }
+        async listShareLinks(options = {}) {
+            const payload = await this.requestApiJson('GET', '/api/v1/public/share/list', undefined, options);
+            if (!isRecord(payload)) {
+                return [];
+            }
+            const items = payload.items;
+            if (!Array.isArray(items)) {
+                return [];
+            }
+            return items.filter(isRecord);
+        }
+        async revokeShareLink(token, options = {}) {
+            const normalizedToken = String(token || '').trim();
+            if (!normalizedToken) {
+                throw new Error('Share token is required');
+            }
+            const payload = await this.requestApiJson('POST', '/api/v1/public/share/revoke', { token: normalizedToken }, options);
+            if (!isRecord(payload)) {
+                return {};
+            }
+            return payload;
+        }
     }
     function createWebDavClient(options) {
         return new WebDavClient(options);
@@ -1945,6 +2176,7 @@
     exports.authCentralUcanFetch = authCentralUcanFetch;
     exports.authFetch = authFetch;
     exports.authUcanFetch = authUcanFetch;
+    exports.classifyWalletError = classifyWalletError;
     exports.clearAccessToken = clearAccessToken;
     exports.clearCentralSessionToken = clearCentralSessionToken;
     exports.clearUcanSession = clearUcanSession;
@@ -1970,8 +2202,12 @@
     exports.getProvider = getProvider;
     exports.getStoredUcanRoot = getStoredUcanRoot;
     exports.getUcanSession = getUcanSession;
+    exports.getWalletErrorCode = getWalletErrorCode;
+    exports.getWalletErrorMessage = getWalletErrorMessage;
     exports.initDappSession = initDappSession;
     exports.initWebDavStorage = initWebDavStorage;
+    exports.isUserRejectedWalletAction = isUserRejectedWalletAction;
+    exports.isWalletReconnectError = isWalletReconnectError;
     exports.isYeYingProvider = isYeYingProvider;
     exports.issueCentralUcan = issueCentralUcan;
     exports.loginWithChallenge = loginWithChallenge;
@@ -1989,6 +2225,7 @@
     exports.signMessage = signMessage;
     exports.storeUcanRoot = storeUcanRoot;
     exports.watchAccounts = watchAccounts;
+    exports.watchProvider = watchProvider;
 
 }));
 //# sourceMappingURL=web3-bs.umd.js.map