@wener/utils 1.1.50 → 1.1.53

package/src/asyncs/createLazyPromise.test.ts

@@ -2,93 +2,93 @@ import { describe, expect, test } from 'vitest';
 import { createLazyPromise } from './createLazyPromise';
 
 describe('basic', async () => {
-  test('no executor', async () => {
-    const promise = createLazyPromise();
-    let r = 0;
-    void promise.then((v) => (r = v));
-    expect(r).toBe(0);
-    const { resolve, reject } = promise;
-    expect(resolve).toBeTruthy();
-    expect(reject).toBeTruthy();
+	test('no executor', async () => {
+		const promise = createLazyPromise();
+		let r = 0;
+		void promise.then((v) => (r = v));
+		expect(r).toBe(0);
+		const { resolve, reject } = promise;
+		expect(resolve).toBeTruthy();
+		expect(reject).toBeTruthy();
 
-    // peek
-    expect(promise.value).toBeUndefined();
-    expect(promise.status).toBe('pending');
-    resolve(1);
-    expect(promise.value).toBe(1);
-    expect(promise.status).toBe('resolved');
+		// peek
+		expect(promise.value).toBeUndefined();
+		expect(promise.status).toBe('pending');
+		resolve(1);
+		expect(promise.value).toBe(1);
+		expect(promise.status).toBe('resolved');
 
-    expect(r).toBe(0);
+		expect(r).toBe(0);
 
-    await promise;
+		await promise;
 
-    expect(r).toBe(1);
-  });
+		expect(r).toBe(1);
+	});
 
-  test('can resolve to lazy', async () => {
-    const a = createLazyPromise(() => {
-      return createLazyPromise(() => {
-        return 10;
-      });
-    });
+	test('can resolve to lazy', async () => {
+		const a = createLazyPromise(() => {
+			return createLazyPromise(() => {
+				return 10;
+			});
+		});
 
-    expect(a.value).toBeUndefined();
-    expect(a.status).toBe('pending');
-    expect(await a).toBe(10);
-    expect(a.status).toBe('resolved');
-    expect(a.value).toBe(10);
-  });
+		expect(a.value).toBeUndefined();
+		expect(a.status).toBe('pending');
+		expect(await a).toBe(10);
+		expect(a.status).toBe('resolved');
+		expect(a.value).toBe(10);
+	});
 
-  test('can resolve to async lazy', async () => {
-    const a = createLazyPromise(async () => {
-      return createLazyPromise(async () => {
-        return 10;
-      });
-    });
-    expect(a.value).toBeUndefined();
-    expect(a.status).toBe('pending');
-    expect(await a).toBe(10);
-    expect(a.status).toBe('resolved');
-    expect(a.value).toBe(10);
-  });
+	test('can resolve to async lazy', async () => {
+		const a = createLazyPromise(async () => {
+			return createLazyPromise(async () => {
+				return 10;
+			});
+		});
+		expect(a.value).toBeUndefined();
+		expect(a.status).toBe('pending');
+		expect(await a).toBe(10);
+		expect(a.status).toBe('resolved');
+		expect(a.value).toBe(10);
+	});
 });
 
 test('manual resolve skip exec', async () => {
-  const promise = createLazyPromise<number>(() => {
-    expect.fail('should not exec');
-  });
-  promise.resolve(-1);
-  expect(await promise).toBe(-1);
-  expect(String(promise)).toBe('[object LazyPromise]');
+	const promise = createLazyPromise<number>(() => {
+		expect.fail('should not exec');
+	});
+	promise.resolve(-1);
+	expect(await promise).toBe(-1);
+	expect(String(promise)).toBe('[object LazyPromise]');
 });
 
 test('lazy exec resolve by manual', async () => {
-  let r = 0;
-  const promise = createLazyPromise((resolve) => {
-    r++;
-    resolve(10);
-  });
-  await Promise.resolve();
-  expect(r).toBe(0);
-  expect(await promise).toBe(10);
-  expect(r).toBe(1);
-  promise.resolve(20);
-  expect(await promise).toBe(10);
-  expect(r).toBe(1);
+	let r = 0;
+	const promise = createLazyPromise((resolve) => {
+		r++;
+		resolve(10);
+	});
+	await Promise.resolve();
+	expect(r).toBe(0);
+	expect(await promise).toBe(10);
+	expect(r).toBe(1);
+	promise.resolve(20);
+	expect(await promise).toBe(10);
+	expect(r).toBe(1);
 });
 
 test('lazy exec resolve by return', async () => {
-  let r = 0;
-  const promise = createLazyPromise(() => {
-    r++;
-    return 10;
-  });
-  await Promise.resolve();
-  expect(r).toBe(0);
-  void promise.then(() => undefined);
-  await Promise.resolve();
-  // already resolved
-  expect(r).toBe(1);
-  expect(await promise).toBe(10);
-  expect(r).toBe(1);
+	let r = 0;
+	const promise = createLazyPromise(() => {
+		r++;
+		return 10;
+	});
+	await Promise.resolve();
+	expect(r).toBe(0);
+	void promise.then(() => undefined);
+	await Promise.resolve();
+	// already resolved
+	expect(r).toBe(1);
+	expect(await promise).toBe(10);
+	expect(r).toBe(1);
 });

package/src/asyncs/createLazyPromise.ts

@@ -3,11 +3,11 @@ import type { MaybePromise } from './MaybePromise';
 import { Promises } from './Promises';
 
 export type LazyPromise<T> = Promise<T> & {
-  reject(reason?: any): void;
-  resolve(v?: MaybePromise<T>): void;
-  readonly status: 'pending' | 'resolved' | 'rejected';
-  readonly value: T | undefined;
-  readonly error: any;
+	reject(reason?: any): void;
+	resolve(v?: MaybePromise<T>): void;
+	readonly status: 'pending' | 'resolved' | 'rejected';
+	readonly value: T | undefined;
+	readonly error: any;
 };
 
 /**
@@ -15,78 +15,73 @@ export type LazyPromise<T> = Promise<T> & {
  * if you pass a function to it, it will be executed when the promise try to resolve.
  */
 export function createLazyPromise<T = any>(
-  executor?: (resolve: LazyPromise<T>['resolve'], reject: LazyPromise<T>['reject']) => MaybePromise<T> | void,
+	executor?: (resolve: LazyPromise<T>['resolve'], reject: LazyPromise<T>['reject']) => MaybePromise<T> | void,
 ): LazyPromise<T> {
-  const { promise, resolve, reject } = Promises.withResolvers();
-  const lazy = Object.assign(promise, {
-    resolve,
-    reject,
-  }) as LazyPromise<T>;
+	const { promise, resolve, reject } = Promises.withResolvers();
+	const lazy = Object.assign(promise, { resolve, reject }) as LazyPromise<T>;
 
-  let executed = false;
-  let pending = true;
-  let status: 'pending' | 'resolved' | 'rejected' = 'pending';
-  let value: T | undefined;
-  let error: any;
+	let executed = false;
+	let pending = true;
+	let status: 'pending' | 'resolved' | 'rejected' = 'pending';
+	let value: T | undefined;
+	let error: any;
 
-  const _resolve = (v: T) => {
-    resolve(v);
-    if (!pending) return;
-    pending = false;
-    // do not delay this for sync status peek
-    status = 'resolved';
-    value = v;
-  };
-  const _reject = (v: any) => {
-    reject(v);
-    if (!pending) return;
-    pending = false;
-    status = 'rejected';
-    error = v;
-  };
+	const _resolve = (v: T) => {
+		resolve(v);
+		if (!pending) return;
+		pending = false;
+		// do not delay this for sync status peek
+		status = 'resolved';
+		value = v;
+	};
+	const _reject = (v: any) => {
+		reject(v);
+		if (!pending) return;
+		pending = false;
+		status = 'rejected';
+		error = v;
+	};
 
-  const like = Object.assign(
-    {
-      get status() {
-        return status;
-      },
-      get value() {
-        return value;
-      },
-      get error() {
-        return error;
-      },
-    },
-    {
-      cache: lazy.catch.bind(lazy),
-      finally: lazy.finally?.bind(lazy),
-      resolve: _resolve,
-      reject: _reject,
-      then: (...args: any[]) => {
-        if (executor && !executed) {
-          executed = true;
-          try {
-            const result = executor(_resolve, _reject);
-            // ensure resolve/reject is called
-            if (isPromise(result)) {
-              result.then(_resolve, _reject);
-            } else if (result !== undefined) {
-              _resolve(result);
-            }
-          } catch (e) {
-            _reject(e);
-          }
-        }
-        return lazy.then(...args);
-      },
-    },
-  ) as any as LazyPromise<T>;
+	const like = Object.assign(
+		{
+			get status() {
+				return status;
+			},
+			get value() {
+				return value;
+			},
+			get error() {
+				return error;
+			},
+		},
+		{
+			cache: lazy.catch.bind(lazy),
+			finally: lazy.finally?.bind(lazy),
+			resolve: _resolve,
+			reject: _reject,
+			then: (...args: any[]) => {
+				if (executor && !executed) {
+					executed = true;
+					try {
+						const result = executor(_resolve, _reject);
+						// ensure resolve/reject is called
+						if (isPromise(result)) {
+							result.then(_resolve, _reject);
+						} else if (result !== undefined) {
+							_resolve(result);
+						}
+					} catch (e) {
+						_reject(e);
+					}
+				}
+				return lazy.then(...args);
+			},
+		},
+	) as any as LazyPromise<T>;
 
-  if ('toStringTag' in Symbol) {
-    Object.defineProperty(like, Symbol.toStringTag, {
-      value: 'LazyPromise',
-    });
-  }
+	if ('toStringTag' in Symbol) {
+		Object.defineProperty(like, Symbol.toStringTag, { value: 'LazyPromise' });
+	}
 
-  return like;
+	return like;
 }

package/src/asyncs/firstOfAsyncIterator.ts

@@ -3,9 +3,9 @@ import type { MaybePromise } from './MaybePromise';
 import { nextOfAsyncIterator } from './nextOfAsyncIterator';
 
 export function firstOfAsyncIterator<T>(it: MaybePromise<AsyncIterator<T> | Iterator<T> | T>): MaybePromise<T> {
-  const next = nextOfAsyncIterator(it);
-  if (isPromise(next)) {
-    return next.then((v) => v[0]);
-  }
-  return next[0];
+	const next = nextOfAsyncIterator(it);
+	if (isPromise(next)) {
+		return next.then((v) => v[0]);
+	}
+	return next[0];
 }

package/src/asyncs/generatorOfStream.ts

@@ -1,14 +1,14 @@
 export function* generatorOfStream<T = any>(stream: any): IterableIterator<Promise<T>> {
-  let done = false;
-  stream.on('end', () => {
-    done = true;
-  });
-  // eslint-disable-next-line no-unmodified-loop-condition
-  while (!done) {
-    yield new Promise((resolve, reject) => {
-      stream.once('data', resolve);
-      stream.once('end', resolve);
-      stream.once('error', reject);
-    });
-  }
+	let done = false;
+	stream.on('end', () => {
+		done = true;
+	});
+	// eslint-disable-next-line no-unmodified-loop-condition
+	while (!done) {
+		yield new Promise((resolve, reject) => {
+			stream.once('data', resolve);
+			stream.once('end', resolve);
+			stream.once('error', reject);
+		});
+	}
 }

package/src/asyncs/isIterator.ts

@@ -1,3 +1,3 @@
 export function isIterator<T>(it: any): it is Iterator<T> | AsyncIterator<T> {
-  return typeof it?.next === 'function';
+	return typeof it?.next === 'function';
 }

package/src/asyncs/isThenable.ts

@@ -1,4 +1,4 @@
 export function isThenable(v: any): v is PromiseLike<any> {
-  // we are at Promise era now, so we can use Promise instead of PromiseLike
-  return v && typeof v.then === 'function';
+	// we are at Promise era now, so we can use Promise instead of PromiseLike
+	return v && typeof v.then === 'function';
 }

package/src/asyncs/nextOfAsyncIterator.ts

@@ -6,26 +6,26 @@ type IteratorLike<T> = Iterable<T> | Iterator<T>;
 type AsyncIteratorLike<T> = AsyncIterable<T> | AsyncIterator<T> | AsyncIterableIterator<T> | IteratorLike<T>;
 
 export function nextOfAsyncIterator<T>(
-  it: MaybePromise<AsyncIterable<T> | Iterable<T> | AsyncIterator<T> | Iterator<T> | T>,
+	it: MaybePromise<AsyncIterable<T> | Iterable<T> | AsyncIterator<T> | Iterator<T> | T>,
 ): MaybePromise<[value: T, done?: boolean]> {
-  if (isPromise(it)) {
-    return it.then((v) => nextOfAsyncIterator(v));
-  }
+	if (isPromise(it)) {
+		return it.then((v) => nextOfAsyncIterator(v));
+	}
 
-  if (isIterator(it)) {
-    let next = it.next();
-    if (isPromise(next)) {
-      return next.then((v) => [v.value, v.done]);
-    }
-    return [next.value, next.done];
-  }
-  if (it && typeof it === 'object') {
-    if (Symbol.iterator in it) {
-      return nextOfAsyncIterator(it[Symbol.iterator]());
-    }
-    if (Symbol.asyncIterator in it) {
-      return nextOfAsyncIterator(it[Symbol.asyncIterator]());
-    }
-  }
-  return [it];
+	if (isIterator(it)) {
+		let next = it.next();
+		if (isPromise(next)) {
+			return next.then((v) => [v.value, v.done]);
+		}
+		return [next.value, next.done];
+	}
+	if (it && typeof it === 'object') {
+		if (Symbol.iterator in it) {
+			return nextOfAsyncIterator(it[Symbol.iterator]());
+		}
+		if (Symbol.asyncIterator in it) {
+			return nextOfAsyncIterator(it[Symbol.asyncIterator]());
+		}
+	}
+	return [it];
 }

package/src/asyncs/promiseOfCallback.ts

@@ -1,15 +1,15 @@
 export function promiseOfCallback<T>(fun: (cb: (err: any, val?: T) => void) => void) {
-  return new Promise<T>((resolve, reject) => {
-    try {
-      fun((e: any, v: any) => {
-        if (e) {
-          reject(e);
-        } else {
-          resolve(v);
-        }
-      });
-    } catch (e) {
-      reject(e);
-    }
-  });
+	return new Promise<T>((resolve, reject) => {
+		try {
+			fun((e: any, v: any) => {
+				if (e) {
+					reject(e);
+				} else {
+					resolve(v);
+				}
+			});
+		} catch (e) {
+			reject(e);
+		}
+	});
 }

package/src/asyncs/timeout.ts

@@ -1,30 +1,30 @@
 export function timeout<T = any>(
-  pending: Promise<T> | ((args: { signal: AbortSignal }) => Promise<T>),
-  ms: number,
+	pending: Promise<T> | ((args: { signal: AbortSignal }) => Promise<T>),
+	ms: number,
 ): Promise<T> {
-  const error = new TimeoutError();
-  let timeout: any;
-  let ac: AbortController | undefined;
-  if (typeof pending === 'function') {
-    ac = new AbortController();
-    pending = pending({ signal: ac.signal });
-  }
+	const error = new TimeoutError();
+	let timeout: any;
+	let ac: AbortController | undefined;
+	if (typeof pending === 'function') {
+		ac = new AbortController();
+		pending = pending({ signal: ac.signal });
+	}
 
-  return Promise.race<T>([
-    pending,
-    new Promise((_resolve, reject) => {
-      timeout = setTimeout(() => {
-        ac?.abort(error);
-        reject(error);
-      }, ms);
-    }),
-  ]).finally(() => {
-    clearTimeout(timeout);
-  });
+	return Promise.race<T>([
+		pending,
+		new Promise((_resolve, reject) => {
+			timeout = setTimeout(() => {
+				ac?.abort(error);
+				reject(error);
+			}, ms);
+		}),
+	]).finally(() => {
+		clearTimeout(timeout);
+	});
 }
 
 export class TimeoutError extends Error {
-  constructor() {
-    super('TimeoutError');
-  }
+	constructor() {
+		super('TimeoutError');
+	}
 }

package/src/browsers/copy.ts

@@ -4,47 +4,47 @@ let _copy: (s: any) => MaybePromise<void>;
 
 // https://gist.github.com/rproenca/64781c6a1329b48a455b645d361a9aa3
 function initCopy() {
-  let textArea: HTMLTextAreaElement;
-
-  function isIOS() {
-    return navigator.userAgent.match(/ipad|iphone/i);
-  }
-
-  function createTextArea(text: string) {
-    textArea = document.createElement('textArea') as HTMLTextAreaElement;
-    textArea.value = text;
-    document.body.appendChild(textArea);
-  }
-
-  function selectText() {
-    let range, selection;
-
-    if (isIOS()) {
-      range = document.createRange();
-      range.selectNodeContents(textArea);
-      selection = window.getSelection();
-      if (selection === null) {
-        console.error(`no selection`);
-        return;
-      }
-      selection.removeAllRanges();
-      selection.addRange(range);
-      textArea.setSelectionRange(0, 999999);
-    } else {
-      textArea.select();
-    }
-  }
-
-  function copyToClipboard() {
-    document.execCommand('copy');
-    document.body.removeChild(textArea);
-  }
-
-  _copy = (text) => {
-    createTextArea(text);
-    selectText();
-    copyToClipboard();
-  };
+	let textArea: HTMLTextAreaElement;
+
+	function isIOS() {
+		return navigator.userAgent.match(/ipad|iphone/i);
+	}
+
+	function createTextArea(text: string) {
+		textArea = document.createElement('textArea') as HTMLTextAreaElement;
+		textArea.value = text;
+		document.body.appendChild(textArea);
+	}
+
+	function selectText() {
+		let range, selection;
+
+		if (isIOS()) {
+			range = document.createRange();
+			range.selectNodeContents(textArea);
+			selection = window.getSelection();
+			if (selection === null) {
+				console.error(`no selection`);
+				return;
+			}
+			selection.removeAllRanges();
+			selection.addRange(range);
+			textArea.setSelectionRange(0, 999999);
+		} else {
+			textArea.select();
+		}
+	}
+
+	function copyToClipboard() {
+		document.execCommand('copy');
+		document.body.removeChild(textArea);
+	}
+
+	_copy = (text) => {
+		createTextArea(text);
+		selectText();
+		copyToClipboard();
+	};
 }
 
 /**
@@ -52,11 +52,11 @@ function initCopy() {
  * @param content content
  */
 export function copy(content: string): MaybePromise<void> {
-  if (window.navigator?.clipboard?.writeText) {
-    return window.navigator.clipboard.writeText(content);
-  }
-  if (!_copy) {
-    initCopy();
-  }
-  return _copy(content);
+	if (window.navigator?.clipboard?.writeText) {
+		return window.navigator.clipboard.writeText(content);
+	}
+	if (!_copy) {
+		initCopy();
+	}
+	return _copy(content);
 }