wsemi 1.8.12 → 1.8.13

package/g.mjs

@@ -7,53 +7,164 @@ import fsDeleteFolder from './src/fsDeleteFolder.mjs'
 import fsSrlog from './src/fsSrlog.mjs'
 import dig from './src/dig.mjs'
 import genPm from './src/genPm.mjs'
-import fsBuildReadStreamText from './src/fsBuildReadStreamText.mjs'
+import delay from './src/delay.mjs'
+import cacheBd from './src/cacheBd.mjs'
 
 
-let test = async () => {
-
+let test1 = async () => {
     let ms = []
 
-    let fdt = './_test_fsBuildReadStreamText'
-    fsCreateFolder(fdt) //創建臨時任務資料夾
+    let fun = async(p1, p2) => {
+        await delay(300)
+        return `${p1}:${p2}`
+    }
+
+    let bc = cacheBd(fun)
+    let execFun = bc.get
+    let execFunCache = bc.getByCache
+
+    let pm1 = execFunCache(123, 'abc') //pm1執行取得快取, 因無快取將持續等待
+    pm1
+        .then((res) => {
+            // console.log('res', res)
+            ms.push({ result: `pm1-${res}` })
+        })
+
+    let pm2 = execFun(4.56, 'def') //pm2執行原本函數與使用輸入, 會最先回傳, 且更新快取給等待或之後取得快取使用
+    pm2
+        .then((res) => {
+            // console.log('res', res)
+            ms.push({ result: `pm2-${res}` })
+        })
+
+    let pm3 = execFunCache(78.9, 'xyz') //pm3執行取得快取, 因已有快取將直接取得快取
+    pm3
+        .then((res) => {
+            // console.log('res', res)
+            ms.push({ result: `pm3-${res}` })
+        })
+
+    await Promise.all([pm1, pm2, pm3])
+    // console.log('rs', rs)
+
+    console.log('ms', ms)
+    return ms
+}
+await test1()
+// ms [
+//   { result: 'pm2-4.56:def' },
+//   { result: 'pm1-4.56:def' },
+//   { result: 'pm3-4.56:def' }
+// ]
+
+
+let test2 = async () => {
+    let ms = []
 
-    let fn = 't1.txt'
-    let fp = `${fdt}/${fn}`
+    let fun = async(p1, p2) => {
+        await delay(300)
+        return `${p1}:${p2}`
+    }
 
-    fs.writeFileSync(fp, `abc
-測試中文
-def123xyz
-`, 'utf8')
+    let bc = cacheBd(fun)
+    let execFun = bc.get
+    let execFunCache = bc.getByCache
 
-    let ev = fsBuildReadStreamText(fp)
-    ms.push({ 'create': '' })
+    setTimeout(() => {
+        console.log('pm1 exec..')
+        let pm1 = execFunCache(123, 'abc') //pm1執行取得快取, 因無快取將持續等待
+        pm1
+            .then((res) => {
+                console.log('pm1 then', res)
+                ms.push({ result: `pm1-${res}` })
+            })
+    }, 1)
 
-    ev.on('line', (line) => {
-        console.log('line', line)
-        ms.push({ line })
-    })
+    setTimeout(() => {
+        console.log('pm2 exec..')
+        let pm2 = execFun(4.56, 'def') //1000ms後, pm2執行原本函數與使用輸入, 會最先回傳, 且更新快取給等待或之後取得快取使用
+        pm2
+            .then((res) => {
+                console.log('pm2 then', res)
+                ms.push({ result: `pm2-${res}` })
+            })
+    }, 1000)
 
-    let pm = genPm()
-    ev.on('close', () => {
-        console.log('close')
-        pm.resolve()
-        ms.push({ 'close': '' })
-    })
-    await pm
+    setTimeout(() => {
+        console.log('pm3 exec..')
+        let pm3 = execFunCache(78.9, 'xyz') //pm3執行取得快取, 因已有快取將直接取得快取
+        pm3
+            .then((res) => {
+                console.log('pm3 then', res)
+                ms.push({ result: `pm3-${res}` })
+            })
+    }, 3000)
 
-    fsDeleteFolder(fdt) //刪除臨時任務資料夾
+    await delay(5000)
 
     console.log('ms', ms)
     return ms
 }
-await test()
+await test2()
 // ms [
-//   { create: '' },
-//   { line: 'abc' },
-//   { line: '測試中文' },
-//   { line: 'def123xyz' },
-//   { close: '' }
+//   { result: 'pm2-4.56:def' },
+//   { result: 'pm1-4.56:def' },
+//   { result: 'pm3-4.56:def' }
 // ]
 
 
+let test3 = async () => {
+    let ms = []
+
+    let fun = async(p1, p2) => {
+        await delay(300)
+        return `${p1}:${p2}`
+    }
+
+    let bc = cacheBd(fun)
+    let execFun = bc.get
+    let execFunCache = bc.getByCache
+
+    setTimeout(() => {
+        console.log('pm1 exec..')
+        let pm1 = execFunCache(123, 'abc') //pm1執行取得快取, 因無快取將持續等待, 3000ms將執行get與自己的輸入, 並最先回傳
+        pm1
+            .then((res) => {
+                console.log('pm1 then', res)
+                ms.push({ result: `pm1-${res}` })
+            })
+    }, 1)
+
+    setTimeout(() => {
+        console.log('pm2 exec..')
+        let pm2 = execFun(4.56, 'def') //3500ms後, pm2執行原本函數與使用輸入, 計算完畢則會覆蓋快取, 此快取將再給等待或之後取得快取使用
+        pm2
+            .then((res) => {
+                console.log('pm2 then', res)
+                ms.push({ result: `pm2-${res}` })
+            })
+    }, 3500)
+
+    setTimeout(() => {
+        console.log('pm3 exec..')
+        let pm3 = execFunCache(78.9, 'xyz') //pm3執行取得快取, 因已有快取將直接取得快取
+        pm3
+            .then((res) => {
+                console.log('pm3 then', res)
+                ms.push({ result: `pm3-${res}` })
+            })
+    }, 4500)
+
+    await delay(6500)
+
+    console.log('ms', ms)
+    return ms
+}
+await test3()
+// ms [
+//   { result: 'pm1-123:abc' },
+//   { result: 'pm2-4.56:def' },
+//   { result: 'pm3-4.56:def' }
+// ]
+
 //node g.mjs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wsemi",
-  "version": "1.8.12",
+  "version": "1.8.13",
   "main": "dist/wsemi.umd.js",
   "dependencies": {
     "chokidar": "^4.0.3",

package/src/cache.mjs

@@ -10,7 +10,7 @@ import cint from './cint.mjs'
 
 
 /**
- * 非同步函數快取
+ * 非同步函數快取，通過指定key代表函數與其輸入進行執行並快取，快取可設定失效時間，超過失效時間則重新執行與再更新快取
  *
  * Unit Test: {@link https://github.com/yuda-lyu/wsemi/blob/master/test/cache.test.mjs Github}
  * @memberOf wsemi

package/src/cacheBd.mjs

@@ -0,0 +1,237 @@
+import get from 'lodash-es/get.js'
+import ispint from './ispint.mjs'
+import cint from './cint.mjs'
+import delay from './delay.mjs'
+
+
+/**
+ * 封裝非同步函數與再提供使用快取版
+ *
+ * Unit Test: {@link https://github.com/yuda-lyu/wsemi/blob/master/test/cacheBd.test.mjs Github}
+ * @memberOf wsemi
+ * @param {Function} fun 輸入非同步函數
+ * @param {Object} [opt={}] 輸入設定物件，預設{}
+ * @param {Integer} [nMax=200] 輸入使用快取版之總嘗試次數整數，超過則報錯，預設200
+ * @param {Integer} [nTrigger=3] 輸入嘗試指定次數整數，若嘗試指定次數之後皆無快取則須自動執行get用以取得快取，預設3
+ * @returns {Object} 回傳事件物件，可呼叫事件get、getByCache，get為封裝後封裝原本非同步函數，getByCache為提供取用快取版之非同步函數，若有快取則優先使用，若超過指定次數則自動執行get使能取得快取
+ * @example
+ *
+ * let test1 = async () => {
+ *     let ms = []
+ *
+ *     let fun = async(p1, p2) => {
+ *         await delay(300)
+ *         return `${p1}:${p2}`
+ *     }
+ *
+ *     let bc = cacheBd(fun)
+ *     let execFun = bc.get
+ *     let execFunCache = bc.getByCache
+ *
+ *     let pm1 = execFunCache(123, 'abc') //pm1執行取得快取, 因無快取將持續等待
+ *     pm1
+ *         .then((res) => {
+ *             // console.log('res', res)
+ *             ms.push({ result: `pm1-${res}` })
+ *         })
+ *
+ *     let pm2 = execFun(4.56, 'def') //pm2執行原本函數與使用輸入, 會最先回傳, 且更新快取給等待或之後取得快取使用
+ *     pm2
+ *         .then((res) => {
+ *             // console.log('res', res)
+ *             ms.push({ result: `pm2-${res}` })
+ *         })
+ *
+ *     let pm3 = execFunCache(78.9, 'xyz') //pm3執行取得快取, 因已有快取將直接取得快取
+ *     pm3
+ *         .then((res) => {
+ *             // console.log('res', res)
+ *             ms.push({ result: `pm3-${res}` })
+ *         })
+ *
+ *     await Promise.all([pm1, pm2, pm3])
+ *     // console.log('rs', rs)
+ *
+ *     console.log('ms', ms)
+ *     return ms
+ * }
+ * await test1()
+ * // ms [
+ * //   { result: 'pm2-4.56:def' },
+ * //   { result: 'pm1-4.56:def' },
+ * //   { result: 'pm3-4.56:def' }
+ * // ]
+ *
+ * let test2 = async () => {
+ *     let ms = []
+ *
+ *     let fun = async(p1, p2) => {
+ *         await delay(300)
+ *         return `${p1}:${p2}`
+ *     }
+ *
+ *     let bc = cacheBd(fun)
+ *     let execFun = bc.get
+ *     let execFunCache = bc.getByCache
+ *
+ *     setTimeout(() => {
+ *         console.log('pm1 exec..')
+ *         let pm1 = execFunCache(123, 'abc') //pm1執行取得快取, 因無快取將持續等待
+ *         pm1
+ *             .then((res) => {
+ *                 console.log('pm1 then', res)
+ *                 ms.push({ result: `pm1-${res}` })
+ *             })
+ *     }, 1)
+ *
+ *     setTimeout(() => {
+ *         console.log('pm2 exec..')
+ *         let pm2 = execFun(4.56, 'def') //1000ms後, pm2執行原本函數與使用輸入, 會最先回傳, 且更新快取給等待或之後取得快取使用
+ *         pm2
+ *             .then((res) => {
+ *                 console.log('pm2 then', res)
+ *                 ms.push({ result: `pm2-${res}` })
+ *             })
+ *     }, 1000)
+ *
+ *     setTimeout(() => {
+ *         console.log('pm3 exec..')
+ *         let pm3 = execFunCache(78.9, 'xyz') //pm3執行取得快取, 因已有快取將直接取得快取
+ *         pm3
+ *             .then((res) => {
+ *                 console.log('pm3 then', res)
+ *                 ms.push({ result: `pm3-${res}` })
+ *             })
+ *     }, 3000)
+ *
+ *     await delay(5000)
+ *
+ *     console.log('ms', ms)
+ *     return ms
+ * }
+ * await test2()
+ * // ms [
+ * //   { result: 'pm2-4.56:def' },
+ * //   { result: 'pm1-4.56:def' },
+ * //   { result: 'pm3-4.56:def' }
+ * // ]
+ *
+ * let test3 = async () => {
+ *     let ms = []
+ *
+ *     let fun = async(p1, p2) => {
+ *         await delay(300)
+ *         return `${p1}:${p2}`
+ *     }
+ *
+ *     let bc = cacheBd(fun)
+ *     let execFun = bc.get
+ *     let execFunCache = bc.getByCache
+ *
+ *     setTimeout(() => {
+ *         console.log('pm1 exec..')
+ *         let pm1 = execFunCache(123, 'abc') //pm1執行取得快取, 因無快取將持續等待, 3000ms將執行get與自己的輸入, 並最先回傳
+ *         pm1
+ *             .then((res) => {
+ *                 console.log('pm1 then', res)
+ *                 ms.push({ result: `pm1-${res}` })
+ *             })
+ *     }, 1)
+ *
+ *     setTimeout(() => {
+ *         console.log('pm2 exec..')
+ *         let pm2 = execFun(4.56, 'def') //3500ms後, pm2執行原本函數與使用輸入, 計算完畢則會覆蓋快取, 此快取將再給等待或之後取得快取使用
+ *         pm2
+ *             .then((res) => {
+ *                 console.log('pm2 then', res)
+ *                 ms.push({ result: `pm2-${res}` })
+ *             })
+ *     }, 3500)
+ *
+ *     setTimeout(() => {
+ *         console.log('pm3 exec..')
+ *         let pm3 = execFunCache(78.9, 'xyz') //pm3執行取得快取, 因已有快取將直接取得快取
+ *         pm3
+ *             .then((res) => {
+ *                 console.log('pm3 then', res)
+ *                 ms.push({ result: `pm3-${res}` })
+ *             })
+ *     }, 4500)
+ *
+ *     await delay(6500)
+ *
+ *     console.log('ms', ms)
+ *     return ms
+ * }
+ * await test3()
+ * // ms [
+ * //   { result: 'pm1-123:abc' },
+ * //   { result: 'pm2-4.56:def' },
+ * //   { result: 'pm3-4.56:def' }
+ * // ]
+ *
+ */
+function cacheBd(fun, opt = {}) {
+
+    //nMax
+    let nMax = get(opt, 'nMax')
+    if (!ispint(nMax)) {
+        nMax = 200
+    }
+    nMax = cint(nMax)
+
+    //nTrigger
+    let nTrigger = get(opt, 'nTrigger')
+    if (!ispint(nTrigger)) {
+        nTrigger = 3
+    }
+    nTrigger = cint(nTrigger)
+
+    //快取
+    let cc = null
+
+    //函數執行狀態
+    let lock = false
+
+    //_get, 封裝原本非同步函數
+    let _get = async(...inputs) => {
+        lock = true
+        cc = await fun(...inputs) //若發生錯誤則向外報錯
+        lock = false
+        return cc
+    }
+
+    //_getByCache, 提供取用快取版之非同步函數, 若有快取則優先使用, 若超過指定次數則執行get使能取得快取
+    let _getByCache = async(...inputs) => {
+        for (let i = 1; i <= nMax; i++) {
+
+            //exec
+            if (i > nTrigger && !lock) {
+                // console.log('執行get使能取得快取...')
+                await _get(...inputs)
+                    .catch(() => {}) //取得快取時不向外報錯
+            }
+
+            //check
+            if (cc !== null) {
+                break
+            }
+
+            //delay
+            await delay(1000) //偵測週期1000ms
+
+        }
+        if (cc === null) {
+            throw new Error(`exceeded nMax[${nMax}]`)
+        }
+        return cc
+    }
+
+    return {
+        get: _get,
+        getByCache: _getByCache,
+    }
+}
+
+
+export default cacheBd

package/src/index.mjs

@@ -55,6 +55,7 @@ export { default as bufReadDbl } from './bufReadDbl.mjs'
 export { default as bufWrite } from './bufWrite.mjs'
 export { default as bufWriteDbl } from './bufWriteDbl.mjs'
 export { default as cache } from './cache.mjs'
+export { default as cacheBd } from './cacheBd.mjs'
 export { default as cbol } from './cbol.mjs'
 export { default as cdbl } from './cdbl.mjs'
 export { default as ceil } from './ceil.mjs'

package/src/pmDebounce.mjs

@@ -114,47 +114,6 @@ import cint from './cint.mjs'
  */
 function pmDebounce(ms = 300) {
 
-    // function ClsDebounceEasy(ms) { //簡易法, 因執行階段中無法儲存推入任務會被視為強制取消, 不合需求
-
-    //     //timer
-    //     let t = null
-
-    //     //pm
-    //     let pm = Promise.resolve()
-
-    //     //run
-    //     let run = (func, ...input) => {
-
-    //         //clearTimeout
-    //         clearTimeout(t)
-
-    //         // console.log('call fun')
-    //         return new Promise((resolve, reject) => {
-    //             // console.log('call in Promise', ...input, ms)
-
-    //             //setTimeout
-    //             t = setTimeout(async () => {
-    //                 // console.log('exec fun start', ...input, ms)
-
-    //                 try {
-    //                     let res = func(...input)
-    //                     if (ispm(res)) {
-    //                         res = await pm
-    //                     }
-    //                     resolve(res)
-    //                 }
-    //                 catch (err) {
-    //                     reject(err)
-    //                 }
-    //                 // console.log('exec fun end')
-
-    //             }, ms)
-    //         })
-    //     }
-
-    //     return run
-    // }
-
     function ClsDebounce(ms) {
         let q = [] //queue
         let t = null //timer
@@ -167,12 +126,6 @@ function pmDebounce(ms = 300) {
         }
         ms = cint(ms)
 
-        // //_tNow
-        // let _tNow = Date.now()
-        // let getIt = () => {
-        //     return Date.now() - _tNow
-        // }
-
         function detect() {
 
             //check

package/src/pmMap.mjs

@@ -5,6 +5,7 @@ import genPm from './genPm.mjs'
 import isarr from './isarr.mjs'
 import isobj from './isobj.mjs'
 import isfun from './isfun.mjs'
+import ispm from './ispm.mjs'
 import queue from './queue.mjs'
 
 
@@ -20,7 +21,7 @@ import queue from './queue.mjs'
  * Unit Test: {@link https://github.com/yuda-lyu/wsemi/blob/master/test/pmMap.test.mjs Github}
  * @memberOf wsemi
  * @param {Array} rs 輸入資料陣列，若不給fn則rs需要為Promise陣列
- * @param {Function} fun 輸入循序執行值的呼叫函數
+ * @param {Function} fun 輸入循序執行值的呼叫async函數
  * @param {Integer} [takeLimit=0] 輸入同時處理數量整數，預設0，代表無限制
  * @returns {Promise} 回傳Promise，resolve回傳成功結果，reject回傳失敗結果
  * @example
@@ -405,6 +406,12 @@ function pmMap(rs, fun, takeLimit = 0) {
                 uv = v.value.v
             }
             pmm = fun(uv, uk)
+
+            //check
+            if (!ispm(pmm)) {
+                throw new Error(`return of fun is not a promise`)
+            }
+
         }
         else {
             pmm = v.value

package/src/pmThrottle.mjs

@@ -326,7 +326,7 @@ function pmThrottle() {
                 t = null
             }
 
-        }, 10) //10ms偵測, 啟動後跑timer, 無佇列則會停止減耗
+        }, 20) //20ms偵測, 啟動後跑timer, 無佇列則會停止減耗
     }
 
     function run(func, ...input) {

package/src/queue.mjs

@@ -4,7 +4,7 @@ import cint from './cint.mjs'
 
 
 /**
- * 佇列處理器，單生產者單消費者模式，核心使用迭代器，具有消息堵塞與可限定同時處理上限數量功能
+ * 佇列處理器，單生產者單消費者模式，具有消息堵塞與可限定同時處理上限數量功能
  *
  * Unit Test: {@link https://github.com/yuda-lyu/wsemi/blob/master/test/queue.test.mjs Github}
  * @memberOf wsemi