@powfix/core-js 0.24.1 → 0.24.3

package/dist/shared/features/DedupedTaskManager.cjs

@@ -0,0 +1,63 @@
+'use strict';
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+var chunkJE77HYXB_cjs = require('../../chunk-JE77HYXB.cjs');
+var _tasks;
+var DedupedTaskManager = /*#__PURE__*/ function() {
+    function DedupedTaskManager() {
+        _class_call_check(this, DedupedTaskManager);
+        chunkJE77HYXB_cjs.__privateAdd(this, _tasks, /* @__PURE__ */ new Map());
+    }
+    _create_class(DedupedTaskManager, [
+        {
+            key: "run",
+            value: function run(key, factory, options) {
+                var _this = this;
+                if (chunkJE77HYXB_cjs.__privateGet(this, _tasks).has(key)) {
+                    var task2 = chunkJE77HYXB_cjs.__privateGet(this, _tasks).get(key);
+                    if (task2 != null) {
+                        return task2;
+                    }
+                }
+                var task = factory().finally(function() {
+                    var ttl = options === null || options === void 0 ? void 0 : options.ttl;
+                    if (ttl) {
+                        setTimeout(function() {
+                            chunkJE77HYXB_cjs.__privateGet(_this, _tasks).delete(key);
+                        }, ttl);
+                    } else {
+                        chunkJE77HYXB_cjs.__privateGet(_this, _tasks).delete(key);
+                    }
+                });
+                chunkJE77HYXB_cjs.__privateGet(this, _tasks).set(key, task);
+                return task;
+            }
+        },
+        {
+            key: "tasks",
+            get: function get() {
+                return chunkJE77HYXB_cjs.__privateGet(this, _tasks);
+            }
+        }
+    ]);
+    return DedupedTaskManager;
+}();
+_tasks = new WeakMap();
+exports.DedupedTaskManager = DedupedTaskManager;

package/dist/shared/features/DedupedTaskManager.d.ts

@@ -0,0 +1,6 @@
+import type { DedupedTaskManagerRunOptions as RunOptions, DedupedTaskManagerTaskKey as TaskKey } from "./DedupedTaskManager.types.js";
+export declare class DedupedTaskManager {
+    #private;
+    run<T>(key: TaskKey, factory: () => Promise<T>, options?: RunOptions): Promise<T>;
+    get tasks(): Map<TaskKey, Promise<any>>;
+}

package/dist/shared/features/DedupedTaskManager.js

@@ -0,0 +1,63 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+import { __privateAdd, __privateGet } from '../../chunk-AQ5VUG5P.js';
+var _tasks;
+var DedupedTaskManager = /*#__PURE__*/ function() {
+    "use strict";
+    function DedupedTaskManager() {
+        _class_call_check(this, DedupedTaskManager);
+        __privateAdd(this, _tasks, /* @__PURE__ */ new Map());
+    }
+    _create_class(DedupedTaskManager, [
+        {
+            key: "run",
+            value: function run(key, factory, options) {
+                var _this = this;
+                if (__privateGet(this, _tasks).has(key)) {
+                    var task2 = __privateGet(this, _tasks).get(key);
+                    if (task2 != null) {
+                        return task2;
+                    }
+                }
+                var task = factory().finally(function() {
+                    var ttl = options === null || options === void 0 ? void 0 : options.ttl;
+                    if (ttl) {
+                        setTimeout(function() {
+                            __privateGet(_this, _tasks).delete(key);
+                        }, ttl);
+                    } else {
+                        __privateGet(_this, _tasks).delete(key);
+                    }
+                });
+                __privateGet(this, _tasks).set(key, task);
+                return task;
+            }
+        },
+        {
+            key: "tasks",
+            get: function get() {
+                return __privateGet(this, _tasks);
+            }
+        }
+    ]);
+    return DedupedTaskManager;
+}();
+_tasks = new WeakMap();
+export { DedupedTaskManager };

package/dist/shared/features/DedupedTaskManager.types.cjs

@@ -0,0 +1 @@
+'use strict';

package/dist/shared/features/DedupedTaskManager.types.d.ts

@@ -0,0 +1,4 @@
+export type DedupedTaskManagerTaskKey = number | string | symbol;
+export type DedupedTaskManagerRunOptions = {
+    ttl?: number;
+};

package/dist/shared/features/WatchablePromise.d.ts

@@ -1,8 +1,8 @@
-import type { WatchablePromiseStatus } from "./WatchablePromise.types.js";
+import type { PromiseExecutor, WatchablePromiseStatus } from "./WatchablePromise.types.js";
 export declare class WatchablePromise<T, E = Error> extends Promise<T> {
     #private;
     static from<P extends typeof WatchablePromise, T>(this: P, promise: Promise<T>): InstanceType<P>;
-    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void);
+    constructor(executor: PromiseExecutor<T>);
     get settled(): boolean;
     get status(): WatchablePromiseStatus;
     get result(): T | PromiseLike<T> | E | undefined;

package/dist/shared/features/WatchablePromise.types.d.ts

@@ -1 +1,2 @@
+export type PromiseExecutor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void;
 export type WatchablePromiseStatus = 'pending' | 'fulfilled' | 'rejected';

package/dist/shared/features/index.cjs

@@ -1,5 +1,14 @@
 'use strict';
+var DedupedTaskManager = require('./DedupedTaskManager');
 var WatchablePromise = require('./WatchablePromise');
+Object.keys(DedupedTaskManager).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return DedupedTaskManager[k];
+        }
+    });
+});
 Object.keys(WatchablePromise).forEach(function(k) {
     if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
         enumerable: true,

package/dist/shared/features/index.d.ts

@@ -1,2 +1,4 @@
+export * from "./DedupedTaskManager.js";
+export type * from "./DedupedTaskManager.types.js";
 export * from "./WatchablePromise.js";
 export type * from "./WatchablePromise.types.js";

package/dist/shared/features/index.js

@@ -1 +1,2 @@
+export * from './DedupedTaskManager.js';
 export * from './WatchablePromise.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powfix/core-js",
-  "version": "0.24.1",
+  "version": "0.24.3",
   "description": "core package",
   "author": "Kwon Kyung-Min <powfix@gmail.com>",
   "private": false,