worker-timers-worker - npm Package Compare versions

Comparing version 7.0.71 to 8.0.0

build/es2019/helpers/timer.d.ts

@@ -1,5 +0,5 @@
-export declare const clearScheduledInterval: (timerId: number) => void;
-export declare const clearScheduledTimeout: (timerId: number) => void;
-export declare const scheduleInterval: (delay: number, timerId: number, nowInMainThread: number) => void;
-export declare const scheduleTimeout: (delay: number, timerId: number, nowInMainThread: number) => void;
+export declare const clearScheduledInterval: (timerId: number) => boolean;
+export declare const clearScheduledTimeout: (timerId: number) => boolean;
+export declare const scheduleInterval: (delay: number, timerId: number, nowAndTimeOrigin: number) => void;
+export declare const scheduleTimeout: (delay: number, timerId: number, nowAndTimeOrigin: number) => void;
 //# sourceMappingURL=timer.d.ts.map

build/es2019/helpers/timer.js

@@ -5,27 +5,21 @@ const scheduledIntervalIdentifiers = new Map();
     const identifier = scheduledIntervalIdentifiers.get(timerId);
-    if (identifier !== undefined) {
-        clearTimeout(identifier);
-        scheduledIntervalIdentifiers.delete(timerId);
+    if (identifier === undefined) {
+        return false;
     }
-    else {
-        throw new Error(`There is no interval scheduled with the given id "${timerId}".`);
-    }
+    clearTimeout(identifier);
+    scheduledIntervalIdentifiers.delete(timerId);
+    return true;
 };
 export const clearScheduledTimeout = (timerId) => {
     const identifier = scheduledTimeoutIdentifiers.get(timerId);
-    if (identifier !== undefined) {
-        clearTimeout(identifier);
-        scheduledTimeoutIdentifiers.delete(timerId);
+    if (identifier === undefined) {
+        return false;
     }
-    else {
-        throw new Error(`There is no timeout scheduled with the given id "${timerId}".`);
-    }
+    clearTimeout(identifier);
+    scheduledTimeoutIdentifiers.delete(timerId);
+    return true;
 };
-const computeDelayAndExpectedCallbackTime = (delay, nowInMainThread) => {
-    let now;
-    let remainingDelay;
-    const nowInWorker = performance.now();
-    const elapsed = Math.max(0, nowInWorker - nowInMainThread);
-    now = nowInWorker;
-    remainingDelay = delay - elapsed;
+const computeDelayAndExpectedCallbackTime = (delay, nowAndTimeOrigin) => {
+    const now = performance.now();
+    const remainingDelay = delay + nowAndTimeOrigin - now - performance.timeOrigin;
     const expected = now + remainingDelay;
@@ -35,18 +29,19 @@ return { expected, remainingDelay };
 const setTimeoutCallback = (identifiers, timerId, expected, timerType) => {
-    const now = performance.now();
-    if (now > expected) {
-        postMessage({ id: null, method: 'call', params: { timerId, timerType } });
+    const remainingDelay = expected - performance.now();
+    if (remainingDelay > 0) {
+        identifiers.set(timerId, setTimeout(setTimeoutCallback, remainingDelay, identifiers, timerId, expected, timerType));
     }
     else {
-        identifiers.set(timerId, setTimeout(setTimeoutCallback, expected - now, identifiers, timerId, expected, timerType));
+        identifiers.delete(timerId);
+        postMessage({ id: null, method: 'call', params: { timerId, timerType } });
     }
 };
-export const scheduleInterval = (delay, timerId, nowInMainThread) => {
-    const { expected, remainingDelay } = computeDelayAndExpectedCallbackTime(delay, nowInMainThread);
+export const scheduleInterval = (delay, timerId, nowAndTimeOrigin) => {
+    const { expected, remainingDelay } = computeDelayAndExpectedCallbackTime(delay, nowAndTimeOrigin);
     scheduledIntervalIdentifiers.set(timerId, setTimeout(setTimeoutCallback, remainingDelay, scheduledIntervalIdentifiers, timerId, expected, 'interval'));
 };
-export const scheduleTimeout = (delay, timerId, nowInMainThread) => {
-    const { expected, remainingDelay } = computeDelayAndExpectedCallbackTime(delay, nowInMainThread);
+export const scheduleTimeout = (delay, timerId, nowAndTimeOrigin) => {
+    const { expected, remainingDelay } = computeDelayAndExpectedCallbackTime(delay, nowAndTimeOrigin);
     scheduledTimeoutIdentifiers.set(timerId, setTimeout(setTimeoutCallback, remainingDelay, scheduledTimeoutIdentifiers, timerId, expected, 'timeout'));
 };
 //# sourceMappingURL=timer.js.map

build/es2019/interfaces/clear-response.d.ts

 export interface IClearResponse {
-    error: null;
     id: number;
+    result: boolean;
 }
 //# sourceMappingURL=clear-response.d.ts.map

build/es2019/module.js

@@ -13,8 +13,6 @@ import { clearScheduledInterval, clearScheduledTimeout, scheduleInterval, scheduleTimeout } from './helpers/timer';
             if (timerType === 'interval') {
-                clearScheduledInterval(timerId);
-                postMessage({ error: null, id });
+                postMessage({ id, result: clearScheduledInterval(timerId) });
             }
             else if (timerType === 'timeout') {
-                clearScheduledTimeout(timerId);
-                postMessage({ error: null, id });
+                postMessage({ id, result: clearScheduledTimeout(timerId) });
             }
@@ -21,0 +19,0 @@ else {

build/es5/bundle.js

@@ -10,25 +10,21 @@ (function (factory) {
       var identifier = scheduledIntervalIdentifiers.get(timerId);
-      if (identifier !== undefined) {
-        clearTimeout(identifier);
-        scheduledIntervalIdentifiers["delete"](timerId);
-      } else {
-        throw new Error("There is no interval scheduled with the given id \"".concat(timerId, "\"."));
+      if (identifier === undefined) {
+        return false;
       }
+      clearTimeout(identifier);
+      scheduledIntervalIdentifiers["delete"](timerId);
+      return true;
     };
     var clearScheduledTimeout = function clearScheduledTimeout(timerId) {
       var identifier = scheduledTimeoutIdentifiers.get(timerId);
-      if (identifier !== undefined) {
-        clearTimeout(identifier);
-        scheduledTimeoutIdentifiers["delete"](timerId);
-      } else {
-        throw new Error("There is no timeout scheduled with the given id \"".concat(timerId, "\"."));
+      if (identifier === undefined) {
+        return false;
       }
+      clearTimeout(identifier);
+      scheduledTimeoutIdentifiers["delete"](timerId);
+      return true;
     };
-    var computeDelayAndExpectedCallbackTime = function computeDelayAndExpectedCallbackTime(delay, nowInMainThread) {
-      var now;
-      var remainingDelay;
-      var nowInWorker = performance.now();
-      var elapsed = Math.max(0, nowInWorker - nowInMainThread);
-      now = nowInWorker;
-      remainingDelay = delay - elapsed;
+    var computeDelayAndExpectedCallbackTime = function computeDelayAndExpectedCallbackTime(delay, nowAndTimeOrigin) {
+      var now = performance.now();
+      var remainingDelay = delay + nowAndTimeOrigin - now - performance.timeOrigin;
       var expected = now + remainingDelay;
@@ -41,4 +37,7 @@ return {
     var setTimeoutCallback = function setTimeoutCallback(identifiers, timerId, expected, timerType) {
-      var now = performance.now();
-      if (now > expected) {
+      var remainingDelay = expected - performance.now();
+      if (remainingDelay > 0) {
+        identifiers.set(timerId, setTimeout(setTimeoutCallback, remainingDelay, identifiers, timerId, expected, timerType));
+      } else {
+        identifiers["delete"](timerId);
         postMessage({
@@ -52,8 +51,6 @@ id: null,
         });
-      } else {
-        identifiers.set(timerId, setTimeout(setTimeoutCallback, expected - now, identifiers, timerId, expected, timerType));
       }
     };
-    var scheduleInterval = function scheduleInterval(delay, timerId, nowInMainThread) {
-      var _computeDelayAndExpec = computeDelayAndExpectedCallbackTime(delay, nowInMainThread),
+    var scheduleInterval = function scheduleInterval(delay, timerId, nowAndTimeOrigin) {
+      var _computeDelayAndExpec = computeDelayAndExpectedCallbackTime(delay, nowAndTimeOrigin),
         expected = _computeDelayAndExpec.expected,
@@ -63,4 +60,4 @@ remainingDelay = _computeDelayAndExpec.remainingDelay;
     };
-    var scheduleTimeout = function scheduleTimeout(delay, timerId, nowInMainThread) {
-      var _computeDelayAndExpec2 = computeDelayAndExpectedCallbackTime(delay, nowInMainThread),
+    var scheduleTimeout = function scheduleTimeout(delay, timerId, nowAndTimeOrigin) {
+      var _computeDelayAndExpec2 = computeDelayAndExpectedCallbackTime(delay, nowAndTimeOrigin),
         expected = _computeDelayAndExpec2.expected,
@@ -80,12 +77,10 @@ remainingDelay = _computeDelayAndExpec2.remainingDelay;
           if (timerType === 'interval') {
-            clearScheduledInterval(timerId);
             postMessage({
-              error: null,
-              id: id
+              id: id,
+              result: clearScheduledInterval(timerId)
             });
           } else if (timerType === 'timeout') {
-            clearScheduledTimeout(timerId);
             postMessage({
-              error: null,
-              id: id
+              id: id,
+              result: clearScheduledTimeout(timerId)
             });
@@ -92,0 +87,0 @@ } else {

package.json

@@ -34,3 +34,3 @@ {
         "eslint": "^8.57.0",
-        "eslint-config-holy-grail": "^59.0.8",
+        "eslint-config-holy-grail": "^59.0.10",
         "grunt": "^1.6.1",
@@ -50,3 +50,3 @@ "grunt-cli": "^1.4.3",
         "karma-webpack": "^5.0.1",
-        "lint-staged": "^15.2.2",
+        "lint-staged": "^15.2.4",
         "load-grunt-config": "^4.0.1",
@@ -56,5 +56,5 @@ "memory-fs": "^0.5.0",
         "prettier": "^3.2.5",
-        "rimraf": "^5.0.5",
+        "rimraf": "^5.0.7",
         "rollup": "^4.17.2",
-        "sinon": "^17.0.1",
+        "sinon": "^17.0.2",
         "sinon-chai": "^3.7.0",
@@ -93,3 +93,3 @@ "ts-loader": "^9.5.1",
     "types": "build/es2019/module.d.ts",
-    "version": "7.0.71"
+    "version": "8.0.0"
 }

src/helpers/timer.ts

@@ -9,8 +9,10 @@ import { ICallNotification } from '../interfaces';
 
-    if (identifier !== undefined) {
-        clearTimeout(identifier);
-        scheduledIntervalIdentifiers.delete(timerId);
-    } else {
-        throw new Error(`There is no interval scheduled with the given id "${timerId}".`);
+    if (identifier === undefined) {
+        return false;
     }
+
+    clearTimeout(identifier);
+    scheduledIntervalIdentifiers.delete(timerId);
+
+    return true;
 };
@@ -21,19 +23,15 @@
 
-    if (identifier !== undefined) {
-        clearTimeout(identifier);
-        scheduledTimeoutIdentifiers.delete(timerId);
-    } else {
-        throw new Error(`There is no timeout scheduled with the given id "${timerId}".`);
+    if (identifier === undefined) {
+        return false;
     }
-};
 
-const computeDelayAndExpectedCallbackTime = (delay: number, nowInMainThread: number) => {
-    let now: number;
-    let remainingDelay: number;
-    const nowInWorker = performance.now();
-    const elapsed = Math.max(0, nowInWorker - nowInMainThread);
+    clearTimeout(identifier);
+    scheduledTimeoutIdentifiers.delete(timerId);
 
-    now = nowInWorker;
-    remainingDelay = delay - elapsed;
+    return true;
+};
 
+const computeDelayAndExpectedCallbackTime = (delay: number, nowAndTimeOrigin: number) => {
+    const now = performance.now();
+    const remainingDelay = delay + nowAndTimeOrigin - now - performance.timeOrigin;
     const expected = now + remainingDelay;
@@ -45,13 +43,14 @@
 const setTimeoutCallback = (identifiers: Map<number, number>, timerId: number, expected: number, timerType: string) => {
-    const now = performance.now();
+    const remainingDelay = expected - performance.now();
 
-    if (now > expected) {
+    if (remainingDelay > 0) {
+        identifiers.set(timerId, setTimeout(setTimeoutCallback, remainingDelay, identifiers, timerId, expected, timerType));
+    } else {
+        identifiers.delete(timerId);
         postMessage(<ICallNotification>{ id: null, method: 'call', params: { timerId, timerType } });
-    } else {
-        identifiers.set(timerId, setTimeout(setTimeoutCallback, expected - now, identifiers, timerId, expected, timerType));
     }
 };
 
-export const scheduleInterval = (delay: number, timerId: number, nowInMainThread: number) => {
-    const { expected, remainingDelay } = computeDelayAndExpectedCallbackTime(delay, nowInMainThread);
+export const scheduleInterval = (delay: number, timerId: number, nowAndTimeOrigin: number) => {
+    const { expected, remainingDelay } = computeDelayAndExpectedCallbackTime(delay, nowAndTimeOrigin);
 
@@ -64,4 +63,4 @@ scheduledIntervalIdentifiers.set(
 
-export const scheduleTimeout = (delay: number, timerId: number, nowInMainThread: number) => {
-    const { expected, remainingDelay } = computeDelayAndExpectedCallbackTime(delay, nowInMainThread);
+export const scheduleTimeout = (delay: number, timerId: number, nowAndTimeOrigin: number) => {
+    const { expected, remainingDelay } = computeDelayAndExpectedCallbackTime(delay, nowAndTimeOrigin);
 
@@ -68,0 +67,0 @@ scheduledTimeoutIdentifiers.set(

src/interfaces/clear-response.ts

 export interface IClearResponse {
-    error: null;
+    id: number;
 
-    id: number;
+    result: boolean;
 }

src/module.ts

@@ -20,9 +20,5 @@ import { clearScheduledInterval, clearScheduledTimeout, scheduleInterval, scheduleTimeout } from './helpers/timer';
             if (timerType === 'interval') {
-                clearScheduledInterval(timerId);
-
-                postMessage(<IClearResponse>{ error: null, id });
+                postMessage(<IClearResponse>{ id, result: clearScheduledInterval(timerId) });
             } else if (timerType === 'timeout') {
-                clearScheduledTimeout(timerId);
-
-                postMessage(<IClearResponse>{ error: null, id });
+                postMessage(<IClearResponse>{ id, result: clearScheduledTimeout(timerId) });
             } else {
@@ -29,0 +25,0 @@ throw new Error(`The given type "${timerType}" is not supported`);

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

32357

decreased by-2.39%

Lines of code

472

decreased by-3.48%

No dependency changes