brummelte / sleep-promise Goto Github PK

Hi again @brummelte and thanks for your efforts to move the project to the next level!

I'm writing to report that sleep-promise v4.1 does not work in a TypeScript project. This is because Node still imports a js file rather than an mjs, but that file does not have a default export. Now the library is not usable because when I type import * as sleep from "sleep-promise", I get a TypeScript compiler error, expectedly coming from index.d.ts, but when I try import sleep as "sleep-promise" and get cool TS hints, this exception shows up:

TypeError: sleep_promise_1.default is not a function

I guess you'll need to export sleep function twice to make bundle.js compatible with both require and import:

module.exports = sleep;
module.exports.default = module.exports;

This is what chalk does at least, but they are implementing both flavours of exports manually. Given that your source is in es6 now, perhaps, there is some rollup option that would do the trick?

Rolling back to v2 for now 😉

An unnecessary dependency on core-js was removed in #27 in October. However, the latest published release (9.0.0) still includes it. It’d be great if you could release 9.0.1 at some point, which would not includecore-js. This may resolve certain issues related to dependency hoisting and resolution. Cheers!

Please clarify what the units are for the timeout argument by adding a comment.

sinon is a popular stubbing framework for JavaScript unit tests. sinon.useFakeTimers() replaces the global setTimeout() method with its own, allowing unit tests to instantly move time forward instead of waiting for time to pass.

Because this project calls the global setTimeout() method, it will not work if sinon.useFakeTimers() is called.

A simple solution would be to store the global setTimeout() method before sinon replaces it:

sleep-promise/lib/index.js

const setTimeout = global.setTimeout;

// sleep() implementation...

someProject/test.js

const sleep = require('sleep-promise');
const clock = sinon.useFakeTimers();

// Unit test code...

If you're ok with this from a design perspective, I'd be happy to open a PR.

There is an error with this repository's Renovate configuration that needs to be fixed. As a precaution, Renovate will stop PRs until it is resolved.

Error type: undefined. Note: this is a nested preset so please contact the preset author if you are unable to fix it yourself.

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

Open

These updates have all been created already. Click a checkbox below to force a retry/rebase of any.

• chore(deps): replace dependency rollup-plugin-babel with @rollup/plugin-babel ^5.0.0
• chore(deps): replace dependency rollup-plugin-node-resolve with @rollup/plugin-node-resolve ^6.0.0
• chore(deps): replace dependency rollup-plugin-terser with @rollup/plugin-terser ^0.1.0
• chore(deps): update dependency @brummelte/eslint-config to v10
• chore(deps): update dependency eslint to v9
• chore(deps): update dependency rollup to v4
• chore(deps): update semantic-release monorepo (major) (@semantic-release/commit-analyzer, @semantic-release/release-notes-generator, semantic-release)
• Click on this checkbox to rebase all open PRs at once

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

I imagine a method to delay a promise chain would be extremely useful.

Something to allow:

Promise.resolve("hello world")
    .then(sleep(5000))
    .then(x => x.toUpperCase())
    .then(x => console.log(x))

this can be useful to control an animation or display a notification

sendEmail("[email protected]")
    .then(showNotification)
    .then(sleep(200))
    .then(id => hideNotification(id))

what do you think?

I'm using this library for handling timeout stuffs or something else like:

await Promise.all([
  triggerPromise(),
  Promise.race([
    eventPromise.then(...), // event might be invoked or not
    sleep(1000).then(() => Promise.reject('timeout exceeded of 1000ms while ...')), // timeout
  ]),
]);

(feature request)
In the case above all things are good, however I have faced a situation where the sleep promise should be cancelled to continue, as like:

const timeout = sleep(1000).then(() => Promise.reject(...));
await Promise.all([
  triggerPromise(),
  Promise.race([
    eventPromise.then(() => {
      timeout.cancel(); // here
      return operationPromiseThatTakesMoreThanTimeout();
    }),
    timeout,
  ]);
]);

(current solution)
Anyway, this goal can be reached by writing code like as follows:

const timeout = sleep(1000).then(() => Promise.reject(...));
await Promise.all([
  triggerPromise(),
  new Promise((resolve, reject) => {
    let handled = false;

    eventPromise.then(() => {
      handled = true;
      operationPromiseThatTakesMoreThanTimeout().then(resolve);
    });

    sleep(1000).then(() => { // or `setTimeout`
      if (handled) {
        return;
      }
      reject(...);
    });
  }),
]);

(or similar)

but you may know this is bad idea/style, just because if sleep-promise supports promise cancellation for the case like this.

The README example shows

import sleep from 'sleep-promise';

This is a default import. But there's no default export on this module:

> require('sleep-promise').default
undefined

It'd be great if the library provided TypeScript typings! Otherwise, this warning is shown next to import * as sleep from "sleep-promise";:

Could not find a declaration file for module 'sleep-promise'.
'/path/to/project/node_modules/sleep-promise/lib/index.js' implicitly has an 'any' type.
Try `npm install @types/sleep-promise` if it exists or add a new declaration
(.d.ts) file containing `declare module 'sleep-promise';`

I can submit a PR if this idea gets approved.