zpromise - npm Package Compare versions

Comparing version 1.2.4 to 1.3.0

index.js

 'use strict';
 
-const timeChain = require('timechain')
-
-const timechain = new timeChain({ delay: 0 })
-
 class zPromise {
-   /**
-    * 
-    * @param {Object} options
-    * @param {Number} options.timeout 超时时间，单位ms
-    */
-   constructor(options = {}) {
+   constructor() {
 
       let callback
 
-      let promise = new Promise((resolve, reject) => {
+      let promise = new Promise(function (resolve, reject) {
          callback = {
@@ -26,54 +17,10 @@ resolve,
 
-      if (options.delay) {
-
-         promise.resolve = function (data) {
-            timechain.delete(key)
-            callback.resolve(data)
-            promise.state = 'resolve'
-         }
-
-         promise.reject = function (data) {
-            timechain.delete(key)
-            callback.reject(data)
-            promise.state = 'reject'
-         }
-
-         let { resolve, reject, delay } = options
-
-         let key, value
-         if (resolve) {
-            key = promise.resolve
-            value = resolve
-         } else {
-            key = promise.reject
-            value = reject
-         }
-
-         timechain.set(key, value, delay)
-
-      } else {
-
-         promise.resolve = function (data) {
-            promise.state = 'resolve'
-            callback.resolve(data)
-         }
-
-         promise.reject = function (data) {
-            promise.state = 'reject'
-            callback.reject(data)
-         }
-
+      promise.resolve = function (data) {
+         promise.state = 'resolve'
+         callback.resolve(data)
       }
 
-      /**
-       * 基于已有配置创建新的Promise实例
-       */
-      promise.restart = function (newOptions) {
-
-         if (promise.state === 'pending') {
-            promise.resolve()
-         }
-
-         return new zPromise(newOptions || options)
-
+      promise.reject = function (data) {
+         promise.state = 'reject'
+         callback.reject(data)
       }
@@ -80,0 +27,0 @@

package.json

 {
   "name": "zpromise",
-  "version": "1.2.4",
-  "description": "Promise简化包装器，用于增强已有ES6 Promise的易用性",
+  "version": "1.3.0",
+  "description": "ES6 Promise简化包装器，用于增强Promise功能和易用性",
   "main": "index.js",
@@ -26,4 +26,4 @@ "scripts": {
   "dependencies": {
-    "timechain": "^1.3.0"
+    "timechain": "^1.3.1"
   }
 }

README.md

@@ -1,5 +0,3 @@
-<!-- Promise简化包装器，用于增强已有ES6 Promise的易用性 -->
+## Install
 
-### Install
-
 ```
@@ -9,13 +7,13 @@ npm install zpromise
 
-### 特性
+## 特性
 
-* 消除Promise注入函数，直接在Promise实例上调用resolve和reject方法进行状态管理
+* 消除Promise注入函数，可通过Promise实例直接访问resolve()或reject()
 
-* 支持Promise超时触发resolve或reject，解除无限等待
-
 * 支持获取当前Promise实例状态
 
+* 支持Promise超时触发resolve()或reject()
+
 * 支持Promise重启，可复用配置项
 
-### 示例
+## 示例
 
@@ -49,7 +47,7 @@ ```js
 ```js
-const zPromise = require('zpromise');
+const timerPromise = require('zpromise/timer');
 
 async function run(params) {
 
-   let promise = new zPromise({ delay: 3000, reject: "等待超时" })
+   let promise = new timerPromise({ delay: 3000, reject: "等待超时" })
 
@@ -73,7 +71,7 @@ console.log(promise.state)
 ```js
-const zPromise = require('zpromise');
+const timerPromise = require('zpromise/timer');
 
 async function run(params) {
 
-   let p1 = new zPromise({ delay: 3000, resolve: { a: 1 } })
+   let p1 = new timerPromise({ delay: 3000, resolve: { a: 1 } })
 
@@ -104,32 +102,34 @@ await p1.catch(error => {
 
-### API
+## API
 
-#### zPromise(options)
+### zPromise()
 
-* `options` *Object* 配置选项
+> Promise简化包装，提供resolve、reject绑定和状态查询
 
-   * `delay` *Number* 超时时间，单位ms，可选
+#### zPromise.prototype.state
 
-   * `reject` * reject超时返回值，默认
+Promise实例状态，包含pending、resolve、reject三种状态
 
-   * `resolve` * resolve超时返回值
+#### zPromise.prototype.resolve(data)
 
-#### this.state
+对应Promise注入函数中的resolve()
 
-当前promise状态，值分别为pending、resolve、reject
+#### zPromise.prototype.reject(error)
 
-#### this.resolve(data)
+对应Promise注入函数中的reject()
 
-* data 成功返回值
+### timerPromise(options)
 
-代理Promise注入函数中的resolve，成功时执行
+> 在zPromise基础上增加了定时器功能，在等待超时后自动调用预设的reject()或resolve()，原型属性与zPromise一致。
 
-#### this.reject(error)
+* `options` *Object* 配置选项
 
-* error 失败返回值
+   * `delay` *Number* 超时时间，单位ms，可选
 
-代理Promise注入函数中的reject，失败时执行
+   * `reject` * reject超时返回值，默认
 
-#### this.restart(options)
+   * `resolve` * resolve超时返回值
 
+#### timerPromise.prototype.restart(options)
+
 * options 与zPromise创建实例时的参数一样
@@ -136,0 +136,0 @@

test/index.js

@@ -5,39 +5,42 @@ 'use strict';
 const zPromise = require('..');
-const { sleep } = require('./helpers/');
 
-test('reject', async t => {
+test('resolve', async t => {
 
-   let promise = new zPromise({ delay: 2000, reject: '等待超时' })
+   let zpromise = new zPromise()
 
-   promise.catch(function (error) {
-
+   zpromise.then(function () {
+      t.deepEqual('resolve', zpromise.state)
+   }).catch(function () {
+      t.deepEqual('reject', zpromise.state)
    })
 
-   t.deepEqual('pending', promise.state)
+   zpromise.resolve()
 
-   await sleep(1000)
-   
-   t.deepEqual('pending', promise.state)
+   t.deepEqual('resolve', zpromise.state)
 
-   await sleep(3000)
+})
 
-   t.deepEqual('reject', promise.state)
 
-})
+test('reject', async t => {
 
+   let zpromise = new zPromise()
 
-test('resolve', async t => {
+   zpromise.catch(function () {
 
-   let promise = new zPromise({ delay: 2000, resolve: { a: 1 } })
+      t.deepEqual('reject', zpromise.state)
 
-   t.deepEqual('pending', promise.state)
+   })
 
-   await sleep(1000)
+   zpromise.reject(111)
 
-   t.deepEqual('pending', promise.state)
+   t.deepEqual('reject', zpromise.state)
 
-   await sleep(2000)
+   let  result = await zpromise.catch(function (error) {
 
-   t.deepEqual('resolve', promise.state)
+      return error
+      
+   })
 
+   t.deepEqual(111, result)
+
 })

test/restart.js

@@ -0,7 +1,9 @@
+"use strict"
+
 const test = require('jtf');
-const zPromise = require('..');
+const timerPromise = require('../timer');
 
 test('restart', async t => {
 
-   let p1 = new zPromise({
+   let p1 = new timerPromise({
       delay: 3000,
@@ -18,9 +20,7 @@ resolve: "等待超时"
 
-   t.equal(p1.state, 'resolve');
-
    t.equal(result, "等待超时");
 
-   t.equal(await p1, "等待超时");
+   t.equal(p1.state, 'resolve');
 
-   let p2 = p1.restart({
+   p1 = p1.restart({
       delay: 2000,
@@ -30,9 +30,9 @@ reject: "等待超时"
 
-   await p2.catch(error => {
+   p1.catch(error => {
       t.equal(error, "等待超时")
    })
 
-   let p3 = p2.restart()
+   p1 = p1.restart()
 
-   await p3.catch(error => {
+   await p1.catch(error => {
       t.equal(error, "等待超时")
@@ -39,0 +39,0 @@ })

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

7680

increased by5.58%

Number of package files

9

increased by12.5%

Lines of code

150

increased by6.38%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• Updatedtimechain@^1.3.1