@jrc03c/pause 0.0.10 → 0.0.12

package/.prettierrc.json

@@ -0,0 +1,10 @@
+{
+  "arrowParens": "avoid",
+  "bracketSameLine": true,
+  "htmlWhitespaceSensitivity": "ignore",
+  "semi": false,
+  "singleQuote": false,
+  "tabWidth": 2,
+  "useTabs": false,
+  "vueIndentScriptAndStyle": true
+}

package/dist/pause.js

@@ -1,28 +1,18 @@
 (() => {
   // src/index.mjs
-  function pauseAsync(ms) {
+  function pause(ms) {
     return new Promise((resolve, reject) => {
       try {
-        const start = /* @__PURE__ */ new Date();
-        return setTimeout(() => resolve(/* @__PURE__ */ new Date() - start), ms);
+        const start = performance.now();
+        return setTimeout(() => resolve(performance.now() - start), ms);
       } catch (e) {
         return reject(e);
       }
     });
   }
-  function pauseSync(ms) {
-    const start = /* @__PURE__ */ new Date();
-    let now = /* @__PURE__ */ new Date();
-    while (now - start < ms) {
-      now = /* @__PURE__ */ new Date();
-    }
-    return /* @__PURE__ */ new Date() - start;
-  }
 
   // src/iife.mjs
   if (typeof globalThis !== "undefined") {
-    globalThis.pause = pauseAsync;
-    globalThis.pauseAsync = pauseAsync;
-    globalThis.pauseSync = pauseSync;
+    globalThis.pause = pause;
   }
 })();

package/dist/pause.min.js

@@ -1 +1 @@
-(()=>{function s(t){return new Promise((e,n)=>{try{let a=new Date;return setTimeout(()=>e(new Date-a),t)}catch(a){return n(a)}})}function u(t){let e=new Date,n=new Date;for(;n-e<t;)n=new Date;return new Date-e}typeof globalThis<"u"&&(globalThis.pause=s,globalThis.pauseAsync=s,globalThis.pauseSync=u);})();
+(()=>{function r(n){return new Promise((t,o)=>{try{let e=performance.now();return setTimeout(()=>t(performance.now()-e),n)}catch(e){return o(e)}})}typeof globalThis<"u"&&(globalThis.pause=r);})();

package/package.json

@@ -3,7 +3,7 @@
   "description": "a simple async pause function",
   "devDependencies": {
     "@eslint/js": "^9.12.0",
-    "esbuild": "^0.24.0",
+    "esbuild": "^0.25.4",
     "eslint": "^9.12.0",
     "globals": "^15.11.0",
     "prettier": "^3.3.3"
@@ -18,5 +18,10 @@
   "module": "./src/index.mjs",
   "name": "@jrc03c/pause",
   "type": "module",
-  "version": "0.0.10"
-}
+  "version": "0.0.12",
+  "scripts": {
+    "build": "node build.mjs",
+    "pub": "npm version patch --force && npm publish --access=public",
+    "test": "node src/index.test.mjs"
+  }
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+onlyBuiltDependencies:
+  - esbuild

package/readme.md

@@ -0,0 +1,31 @@
+# Intro
+
+An asynchronous `pause` function
+
+# Installation
+
+```bash
+npm install --save @jrc03c/pause
+```
+
+# Usage
+
+```js
+import { pause } from "@jrc03c/pause"
+
+pause(1000).then(elapsed => {
+  console.log(`${elapsed} milliseconds have elapsed!`)
+})
+```
+
+# API
+
+## `pause(ms)`
+
+Given a number of milliseconds, `ms`, for which to pause, returns a `Promise` that resolves to a number indicating how many milliseconds have actually elapsed since the function was called.
+
+## `pauseSync(ms)`
+
+Given a number of milliseconds, `ms`, for which to pause, returns a number indicating how many milliseconds have actually elapsed since the function was called.
+
+> **WARNING:** Because this function is synchronous, it completely blocks its thread while running! Therefore, you should probably almost never use this in production. I provide it mainly because it's useful in some testing contexts.

package/src/iife.mjs

@@ -1,7 +1,5 @@
-import { pause, pauseAsync, pauseSync } from "./index.mjs"
+import { pause } from "./index.mjs"
 
 if (typeof globalThis !== "undefined") {
-  globalThis.pause = pauseAsync
-  globalThis.pauseAsync = pauseAsync
-  globalThis.pauseSync = pauseSync
+  globalThis.pause = pause
 }

package/src/index.mjs

@@ -1,8 +1,8 @@
-function pauseAsync(ms) {
+function pause(ms) {
   return new Promise((resolve, reject) => {
     try {
-      const start = new Date()
-      return setTimeout(() => resolve(new Date() - start), ms)
+      const start = performance.now()
+      return setTimeout(() => resolve(performance.now() - start), ms)
     } catch (e) {
       return reject(e)
     }
@@ -10,14 +10,16 @@ function pauseAsync(ms) {
 }
 
 function pauseSync(ms) {
-  const start = new Date()
-  let now = new Date()
+  const start = performance.now()
+  let isStillWaiting = true
 
-  while (now - start < ms) {
-    now = new Date()
+  while (isStillWaiting) {
+    if (performance.now() - start >= ms) {
+      isStillWaiting = false
+    }
   }
 
-  return new Date() - start
+  return performance.now() - start
 }
 
-export { pauseAsync as pause, pauseAsync, pauseSync }
+export { pause, pauseSync }

package/src/index.test.mjs

@@ -1,65 +1,63 @@
-import { pauseAsync, pauseSync } from "./index.mjs"
-
-let syncTestsAreRunning = true
+import { pause, pauseSync } from "./index.mjs"
 
 !(async () => {
-  while (syncTestsAreRunning) {
-    await pauseAsync(100)
-  }
-
-  const start = new Date()
-
-  for (let i = 0; i < 100; i++) {
-    const t = Math.floor(Math.random() * 100)
-    const elapsed = await pauseAsync(t)
-
-    if (typeof elapsed !== "number" || isNaN(elapsed)) {
-      throw new Error(
-        `The function was supposed to return a number representing the number of milliseconds that elapsed since the function was called, but instead it returned a ${typeof elapsed} value! (${elapsed})`,
-      )
-    }
-
-    // there should be less than 10ms difference between the given time and the
-    // actual elapsed time
-    if (Math.abs(elapsed - t) > 10) {
-      throw new Error(
-        `The function was supposed to wait for ${t}ms, but instead it waited for ${elapsed}ms!`,
-      )
-    }
-  }
-
-  const seconds = (new Date() - start) / 1000
-
-  console.log(
-    `🎉 All asynchronous tests passed! (${seconds.toFixed(2)} seconds)`,
-  )
-})()
-
-!(() => {
-  const start = new Date()
-
-  for (let i = 0; i < 100; i++) {
-    const t = Math.floor(Math.random() * 100)
-    const elapsed = pauseSync(t)
-
-    if (typeof elapsed !== "number" || isNaN(elapsed)) {
-      throw new Error(
-        `The function was supposed to return a number representing the number of milliseconds that elapsed since the function was called, but instead it returned a ${typeof elapsed} value! (${elapsed})`,
-      )
+  // asynchronous tests
+  await (async () => {
+    const start = performance.now()
+
+    for (let i = 0; i < 100; i++) {
+      const t = Math.floor(Math.random() * 100)
+      const elapsed = await pause(t)
+
+      if (typeof elapsed !== "number" || isNaN(elapsed)) {
+        throw new Error(
+          `The function was supposed to return a number representing the number of milliseconds that elapsed since the function was called, but instead it returned a ${typeof elapsed} value! (${elapsed})`,
+        )
+      }
+
+      // there should be less than 10ms difference between the given time and
+      // the actual elapsed time
+      if (Math.abs(elapsed - t) > 10) {
+        throw new Error(
+          `The function was supposed to wait for ${t}ms, but instead it waited for ${elapsed}ms!`,
+        )
+      }
     }
 
-    if (elapsed < t) {
-      throw new Error(
-        `The function was supposed to wait for ${t}ms, but instead it only waited for ${elapsed}ms!`,
-      )
+    const seconds = (performance.now() - start) / 1000
+
+    console.log(
+      `🎉 All asynchronous tests passed! (${seconds.toFixed(2)} seconds)`,
+    )
+  })()
+
+  // synchronous tests
+  !(() => {
+    const start = performance.now()
+
+    for (let i = 0; i < 100; i++) {
+      const t = Math.floor(Math.random() * 100)
+      const elapsed = pauseSync(t)
+
+      if (typeof elapsed !== "number" || isNaN(elapsed)) {
+        throw new Error(
+          `The function was supposed to return a number representing the number of milliseconds that elapsed since the function was called, but instead it returned a ${typeof elapsed} value! (${elapsed})`,
+        )
+      }
+
+      // there should be less than 10ms difference between the given time and
+      // the actual elapsed time
+      if (Math.abs(elapsed - t) > 10) {
+        throw new Error(
+          `The function was supposed to wait for ${t}ms, but instead it waited for ${elapsed}ms!`,
+        )
+      }
     }
-  }
-
-  const seconds = (new Date() - start) / 1000
 
-  console.log(
-    `🎉 All synchronous tests passed! (${seconds.toFixed(2)} seconds)`,
-  )
+    const seconds = (performance.now() - start) / 1000
 
-  syncTestsAreRunning = false
+    console.log(
+      `🎉 All synchronous tests passed! (${seconds.toFixed(2)} seconds)`,
+    )
+  })()
 })()

package/moon.yml

@@ -1,29 +0,0 @@
-language: javascript
-tasks:
-  build:
-    command:
-      - node
-      - build.mjs
-    platform: node
-  pub:
-    command:
-      - npm
-      - publish
-      - --access=public
-    deps:
-      - ~:pub-dep1
-    local: true
-    platform: node
-  pub-dep1:
-    command:
-      - npm
-      - version
-      - patch
-      - --force
-    local: true
-    platform: node
-  test:
-    command:
-      - node
-      - src/index.test.mjs
-    platform: node