implab/implabjs-core Commit - r159:130129fdbd20

Added safe.debounce function, this is a preview version

cin -

r159:130129fdbd20 default

parent child

Context file:

r159:130129fdbd20

Collapse all files

package-lock.json +3 -3

                    }
                  },
                  "typescript": {
-                   "version": "3.6.4",
-                   "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.6.4.tgz",
-                   "integrity": "sha512-unoCll1+l+YK4i4F8f22TaNVPRHcD9PA3yCuZ8g5e0qGqlVlJ/8FSateOLLSagn+Yg5+ZwuPkL8LFUc0Jcvksg==",
+                   "version": "4.1.5",
+                   "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.1.5.tgz",
+                   "integrity": "sha512-6OSu9PTIzmn9TCDiovULTnET6BgXtDYL4Gg4szY+cGsc3JP1dQL8qvE8kShTRx1NIw4Q9IBHlwODjkjWEtMUyA==",
                    "dev": true
                  },
                  "uri-js": {

package.json +1 -1

                  "dojo-typings": "^1.11.9",
                  "requirejs": "latest",
                  "tape": "~4.11.0",
-                 "typescript": "~3.6.4",
+                 "typescript": "~4.1.5",
                  "eslint": "6.1.0",
                  "tslint": "5.18.0"
                }

src/main/ts/safe.ts +55 -1

                  Symbol("__implab__oid__") :
                  "__implab__oid__";
+             function _noop() { }
              export function oid(instance: null | undefined): undefined;
              export function oid(instance: NonNullable<any>): string;
              export function oid(instance: any): string | undefined {
                  };
              }
+             /** Returns promise which will be resolved after the specified amount of time.
+              *
+              * @param timeMs The delay before the promise will be resolved in milliseconds.
+              * @param ct Optional. A cancellation token for the operation.
+              */
              export function delay(timeMs: number, ct = cancellationNone) {
                  ct.throwIfRequested();
-                 return new Promise((resolve, reject) => {
+                 return new Promise<void>((resolve, reject) => {
                      const h = ct.register(e => {
                          clearTimeout(id);
                          reject(e);
                  });
              }
+             export function debounce<T extends any[], R, This>(func: (this: This, ...args: T) => R | PromiseLike<R>, wait: number) {
+                 let cancel: (e?: any) => void = _noop;
+                 const fn = function executedFunction(this: This, ...args: T) {
+                     return new Promise<R>((resolve, reject) => {
+                         // used to cleanup currently allocated resources
+                         const _cleanup = () => {
+                             cancel = _noop;
+                             clearTimeout(handle);
+                         };
+                         // used in case of cancellation of the current operation
+                         const _cancel = (e: any) => {
+                             _cleanup();
+                             reject(e);
+                         };
+                         // performs actual work
+                         const _later = () => {
+                             _cleanup();
+                             resolve(func.apply(this, args));
+                         };
+                         // cancel previously queued operation
+                         if (cancel !== _noop)
+                             cancel(new Error("Operation cancelled due to debouncing"));
+                         cancel = _cancel;
+                         const handle = setTimeout(_later, wait);
+                     });
+                 };
+                 fn.cancel = (e?: any) => cancel(e);
+                 fn.applyAsync = async (thisArg: This, args: T, ct: ICancellation) => {
+                     const h = ct.register(cancel);
+                     try {
+                         await fn.apply(thisArg, args);
+                     } finally {
+                         h.destroy();
+                     }
+                 };
+                 return fn;
+             }
              /** Returns resolved promise, awaiting this method will cause the asynchronous
               * completion of the rest of the code.
               */

src/test/ts/tests/SafeTests.ts +62 -1

		@@ -1,5 +1,6
1	1	import { Cancellation } from "../Cancellation";
2		import { first, isPromise, firstWhere, delay, nowait, notImplemented } from "../safe";
	2	import { ICancellation } from "../interfaces";
	3	import { first, isPromise, firstWhere, delay, nowait, notImplemented, debounce, fork } from "../safe";
3	4	import { test } from "./TestTraits";
4	5
5	6	test("await delay test", async t => {
		@@ -93,3 +94,63 test("sequemce test", async t => {
93	94	v = await new Promise(resolve => first(asyncSequence, resolve));
94	95	t.equal(v, "a", "The callback should be called for the first element");
95	96	});
	97
	98	test("debounce tests", async (t, trace) => {
	99	let count = 0;
	100	let rejected = 0;
	101	function increment(step: number = 1) {
	102	count += step;
	103	return count;
	104	}
	105
	106	const f = debounce(increment, 100);
	107	f().then(undefined, () => rejected++);
	108	f().then(undefined, () => rejected++);
	109
	110	await f(1);
	111
	112	t.equal(rejected, 2, "Previous operations should be rejected");
	113	t.equal(count, 1, "The operation should run once");
	114
	115	const acc = debounce(
	116	(...values: number[]) => count = values.reduce((a, v) => v + a, count),
	117	100
	118	);
	119
	120	acc(1, 2, 3).catch(() => { });
	121	const result = acc(1, 2, 3);
	122	acc.cancel();
	123
	124	try {
	125	await result;
	126	t.notOk("fn.cancel() should make current operation to throw an exception");
	127	} catch {
	128	t.ok("fn.cancel() should make current operation to throw an exception");
	129	}
	130
	131	t.equal(count, 1, "fn.cancel() The operation should not run");
	132
	133	acc.cancel();
	134	await acc(1, 2);
	135	t.equal(count, 4, "The variable arguments list shoud be handled correctly");
	136
	137	// create cancellation token
	138	let cancel: (e?: any) => void = notImplemented;
	139	const ct = new Cancellation(c => cancel = c);
	140
	141	const d = debounce(async (ct2: ICancellation = Cancellation.none) => {
	142	ct2.throwIfRequested();
	143	trace.debug("do async increment");
	144	await fork();
	145	count++;
	146	return count;
	147	}, 0);
	148
	149	const p = d.applyAsync(null, [ct], ct).then(undefined, () => rejected++);
	150	cancel();
	151	await p;
	152
	153	t.equal(count, 4, "Cancellation token should prevent the function execution");
	154	t.equal(rejected, 3, "Cancellation token should reject operation");
	155
	156	});

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages