@whitesev/domutils 1.5.9 → 1.5.11

package/dist/index.system.js

@@ -103,155 +103,168 @@ System.register('DOMUtils', [], (function (exports) {
             const cache = createCache(LAST_NUMBER_WEAK_MAP);
             const generateUniqueNumber = createGenerateUniqueNumber(cache, LAST_NUMBER_WEAK_MAP);
 
-            const isCallNotification = (message) => {
-                return message.method !== undefined && message.method === 'call';
+            const isMessagePort = (sender) => {
+                return typeof sender.start === 'function';
             };
 
-            const isClearResponse = (message) => {
-                return typeof message.id === 'number' && typeof message.result === 'boolean';
-            };
+            const PORT_MAP = new WeakMap();
 
-            const load = (url) => {
-                // Prefilling the Maps with a function indexed by zero is necessary to be compliant with the specification.
-                const scheduledIntervalFunctions = new Map([[0, () => { }]]); // tslint:disable-line no-empty
-                const scheduledTimeoutFunctions = new Map([[0, () => { }]]); // tslint:disable-line no-empty
-                const unrespondedRequests = new Map();
-                const worker = new Worker(url);
-                worker.addEventListener('message', ({ data }) => {
-                    if (isCallNotification(data)) {
-                        const { params: { timerId, timerType } } = data;
-                        if (timerType === 'interval') {
-                            const idOrFunc = scheduledIntervalFunctions.get(timerId);
-                            if (typeof idOrFunc === undefined) {
-                                throw new Error('The timer is in an undefined state.');
-                            }
-                            if (typeof idOrFunc === 'number') {
-                                const timerIdAndTimerType = unrespondedRequests.get(idOrFunc);
-                                if (timerIdAndTimerType === undefined ||
-                                    timerIdAndTimerType.timerId !== timerId ||
-                                    timerIdAndTimerType.timerType !== timerType) {
-                                    throw new Error('The timer is in an undefined state.');
-                                }
-                            }
-                            else if (typeof idOrFunc === 'function') {
-                                idOrFunc();
-                            }
+            const extendBrokerImplementation = (partialBrokerImplementation) => ({
+                ...partialBrokerImplementation,
+                connect: ({ call }) => {
+                    return async () => {
+                        const { port1, port2 } = new MessageChannel();
+                        const portId = await call('connect', { port: port1 }, [port1]);
+                        PORT_MAP.set(port2, portId);
+                        return port2;
+                    };
+                },
+                disconnect: ({ call }) => {
+                    return async (port) => {
+                        const portId = PORT_MAP.get(port);
+                        if (portId === undefined) {
+                            throw new Error('The given port is not connected.');
                         }
-                        else if (timerType === 'timeout') {
-                            const idOrFunc = scheduledTimeoutFunctions.get(timerId);
-                            if (typeof idOrFunc === undefined) {
-                                throw new Error('The timer is in an undefined state.');
-                            }
-                            if (typeof idOrFunc === 'number') {
-                                const timerIdAndTimerType = unrespondedRequests.get(idOrFunc);
-                                if (timerIdAndTimerType === undefined ||
-                                    timerIdAndTimerType.timerId !== timerId ||
-                                    timerIdAndTimerType.timerType !== timerType) {
-                                    throw new Error('The timer is in an undefined state.');
-                                }
+                        await call('disconnect', { portId });
+                    };
+                },
+                isSupported: ({ call }) => {
+                    return () => call('isSupported');
+                }
+            });
+
+            const ONGOING_REQUESTS = new WeakMap();
+            const createOrGetOngoingRequests = (sender) => {
+                if (ONGOING_REQUESTS.has(sender)) {
+                    // @todo TypeScript needs to be convinced that has() works as expected.
+                    return ONGOING_REQUESTS.get(sender);
+                }
+                const ongoingRequests = new Map();
+                ONGOING_REQUESTS.set(sender, ongoingRequests);
+                return ongoingRequests;
+            };
+            const createBroker = (brokerImplementation) => {
+                const fullBrokerImplementation = extendBrokerImplementation(brokerImplementation);
+                return (sender) => {
+                    const ongoingRequests = createOrGetOngoingRequests(sender);
+                    sender.addEventListener('message', (({ data: message }) => {
+                        const { id } = message;
+                        if (id !== null && ongoingRequests.has(id)) {
+                            const { reject, resolve } = ongoingRequests.get(id);
+                            ongoingRequests.delete(id);
+                            if (message.error === undefined) {
+                                resolve(message.result);
                             }
-                            else if (typeof idOrFunc === 'function') {
-                                idOrFunc();
-                                // A timeout can be savely deleted because it is only called once.
-                                scheduledTimeoutFunctions.delete(timerId);
+                            else {
+                                reject(new Error(message.error.message));
                             }
                         }
+                    }));
+                    if (isMessagePort(sender)) {
+                        sender.start();
                     }
-                    else if (isClearResponse(data)) {
-                        const { id } = data;
-                        const timerIdAndTimerType = unrespondedRequests.get(id);
-                        if (timerIdAndTimerType === undefined) {
-                            throw new Error('The timer is in an undefined state.');
-                        }
-                        const { timerId, timerType } = timerIdAndTimerType;
-                        unrespondedRequests.delete(id);
-                        if (timerType === 'interval') {
-                            scheduledIntervalFunctions.delete(timerId);
-                        }
-                        else {
-                            scheduledTimeoutFunctions.delete(timerId);
-                        }
-                    }
-                    else {
-                        const { error: { message } } = data;
-                        throw new Error(message);
-                    }
-                });
-                const clearInterval = (timerId) => {
-                    if (typeof scheduledIntervalFunctions.get(timerId) === 'function') {
-                        const id = generateUniqueNumber(unrespondedRequests);
-                        unrespondedRequests.set(id, { timerId, timerType: 'interval' });
-                        scheduledIntervalFunctions.set(timerId, id);
-                        worker.postMessage({
-                            id,
-                            method: 'clear',
-                            params: { timerId, timerType: 'interval' }
-                        });
-                    }
-                };
-                const clearTimeout = (timerId) => {
-                    if (typeof scheduledTimeoutFunctions.get(timerId) === 'function') {
-                        const id = generateUniqueNumber(unrespondedRequests);
-                        unrespondedRequests.set(id, { timerId, timerType: 'timeout' });
-                        scheduledTimeoutFunctions.set(timerId, id);
-                        worker.postMessage({
-                            id,
-                            method: 'clear',
-                            params: { timerId, timerType: 'timeout' }
+                    const call = (method, params = null, transferables = []) => {
+                        return new Promise((resolve, reject) => {
+                            const id = generateUniqueNumber(ongoingRequests);
+                            ongoingRequests.set(id, { reject, resolve });
+                            if (params === null) {
+                                sender.postMessage({ id, method }, transferables);
+                            }
+                            else {
+                                sender.postMessage({ id, method, params }, transferables);
+                            }
                         });
+                    };
+                    const notify = (method, params, transferables = []) => {
+                        sender.postMessage({ id: null, method, params }, transferables);
+                    };
+                    let functions = {};
+                    for (const [key, handler] of Object.entries(fullBrokerImplementation)) {
+                        functions = { ...functions, [key]: handler({ call, notify }) };
                     }
+                    return { ...functions };
                 };
-                const setInterval = (func, delay = 0, ...args) => {
-                    const timerId = generateUniqueNumber(scheduledIntervalFunctions);
-                    scheduledIntervalFunctions.set(timerId, () => {
-                        func(...args);
-                        // Doublecheck if the interval should still be rescheduled because it could have been cleared inside of func().
-                        if (typeof scheduledIntervalFunctions.get(timerId) === 'function') {
-                            worker.postMessage({
-                                id: null,
-                                method: 'set',
-                                params: {
-                                    delay,
-                                    now: performance.timeOrigin + performance.now(),
-                                    timerId,
-                                    timerType: 'interval'
-                                }
+            };
+
+            // Prefilling the Maps with a function indexed by zero is necessary to be compliant with the specification.
+            const scheduledIntervalsState = new Map([[0, null]]); // tslint:disable-line no-empty
+            const scheduledTimeoutsState = new Map([[0, null]]); // tslint:disable-line no-empty
+            const wrap = createBroker({
+                clearInterval: ({ call }) => {
+                    return (timerId) => {
+                        if (typeof scheduledIntervalsState.get(timerId) === 'symbol') {
+                            scheduledIntervalsState.set(timerId, null);
+                            call('clear', { timerId, timerType: 'interval' }).then(() => {
+                                scheduledIntervalsState.delete(timerId);
                             });
                         }
-                    });
-                    worker.postMessage({
-                        id: null,
-                        method: 'set',
-                        params: {
+                    };
+                },
+                clearTimeout: ({ call }) => {
+                    return (timerId) => {
+                        if (typeof scheduledTimeoutsState.get(timerId) === 'symbol') {
+                            scheduledTimeoutsState.set(timerId, null);
+                            call('clear', { timerId, timerType: 'timeout' }).then(() => {
+                                scheduledTimeoutsState.delete(timerId);
+                            });
+                        }
+                    };
+                },
+                setInterval: ({ call }) => {
+                    return (func, delay = 0, ...args) => {
+                        const symbol = Symbol();
+                        const timerId = generateUniqueNumber(scheduledIntervalsState);
+                        scheduledIntervalsState.set(timerId, symbol);
+                        const schedule = () => call('set', {
                             delay,
                             now: performance.timeOrigin + performance.now(),
                             timerId,
                             timerType: 'interval'
-                        }
-                    });
-                    return timerId;
-                };
-                const setTimeout = (func, delay = 0, ...args) => {
-                    const timerId = generateUniqueNumber(scheduledTimeoutFunctions);
-                    scheduledTimeoutFunctions.set(timerId, () => func(...args));
-                    worker.postMessage({
-                        id: null,
-                        method: 'set',
-                        params: {
+                        }).then(() => {
+                            const state = scheduledIntervalsState.get(timerId);
+                            if (state === undefined) {
+                                throw new Error('The timer is in an undefined state.');
+                            }
+                            if (state === symbol) {
+                                func(...args);
+                                // Doublecheck if the interval should still be rescheduled because it could have been cleared inside of func().
+                                if (scheduledIntervalsState.get(timerId) === symbol) {
+                                    schedule();
+                                }
+                            }
+                        });
+                        schedule();
+                        return timerId;
+                    };
+                },
+                setTimeout: ({ call }) => {
+                    return (func, delay = 0, ...args) => {
+                        const symbol = Symbol();
+                        const timerId = generateUniqueNumber(scheduledTimeoutsState);
+                        scheduledTimeoutsState.set(timerId, symbol);
+                        call('set', {
                             delay,
                             now: performance.timeOrigin + performance.now(),
                             timerId,
                             timerType: 'timeout'
-                        }
-                    });
-                    return timerId;
-                };
-                return {
-                    clearInterval,
-                    clearTimeout,
-                    setInterval,
-                    setTimeout
-                };
+                        }).then(() => {
+                            const state = scheduledTimeoutsState.get(timerId);
+                            if (state === undefined) {
+                                throw new Error('The timer is in an undefined state.');
+                            }
+                            if (state === symbol) {
+                                // A timeout can be savely deleted because it is only called once.
+                                scheduledTimeoutsState.delete(timerId);
+                                func(...args);
+                            }
+                        });
+                        return timerId;
+                    };
+                }
+            });
+            const load = (url) => {
+                const worker = new Worker(url);
+                return wrap(worker);
             };
 
             const createLoadOrReturnBroker = (loadBroker, worker) => {
@@ -270,7 +283,7 @@ System.register('DOMUtils', [], (function (exports) {
             };
 
             // This is the minified and stringified code of the worker-timers-worker package.
-            const worker = `(()=>{"use strict";const e=new Map,t=new Map,r=t=>{const r=e.get(t);return void 0!==r&&(clearTimeout(r),e.delete(t),!0)},s=e=>{const r=t.get(e);return void 0!==r&&(clearTimeout(r),t.delete(e),!0)},o=(e,t)=>{const r=performance.now(),s=e+t-r-performance.timeOrigin;return{expected:r+s,remainingDelay:s}},i=(e,t,r,s)=>{const o=r-performance.now();o>0?e.set(t,setTimeout(i,o,e,t,r,s)):(e.delete(t),postMessage({id:null,method:"call",params:{timerId:t,timerType:s}}))};addEventListener("message",(({data:n})=>{try{if("clear"===n.method){const{id:e,params:{timerId:t,timerType:o}}=n;if("interval"===o)postMessage({id:e,result:r(t)});else{if("timeout"!==o)throw new Error('The given type "'.concat(o,'" is not supported'));postMessage({id:e,result:s(t)})}}else{if("set"!==n.method)throw new Error('The given method "'.concat(n.method,'" is not supported'));{const{params:{delay:r,now:s,timerId:a,timerType:m}}=n;if("interval"===m)((t,r,s)=>{const{expected:n,remainingDelay:a}=o(t,s);e.set(r,setTimeout(i,a,e,r,n,"interval"))})(r,a,s);else{if("timeout"!==m)throw new Error('The given type "'.concat(m,'" is not supported'));((e,r,s)=>{const{expected:n,remainingDelay:a}=o(e,s);t.set(r,setTimeout(i,a,t,r,n,"timeout"))})(r,a,s)}}}}catch(e){postMessage({error:{message:e.message},id:n.id,result:null})}}))})();`; // tslint:disable-line:max-line-length
+            const worker = `(()=>{var e={455:function(e,t){!function(e){"use strict";var t=function(e){return function(t){var r=e(t);return t.add(r),r}},r=function(e){return function(t,r){return e.set(t,r),r}},n=void 0===Number.MAX_SAFE_INTEGER?9007199254740991:Number.MAX_SAFE_INTEGER,o=536870912,s=2*o,a=function(e,t){return function(r){var a=t.get(r),i=void 0===a?r.size:a<s?a+1:0;if(!r.has(i))return e(r,i);if(r.size<o){for(;r.has(i);)i=Math.floor(Math.random()*s);return e(r,i)}if(r.size>n)throw new Error("Congratulations, you created a collection of unique numbers which uses all available integers!");for(;r.has(i);)i=Math.floor(Math.random()*n);return e(r,i)}},i=new WeakMap,u=r(i),c=a(u,i),d=t(c);e.addUniqueNumber=d,e.generateUniqueNumber=c}(t)}},t={};function r(n){var o=t[n];if(void 0!==o)return o.exports;var s=t[n]={exports:{}};return e[n].call(s.exports,s,s.exports,r),s.exports}(()=>{"use strict";const e=-32603,t=-32602,n=-32601,o=(e,t)=>Object.assign(new Error(e),{status:t}),s=t=>o('The handler of the method called "'.concat(t,'" returned an unexpected result.'),e),a=(t,r)=>async({data:{id:a,method:i,params:u}})=>{const c=r[i];try{if(void 0===c)throw(e=>o('The requested method called "'.concat(e,'" is not supported.'),n))(i);const r=void 0===u?c():c(u);if(void 0===r)throw(t=>o('The handler of the method called "'.concat(t,'" returned no required result.'),e))(i);const d=r instanceof Promise?await r:r;if(null===a){if(void 0!==d.result)throw s(i)}else{if(void 0===d.result)throw s(i);const{result:e,transferables:r=[]}=d;t.postMessage({id:a,result:e},r)}}catch(e){const{message:r,status:n=-32603}=e;t.postMessage({error:{code:n,message:r},id:a})}};var i=r(455);const u=new Map,c=(e,r,n)=>({...r,connect:({port:t})=>{t.start();const n=e(t,r),o=(0,i.generateUniqueNumber)(u);return u.set(o,(()=>{n(),t.close(),u.delete(o)})),{result:o}},disconnect:({portId:e})=>{const r=u.get(e);if(void 0===r)throw(e=>o('The specified parameter called "portId" with the given value "'.concat(e,'" does not identify a port connected to this worker.'),t))(e);return r(),{result:null}},isSupported:async()=>{if(await new Promise((e=>{const t=new ArrayBuffer(0),{port1:r,port2:n}=new MessageChannel;r.onmessage=({data:t})=>e(null!==t),n.postMessage(t,[t])}))){const e=n();return{result:e instanceof Promise?await e:e}}return{result:!1}}}),d=(e,t,r=()=>!0)=>{const n=c(d,t,r),o=a(e,n);return e.addEventListener("message",o),()=>e.removeEventListener("message",o)},l=e=>t=>{const r=e.get(t);if(void 0===r)return Promise.resolve(!1);const[n,o]=r;return clearTimeout(n),e.delete(t),o(!1),Promise.resolve(!0)},f=(e,t,r)=>(n,o,s)=>{const{expected:a,remainingDelay:i}=e(n,o);return new Promise((e=>{t.set(s,[setTimeout(r,i,a,t,e,s),e])}))},m=(e,t)=>{const r=performance.now(),n=e+t-r-performance.timeOrigin;return{expected:r+n,remainingDelay:n}},p=(e,t,r,n)=>{const o=e-performance.now();o>0?t.set(n,[setTimeout(p,o,e,t,r,n),r]):(t.delete(n),r(!0))},h=new Map,v=l(h),w=new Map,g=l(w),M=f(m,h,p),y=f(m,w,p);d(self,{clear:async({timerId:e,timerType:t})=>({result:await("interval"===t?v(e):g(e))}),set:async({delay:e,now:t,timerId:r,timerType:n})=>({result:await("interval"===n?M:y)(e,t,r)})})})()})();`; // tslint:disable-line:max-line-length
 
             const loadOrReturnBroker = createLoadOrReturnBroker(load, worker);
             const clearInterval = (timerId) => loadOrReturnBroker().clearInterval(timerId);
@@ -1297,16 +1310,17 @@ System.register('DOMUtils', [], (function (exports) {
                         },
                     };
                 }
-                selector(selector) {
-                    return this.selectorAll(selector)[0];
+                selector(selector, parent) {
+                    return this.selectorAll(selector, parent)[0];
                 }
-                selectorAll(selector) {
+                selectorAll(selector, parent) {
                     const context = this;
+                    parent = parent || context.windowApi.document;
                     selector = selector.trim();
                     if (selector.match(/[^\s]{1}:empty$/gi)) {
                         // empty 语法
                         selector = selector.replace(/:empty$/gi, "");
-                        return Array.from(context.windowApi.document.querySelectorAll(selector)).filter(($ele) => {
+                        return Array.from(parent.querySelectorAll(selector)).filter(($ele) => {
                             return $ele?.innerHTML?.trim() === "";
                         });
                     }
@@ -1316,7 +1330,7 @@ System.register('DOMUtils', [], (function (exports) {
                         let textMatch = selector.match(/:contains\(("|')(.*)("|')\)$/i);
                         let text = textMatch[2];
                         selector = selector.replace(/:contains\(("|')(.*)("|')\)$/gi, "");
-                        return Array.from(context.windowApi.document.querySelectorAll(selector)).filter(($ele) => {
+                        return Array.from(parent.querySelectorAll(selector)).filter(($ele) => {
                             // @ts-ignore
                             return ($ele?.textContent || $ele?.innerText)?.includes(text);
                         });
@@ -1334,14 +1348,14 @@ System.register('DOMUtils', [], (function (exports) {
                         }
                         let regexp = new RegExp(pattern, flags);
                         selector = selector.replace(/:regexp\(("|')(.*)("|')\)$/gi, "");
-                        return Array.from(context.windowApi.document.querySelectorAll(selector)).filter(($ele) => {
+                        return Array.from(parent.querySelectorAll(selector)).filter(($ele) => {
                             // @ts-ignore
                             return Boolean(($ele?.textContent || $ele?.innerText)?.match(regexp));
                         });
                     }
                     else {
                         // 普通语法
-                        return Array.from(context.windowApi.document.querySelectorAll(selector));
+                        return Array.from(parent.querySelectorAll(selector));
                     }
                 }
                 /**
@@ -1476,7 +1490,7 @@ System.register('DOMUtils', [], (function (exports) {
                     super(option);
                 }
                 /** 版本号 */
-                version = "2025.6.6";
+                version = "2025.6.26";
                 attr(element, attrName, attrValue) {
                     let DOMUtilsContext = this;
                     if (typeof element === "string") {
@@ -2441,10 +2455,10 @@ System.register('DOMUtils', [], (function (exports) {
                     if (typeof duration !== "number" || duration <= 0) {
                         throw new TypeError("duration must be a positive number");
                     }
-                    if (typeof callback !== "function" && callback !== undefined) {
+                    if (typeof callback !== "function" && callback !== void 0) {
                         throw new TypeError("callback must be a function or null");
                     }
-                    if (typeof styles !== "object" || styles === undefined) {
+                    if (typeof styles !== "object" || styles === void 0) {
                         throw new TypeError("styles must be an object");
                     }
                     if (Object.keys(styles).length === 0) {