@whitesev/domutils 1.5.3 → 1.5.5

package/dist/index.system.js

@@ -46,6 +46,238 @@ System.register('DOMUtils', [], (function (exports) {
                 }
             }
 
+            const createCache = (lastNumberWeakMap) => {
+                return (collection, nextNumber) => {
+                    lastNumberWeakMap.set(collection, nextNumber);
+                    return nextNumber;
+                };
+            };
+
+            /*
+             * The value of the constant Number.MAX_SAFE_INTEGER equals (2 ** 53 - 1) but it
+             * is fairly new.
+             */
+            const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER === undefined ? 9007199254740991 : Number.MAX_SAFE_INTEGER;
+            const TWO_TO_THE_POWER_OF_TWENTY_NINE = 536870912;
+            const TWO_TO_THE_POWER_OF_THIRTY = TWO_TO_THE_POWER_OF_TWENTY_NINE * 2;
+            const createGenerateUniqueNumber = (cache, lastNumberWeakMap) => {
+                return (collection) => {
+                    const lastNumber = lastNumberWeakMap.get(collection);
+                    /*
+                     * Let's try the cheapest algorithm first. It might fail to produce a new
+                     * number, but it is so cheap that it is okay to take the risk. Just
+                     * increase the last number by one or reset it to 0 if we reached the upper
+                     * bound of SMIs (which stands for small integers). When the last number is
+                     * unknown it is assumed that the collection contains zero based consecutive
+                     * numbers.
+                     */
+                    let nextNumber = lastNumber === undefined ? collection.size : lastNumber < TWO_TO_THE_POWER_OF_THIRTY ? lastNumber + 1 : 0;
+                    if (!collection.has(nextNumber)) {
+                        return cache(collection, nextNumber);
+                    }
+                    /*
+                     * If there are less than half of 2 ** 30 numbers stored in the collection,
+                     * the chance to generate a new random number in the range from 0 to 2 ** 30
+                     * is at least 50%. It's benifitial to use only SMIs because they perform
+                     * much better in any environment based on V8.
+                     */
+                    if (collection.size < TWO_TO_THE_POWER_OF_TWENTY_NINE) {
+                        while (collection.has(nextNumber)) {
+                            nextNumber = Math.floor(Math.random() * TWO_TO_THE_POWER_OF_THIRTY);
+                        }
+                        return cache(collection, nextNumber);
+                    }
+                    // Quickly check if there is a theoretical chance to generate a new number.
+                    if (collection.size > MAX_SAFE_INTEGER) {
+                        throw new Error('Congratulations, you created a collection of unique numbers which uses all available integers!');
+                    }
+                    // Otherwise use the full scale of safely usable integers.
+                    while (collection.has(nextNumber)) {
+                        nextNumber = Math.floor(Math.random() * MAX_SAFE_INTEGER);
+                    }
+                    return cache(collection, nextNumber);
+                };
+            };
+
+            const LAST_NUMBER_WEAK_MAP = new WeakMap();
+            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 isClearResponse = (message) => {
+                return typeof message.id === 'number' && typeof message.result === 'boolean';
+            };
+
+            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();
+                            }
+                        }
+                        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.');
+                                }
+                            }
+                            else if (typeof idOrFunc === 'function') {
+                                idOrFunc();
+                                // A timeout can be savely deleted because it is only called once.
+                                scheduledTimeoutFunctions.delete(timerId);
+                            }
+                        }
+                    }
+                    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 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'
+                                }
+                            });
+                        }
+                    });
+                    worker.postMessage({
+                        id: null,
+                        method: 'set',
+                        params: {
+                            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: {
+                            delay,
+                            now: performance.timeOrigin + performance.now(),
+                            timerId,
+                            timerType: 'timeout'
+                        }
+                    });
+                    return timerId;
+                };
+                return {
+                    clearInterval,
+                    clearTimeout,
+                    setInterval,
+                    setTimeout
+                };
+            };
+
+            const createLoadOrReturnBroker = (loadBroker, worker) => {
+                let broker = null;
+                return () => {
+                    if (broker !== null) {
+                        return broker;
+                    }
+                    const blob = new Blob([worker], { type: 'application/javascript; charset=utf-8' });
+                    const url = URL.createObjectURL(blob);
+                    broker = loadBroker(url);
+                    // Bug #1: Edge up until v18 didn't like the URL to be revoked directly.
+                    setTimeout(() => URL.revokeObjectURL(url));
+                    return broker;
+                };
+            };
+
+            // 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 loadOrReturnBroker = createLoadOrReturnBroker(load, worker);
+            const clearInterval = (timerId) => loadOrReturnBroker().clearInterval(timerId);
+            const clearTimeout = (timerId) => loadOrReturnBroker().clearTimeout(timerId);
+            const setInterval = (...args) => loadOrReturnBroker().setInterval(...args);
+            const setTimeout$1 = (...args) => loadOrReturnBroker().setTimeout(...args);
+
             /** 通用工具类 */
             const DOMUtilsCommonUtils = {
                 windowApi: new WindowApi({
@@ -179,6 +411,58 @@ System.register('DOMUtils', [], (function (exports) {
                         delete target[propName];
                     }
                 },
+                /**
+                 * 自动使用 Worker 执行 setTimeout
+                 */
+                setTimeout(callback, timeout = 0) {
+                    try {
+                        return setTimeout$1(callback, timeout);
+                    }
+                    catch (error) {
+                        return globalThis.setTimeout(callback, timeout);
+                    }
+                },
+                /**
+                 * 配合 .setTimeout 使用
+                 */
+                clearTimeout(timeId) {
+                    try {
+                        if (timeId != null) {
+                            clearTimeout(timeId);
+                        }
+                    }
+                    catch (error) {
+                    }
+                    finally {
+                        globalThis.clearTimeout(timeId);
+                    }
+                },
+                /**
+                 * 自动使用 Worker 执行 setInterval
+                 */
+                setInterval(callback, timeout = 0) {
+                    try {
+                        return setInterval(callback, timeout);
+                    }
+                    catch (error) {
+                        return globalThis.setInterval(callback, timeout);
+                    }
+                },
+                /**
+                 * 配合 .setInterval 使用
+                 */
+                clearInterval(timeId) {
+                    try {
+                        if (timeId != null) {
+                            clearInterval(timeId);
+                        }
+                    }
+                    catch (error) {
+                    }
+                    finally {
+                        globalThis.clearInterval(timeId);
+                    }
+                },
             };
 
             /* 数据 */
@@ -599,7 +883,7 @@ System.register('DOMUtils', [], (function (exports) {
                     }
                     if (checkDOMReadyState()) {
                         /* 检查document状态 */
-                        setTimeout(callback);
+                        DOMUtilsCommonUtils.setTimeout(callback);
                     }
                     else {
                         /* 添加监听 */
@@ -1065,7 +1349,7 @@ System.register('DOMUtils', [], (function (exports) {
                     super(option);
                 }
                 /** 版本号 */
-                version = "2025.4.23";
+                version = "2025.5.26";
                 attr(element, attrName, attrValue) {
                     let DOMUtilsContext = this;
                     if (typeof element === "string") {
@@ -1209,7 +1493,8 @@ System.register('DOMUtils', [], (function (exports) {
                         return;
                     }
                     let setStyleProperty = (propertyName, propertyValue) => {
-                        if (propertyValue === "string" && propertyValue.includes("!important")) {
+                        if (typeof propertyValue === "string" &&
+                            propertyValue.trim().endsWith("!important")) {
                             propertyValue = propertyValue
                                 .trim()
                                 .replace(/!important$/gi, "")
@@ -2046,7 +2331,7 @@ System.register('DOMUtils', [], (function (exports) {
                                 DOMUtilsContext.windowApi.globalThis.getComputedStyle(element)[prop];
                         to[prop] = styles[prop];
                     }
-                    let timer = setInterval(function () {
+                    let timer = DOMUtilsCommonUtils.setInterval(function () {
                         let timePassed = performance.now() - start;
                         let progress = timePassed / duration;
                         if (progress > 1) {
@@ -2057,7 +2342,7 @@ System.register('DOMUtils', [], (function (exports) {
                                 from[prop] + (to[prop] - from[prop]) * progress + "px";
                         }
                         if (progress === 1) {
-                            clearInterval(timer);
+                            DOMUtilsCommonUtils.clearInterval(timer);
                             if (callback) {
                                 callback();
                             }