@chriscdn/memoize 1.0.1 → 1.0.2

package/lib/index.d.ts

@@ -5,14 +5,8 @@ type Options<T extends any[]> = {
 };
 /**
  * Memoize a synchronous function.
- *
- * @template {any[]} Args
- * @template {{}} Return
- * @param {(...args: Args) => Return} cb
- * @param {Partial<Options<Args>>} [options={}]
- * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}
  */
-declare const Memoize: <Args extends any[], Return extends {}>(cb: (...args: Args) => Return, options?: Partial<Options<Args>>) => (...args: Args) => Return;
+declare const Memoize: <Args extends unknown[], Return>(cb: (...args: Args) => Return, options?: Partial<Options<Args>>) => (...args: Args) => Return;
 /**
  * Memoize an asynchronous function.
  *
@@ -20,12 +14,6 @@ declare const Memoize: <Args extends any[], Return extends {}>(cb: (...args: Arg
  * same arguments is only evaluated once. This is controlled by using a
  * semaphore, which forces redundant calls to wait until the first call
  * completes.
- *
- * @template {any[]} Args
- * @template {{}} Return
- * @param {(...args: Args) => Promise<Return>} cb
- * @param {Partial<Options<Args>>} [options={}]
- * @returns {Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>}
  */
-declare const MemoizeAsync: <Args extends any[], Return extends {}>(cb: (...args: Args) => Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>;
+declare const MemoizeAsync: <Args extends unknown[], Return>(cb: (...args: Args) => Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>;
 export { Memoize, MemoizeAsync };

package/lib/memoize.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.cjs","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Return} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}\n */\nconst Memoize = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Promise<Return>} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>}\n */\nconst MemoizeAsync = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"wMAoBgB,SACZA,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAtBX,IAwBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,uBAgBqB,SACjBnB,EACAC,GACA,IAAAoB,EAAAC,OADkC,IAAlCrB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBiB,EAAGpB,EAAQG,SAAOiB,EAhEX,IAkEdhB,EAA2B,OAAnBiB,EAAGrB,EAAQI,UAAQiB,EAC5B,WAAA,OAAmBhB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCa,EAAY,IAAIC,EAAW,QAE3Bb,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDqB,IAA/BX,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BhB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbW,QAAAC,QACMJ,EAAUK,QAAQb,IAAIc,KAAA,WAAA,OAExBlB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAKW,QAAAC,QAEI3B,EAAEgB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBW,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQlB,GAAKgB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}
+{"version":3,"file":"memoize.cjs","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n */\nconst Memoize = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"wMAcgB,SACZA,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,uBAUqB,SACjBnB,EACAC,GACA,IAAAoB,EAAAC,OADkC,IAAlCrB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBiB,EAAGpB,EAAQG,SAAOiB,EApDX,IAsDdhB,EAA2B,OAAnBiB,EAAGrB,EAAQI,UAAQiB,EAC5B,WAAA,OAAmBhB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCa,EAAY,IAAIC,EAAW,QAE3Bb,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDqB,IAA/BX,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BhB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbW,QAAAC,QACMJ,EAAUK,QAAQb,IAAIc,KAAA,WAAA,OAExBlB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAKW,QAAAC,QAEI3B,EAAEgB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBW,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQlB,GAAKgB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}

package/lib/memoize.modern.js.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.modern.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Return} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}\n */\nconst Memoize = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Promise<Return>} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>}\n */\nconst MemoizeAsync = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$resolver","maxSize","resolver","args","JSON","stringify","cache","QuickLRU","maxAge","key","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$resolver2","semaphore","Semaphore","async","acquire","release"],"mappings":"oEAGA,MAiBMA,EAAUA,CACZC,EACAC,EAAkC,CAAA,KAClCC,IAAAA,EAAAC,EACA,MACMC,EAAyBF,OAAlBA,EAAGD,EAAQG,SAAOF,EAtBX,IAwBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,IAAIG,IAAeC,KAAKC,UAAUF,GAEjCG,EAAQ,IAAIC,EAAyB,CACvCC,OAP+BV,EAAQU,OAQvCP,YAGJ,MAAO,IAAIE,KACP,MAAMM,EAAMP,KAAYC,GAExB,GAAIG,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GACd,CACH,MAAMG,EAAcf,KAAMM,GAE1B,OADAG,EAAMO,IAAIJ,EAAKG,GACRA,CACV,EACL,EAiBEE,EAAeA,CACjBjB,EACAC,EAAkC,CAAE,KACpC,IAAAiB,EAAAC,EACA,MAAMR,EAA6BV,EAAQU,OACrCP,EAAyB,OAAlBc,EAAGjB,EAAQG,SAAOc,EAhEX,IAkEdb,EAA2B,OAAnBc,EAAGlB,EAAQI,UAAQc,EAC5B,IAAIb,IAAeC,KAAKC,UAAUF,GAEjCc,EAAY,IAAIC,EAEhBZ,EAAQ,IAAIC,EAAyB,CACvCC,SACAP,YAGJ,OAAOkB,SAAUhB,KACb,MAAMM,EAAMP,KAAYC,GAExB,GAAIG,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GAEjB,IAGI,SAFMQ,EAAUG,QAAQX,GAEpBH,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GACd,CACH,MAAMG,QAAoBf,KAAMM,GAEhC,OADAG,EAAMO,IAAIJ,EAAKG,GACRA,CACV,CACJ,CAAA,QACGK,EAAUI,QAAQZ,EACrB,CACJ,CACL"}
+{"version":3,"file":"memoize.modern.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n */\nconst Memoize = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$resolver","maxSize","resolver","args","JSON","stringify","cache","QuickLRU","maxAge","key","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$resolver2","semaphore","Semaphore","async","acquire","release"],"mappings":"oEAGA,MAWMA,EAAUA,CACZC,EACAC,EAAkC,CAAA,KAClCC,IAAAA,EAAAC,EACA,MACMC,EAAyBF,OAAlBA,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,IAAIG,IAAeC,KAAKC,UAAUF,GAEjCG,EAAQ,IAAIC,EAAyB,CACvCC,OAP+BV,EAAQU,OAQvCP,YAGJ,MAAO,IAAIE,KACP,MAAMM,EAAMP,KAAYC,GAExB,GAAIG,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GACd,CACH,MAAMG,EAAcf,KAAMM,GAE1B,OADAG,EAAMO,IAAIJ,EAAKG,GACRA,CACV,EACL,EAWEE,EAAeA,CACjBjB,EACAC,EAAkC,CAAE,KACpC,IAAAiB,EAAAC,EACA,MAAMR,EAA6BV,EAAQU,OACrCP,EAAyB,OAAlBc,EAAGjB,EAAQG,SAAOc,EApDX,IAsDdb,EAA2B,OAAnBc,EAAGlB,EAAQI,UAAQc,EAC5B,IAAIb,IAAeC,KAAKC,UAAUF,GAEjCc,EAAY,IAAIC,EAEhBZ,EAAQ,IAAIC,EAAyB,CACvCC,SACAP,YAGJ,OAAOkB,SAAUhB,KACb,MAAMM,EAAMP,KAAYC,GAExB,GAAIG,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GAEjB,IAGI,SAFMQ,EAAUG,QAAQX,GAEpBH,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GACd,CACH,MAAMG,QAAoBf,KAAMM,GAEhC,OADAG,EAAMO,IAAIJ,EAAKG,GACRA,CACV,CACJ,CAAA,QACGK,EAAUI,QAAQZ,EACrB,CACJ,CACL"}

package/lib/memoize.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.module.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Return} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}\n */\nconst Memoize = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Promise<Return>} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>}\n */\nconst MemoizeAsync = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"oEAGA,IAiBMA,EAAU,SACZC,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAtBX,IAwBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAyB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,EAgBME,EAAe,SACjBrB,EACAC,GACA,IAAAqB,EAAAC,OADkC,IAAlCtB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBkB,EAAGrB,EAAQG,SAAOkB,EAhEX,IAkEdjB,EAA2B,OAAnBkB,EAAGtB,EAAQI,UAAQkB,EAC5B,WAAA,OAAmBjB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCc,EAAY,IAAIC,EAEhBd,EAAQ,IAAIC,EAAyB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDsB,IAA/BZ,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAa,QAAAC,QAE1BjB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbY,QAAAC,QACMJ,EAAUK,QAAQd,IAAIe,KAAA,WAAA,OAExBnB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAKY,QAAAC,QAEI5B,EAAEgB,WAAIF,EAAAA,IAAKgB,KAAA,SAA/BX,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBY,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQnB,GAAKiB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}
+{"version":3,"file":"memoize.module.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n */\nconst Memoize = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"oEAGA,IAWMA,EAAU,SACZC,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAyB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,EAUME,EAAe,SACjBrB,EACAC,GACA,IAAAqB,EAAAC,OADkC,IAAlCtB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBkB,EAAGrB,EAAQG,SAAOkB,EApDX,IAsDdjB,EAA2B,OAAnBkB,EAAGtB,EAAQI,UAAQkB,EAC5B,WAAA,OAAmBjB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCc,EAAY,IAAIC,EAEhBd,EAAQ,IAAIC,EAAyB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDsB,IAA/BZ,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAa,QAAAC,QAE1BjB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbY,QAAAC,QACMJ,EAAUK,QAAQd,IAAIe,KAAA,WAAA,OAExBnB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAKY,QAAAC,QAEI5B,EAAEgB,WAAIF,EAAAA,IAAKgB,KAAA,SAA/BX,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBY,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQnB,GAAKiB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}

package/lib/memoize.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.umd.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Return} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}\n */\nconst Memoize = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Promise<Return>} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>}\n */\nconst MemoizeAsync = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"geAoBgB,SACZA,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAtBX,IAwBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,iBAgBqB,SACjBnB,EACAC,GACA,IAAAoB,EAAAC,OADkC,IAAlCrB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBiB,EAAGpB,EAAQG,SAAOiB,EAhEX,IAkEdhB,EAA2B,OAAnBiB,EAAGrB,EAAQI,UAAQiB,EAC5B,WAAA,OAAmBhB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCa,EAAY,IAAIC,EAAW,QAE3Bb,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDqB,IAA/BX,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BhB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbW,QAAAC,QACMJ,EAAUK,QAAQb,IAAIc,KAAA,WAAA,OAExBlB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAKW,QAAAC,QAEI3B,EAAEgB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBW,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQlB,GAAKgB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}
+{"version":3,"file":"memoize.umd.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n */\nconst Memoize = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"geAcgB,SACZA,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,iBAUqB,SACjBnB,EACAC,GACA,IAAAoB,EAAAC,OADkC,IAAlCrB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBiB,EAAGpB,EAAQG,SAAOiB,EApDX,IAsDdhB,EAA2B,OAAnBiB,EAAGrB,EAAQI,UAAQiB,EAC5B,WAAA,OAAmBhB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCa,EAAY,IAAIC,EAAW,QAE3Bb,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDqB,IAA/BX,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BhB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbW,QAAAC,QACMJ,EAAUK,QAAQb,IAAIc,KAAA,WAAA,OAExBlB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAKW,QAAAC,QAEI3B,EAAEgB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBW,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQlB,GAAKgB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chriscdn/memoize",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Memoize a synchronous or asynchronous function.",
   "repository": "https://github.com/chriscdn/memoize",
   "author": "Christopher Meyer <chris@schwiiz.org>",

package/src/index.ts

@@ -11,14 +11,8 @@ type Options<T extends any[]> = {
 
 /**
  * Memoize a synchronous function.
- *
- * @template {any[]} Args
- * @template {{}} Return
- * @param {(...args: Args) => Return} cb
- * @param {Partial<Options<Args>>} [options={}]
- * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}
  */
-const Memoize = <Args extends any[], Return extends {}>(
+const Memoize = <Args extends unknown[], Return>(
     cb: (...args: Args) => Return,
     options: Partial<Options<Args>> = {},
 ) => {
@@ -53,14 +47,8 @@ const Memoize = <Args extends any[], Return extends {}>(
  * same arguments is only evaluated once. This is controlled by using a
  * semaphore, which forces redundant calls to wait until the first call
  * completes.
- *
- * @template {any[]} Args
- * @template {{}} Return
- * @param {(...args: Args) => Promise<Return>} cb
- * @param {Partial<Options<Args>>} [options={}]
- * @returns {Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>}
  */
-const MemoizeAsync = <Args extends any[], Return extends {}>(
+const MemoizeAsync = <Args extends unknown[], Return>(
     cb: (...args: Args) => Promise<Return>,
     options: Partial<Options<Args>> = {},
 ) => {