ctx-core 5.8.0 → 5.10.0

package/all/be_lock_memosig_triple/index.js

@@ -6,7 +6,7 @@ import { be_ } from '../be_/index.js'
 import { lock_memosig_ } from '../rmemo/index.js'
 /**
  * @param {Be<sig_T>|be__val__new_T<unknown>}be_OR_val__new
- * @param {rmemo_subscriber_T[]|[...rmemo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
+ * @param {memo_subscriber_T[]|[...memo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
  * @returns {be_lock_memosig_triple_T}
  * @private
  */

package/all/be_memo_pair/index.js

@@ -5,7 +5,7 @@ import { be_ } from '../be_/index.js'
 import { memo_ } from '../rmemo/index.js'
 /**
  * @param {Be|be__val__new_T<unknown>}be_OR_val__new
- * @param {rmemo_subscriber_T[]|[...rmemo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
+ * @param {memo_subscriber_T[]|[...memo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
  * @returns {be_memo_pair_T}
  * @private
  */

package/all/be_sig_triple/index.js

@@ -5,7 +5,7 @@ import { be_ } from '../be_/index.js'
 import { sig_ } from '../rmemo/index.js'
 /**
  * @param {Be<sig_T>|be__val__new_T<unknown>}be_OR_val__new
- * @param {rmemo_subscriber_T[]|[...rmemo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
+ * @param {memo_subscriber_T[]|[...memo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
  * @returns {be_sig_triple_T}
  * @private
  */

package/all/cancel/index.d.ts

@@ -0,0 +1,8 @@
+export declare class Cancel<R = unknown> extends Error {
+	constructor(config?:Cancel_config_T<R>)
+	returns:R
+}
+export type Cancel_config_T<R = unknown> = {
+	message?:string
+	returns?:R
+}

package/all/cancel/index.js

@@ -0,0 +1,6 @@
+export class Cancel extends Error {
+	constructor(config) {
+		super(config?.message ?? 'Cancel')
+		this.returns = config?.returns
+	}
+}

package/all/cancel/index.test.ts

@@ -0,0 +1,9 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { Cancel } from './index.js'
+test('Cancel', ()=>{
+	equal(new Cancel().message, 'Cancel')
+	equal(new Cancel({ message: 'custom message' }).message, 'custom message')
+	equal(new Cancel({ returns: 1 }).returns, 1)
+})
+test.run()

package/all/file_exists/index.d.ts

@@ -1,3 +1,4 @@
+import type { waitfor_Promise } from '../waitfor/index.js'
 export declare function file_exists_(path:string):Promise<boolean|undefined>
 export {
 	file_exists_ as path__exists_
@@ -5,5 +6,5 @@ export {
 export declare function file_exists__waitfor(
 	path:string,
 	timeout?:number,
-	period?:number
-):Promise<void>
+	period?:number|((promise:waitfor_Promise<boolean>)=>Promise<number>)
+):waitfor_Promise<boolean>

package/all/file_exists/index.js

@@ -19,9 +19,16 @@ export {
 /**
  * @param {string}path
  * @param {number}[timeout]
- * @param {number}[period]
- * @returns {Promise<void>}
+ * @param {number|((promise:waitfor_Promise<boolean>)=>Promise<number>)}[period]
+ * @returns {Promise<boolean>}
  */
-export function file_exists__waitfor(path, timeout = 5000, period = 0) {
-	return waitfor(()=>file_exists_(path), timeout, period)
+export function file_exists__waitfor(
+	path,
+	timeout,
+	period
+) {
+	return waitfor(()=>
+		file_exists_(path),
+	timeout ?? 5000,
+	period ?? 0)
 }

package/all/file_exists/index.test.ts

@@ -3,18 +3,35 @@ import { unlink, writeFile } from 'fs/promises'
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { tempfile_path_ } from '../tempfile_path/index.js'
+import { waitfor_Promise } from '../waitfor/index.js'
 import { file_exists_, file_exists__waitfor } from './index.js'
 test('file_exists_ + file_exists__waitfor|server', async ()=>{
 	const tempfile_path = await tempfile_path_()
 	equal(await file_exists_(tempfile_path), false)
 	await writeFile(tempfile_path, 'test content')
 	try {
-		await file_exists__waitfor(tempfile_path)
+		equal(await file_exists__waitfor(tempfile_path), true)
 		equal(await file_exists_(tempfile_path), true)
 	} finally {
 		await unlink(tempfile_path)
 	}
 })
+test('file_exists__waitfor|server|cancel', async ()=>{
+	const tempfile_path = await tempfile_path_()
+	equal(await file_exists_(tempfile_path), false)
+	const promise= file_exists__waitfor(tempfile_path)
+	let rv:boolean|undefined = undefined
+	promise.then(_rv=>rv = _rv)
+	equal(rv, undefined)
+	equal(await promise.cancel(), false)
+	equal(await promise, false)
+	rv = undefined
+	const arg_promise= file_exists__waitfor(tempfile_path)
+	promise.then(_rv=>rv = _rv)
+	equal(rv, undefined)
+	equal(await arg_promise.cancel(true), true)
+	equal(await arg_promise, true)
+})
 test('file_exists_ + file_exists__waitfor|browser', async ()=>{
 	const { file_exists_, file_exists__waitfor } = await esmock('./index.js', {}, {
 		'../process_release_name/index.js': {

package/all/index.d.ts

@@ -70,6 +70,7 @@ export * from './call/index.js'
 export * from './call_assign/index.js'
 export * from './call_fn_a/index.js'
 export * from './call_or_fn/index.js'
+export * from './cancel/index.js'
 export * from './chain/index.js'
 export * from './chunk_aa/index.js'
 export * from './circular_idx/index.js'

package/all/index.js

@@ -70,6 +70,7 @@ export * from './call/index.js'
 export * from './call_assign/index.js'
 export * from './call_fn_a/index.js'
 export * from './call_or_fn/index.js'
+export * from './cancel/index.js'
 export * from './chain/index.js'
 export * from './chunk_aa/index.js'
 export * from './circular_idx/index.js'

package/all/promise/index.d.ts

@@ -1,2 +1,11 @@
-export declare type promise_resolve_T<T> = (value:T|PromiseLike<T>)=>void
-export declare type promise_reject_T = (reason?:any)=>void
+export type promise_resolve_T<T> = (value:T|PromiseLike<T>)=>void
+export type promise_reject_T = (reason?:unknown)=>void
+export type cancel_Promise<
+	V,
+	cancel_fn_T extends (
+		|(()=>Promise<V>)
+		|((val:V)=>Promise<V>)
+	)
+> =
+	&Promise<V>
+	&{ cancel:cancel_fn_T }

package/all/promise/index.js

@@ -1 +1 @@
-export {}
+export {}

package/all/promise_timeout/index.d.ts

@@ -1,5 +1,6 @@
+import type { cancel_Promise } from '../promise/index.js'
 export declare function promise_timeout<O>(
 	promise:(()=>Promise<O>)|Promise<O>,
 	ms:number,
 	error?:Error
-):Promise<O>&{ cancel:(val:O)=>void }
+):cancel_Promise<O, (val?:O)=>Promise<O>>

package/all/promise_timeout/index.js

@@ -2,7 +2,7 @@
  * @param {(()=>Promise<unknown>)|Promise<unknown>}promise
  * @param {number}ms
  * @param {Error}[error]
- * @returns {Promise<unknown>}
+ * @returns {cancel_Promise}
  */
 export function promise_timeout(
 	promise,
@@ -16,6 +16,7 @@ export function promise_timeout(
 	})
 	let cancel_promise__resolve
 	let cancel_promise = new Promise(resolve=>cancel_promise__resolve = resolve)
+	/** @type {cancel_Promise} */
 	let ret_promise = Promise.race([
 		typeof promise === 'function' ? promise() : promise,
 		timeout,

package/all/rmemo/index.d.ts

@@ -19,21 +19,25 @@ export declare function on(rmemo:rmemo_T<unknown>):void
 export declare function off(rmemo:rmemo_T<unknown>):void
 export declare function rmemo__subscribe(rmemo:rmemo_T<unknown>, listener:()=>unknown):()=>void
 export type rmemo_T<val_T> = memo_T<val_T>|sig_T<val_T>|lock_memosig_T<val_T>
+export type circular_rmemo_T = circular_memo_T|circular_sig_T|circular_lock_memosig_T
 export type memo_T<val_T> = (()=>val_T)&{
 	readonly _:val_T
 	readonly val:val_T
 	r?:WeakRef<()=>val_T>
 	memor:WeakRef<()=>val_T>[]
 }
+export interface circular_memo_T extends memo_T<circular_memo_T> {}
 export type sig_T<val_T> = (()=>val_T)&{
 	_:val_T
 	readonly val:val_T
 	r?:WeakRef<()=>val_T>
 	memor:WeakRef<()=>val_T>[]
 }
+export interface circular_sig_T extends sig_T<circular_sig_T> {}
 export type lock_memosig_T<val_T> = sig_T<val_T>&{
 	lock?:0|1
 }
+export interface circular_lock_memosig_T extends lock_memosig_T<circular_lock_memosig_T> {}
 export type rmemo_val_T<sig_T> = sig_T extends { ():infer val_T }
 	? val_T
 	: unknown

package/all/rmemo__wait/index.d.ts

@@ -1,3 +1,4 @@
+import { cancel_Promise } from '../promise/index.js'
 import type { memo_T, rmemo_T, rmemo_val_T } from '../rmemo/index.js'
 export declare function rmemo__wait<
 	_rmemo_T extends rmemo_T<unknown> = rmemo_T<unknown>
@@ -6,8 +7,12 @@ export declare function rmemo__wait<
 	condition_fn:(val:rmemo_val_T<_rmemo_T>)=>unknown,
 	timeout?:number,
 	error?:Error
-):Promise<rmemo_val_T<_rmemo_T>>&{
+):rmemo__wait_ret_T<rmemo_val_T<_rmemo_T>>
+export type rmemo__wait_ret_T<R> =
+	cancel_Promise<
+		R,
+		(val?:R)=>Promise<R>
+	>&{
 	// prevent early usGC
 	m:memo_T<unknown>
-	cancel:(val:rmemo_val_T<_rmemo_T>)=>void
 }

package/all/rmemo__wait/index.js

@@ -7,7 +7,7 @@ import { memo_ } from '../rmemo/index.js'
  * @param {(val:unknown)=>unknown}condition_fn
  * @param {number}[timeout]
  * @param {Error}[error]
- * @returns {Promise<*>|Promise<unknown>}
+ * @returns {cancel_Promise&{ m:memo_T<unknown> }}
  */
 export function rmemo__wait(
 	rmemo,
@@ -24,6 +24,7 @@ export function rmemo__wait(
 		})
 		memo()
 	})
+	/** @type {cancel_Promise&{ m:memo_T<unknown> }} */
 	let promise =
 		promise_timeout(
 			_subscribe_wait,

package/all/sleep/index.d.ts

@@ -1 +1,3 @@
-export declare function sleep(ms:number):Promise<number|NodeJS.Timeout>
+export declare function sleep(
+	ms:number
+):Promise<number>

package/all/sleep/index.js

@@ -1,7 +1,8 @@
 /**
  * @param {number}ms
- * @returns {Promise<number|NodeJS.Timeout>}
+ * @returns {Promise<number>}
  */
 export function sleep(ms) {
-	return new Promise((resolve)=>setTimeout(resolve, ms))
+	return new Promise(resolve=>
+		setTimeout(resolve, ms))
 }

package/all/waitfor/index.d.ts

@@ -1,5 +1,14 @@
+import type { cancel_Promise } from '../promise/index.js'
 export declare function waitfor<V>(
 	fn:()=>Promise<V>|V,
 	timeout:number,
-	period?:number
-):Promise<V>&{ cancel:()=>Promise<V> }
+	period?:number|((promise:waitfor_Promise<V>)=>Promise<number>)
+):waitfor_Promise<V>
+export declare function cancel__period_<V>(
+	ms:number,
+	should_cancel_:()=>boolean
+):(
+	promise:waitfor_Promise<V>
+)=>Promise<number>
+export type waitfor_Promise<V> =
+	cancel_Promise<V, (val?:V)=>Promise<V>>

package/all/waitfor/index.js

@@ -1,31 +1,61 @@
+import { Cancel } from '../cancel/index.js'
 import { promise_timeout } from '../promise_timeout/index.js'
 import { sleep } from '../sleep/index.js'
 /**
  * @param {()=>Promise<unknown>}fn
- * @param {unknown}timeout
- * @param {unknown}[period]
- * @returns {Promise<void>}
+ * @param {number}timeout
+ * @param {number|(()=>Promise<unknown>)}[period]
+ * @returns {Promise<unknown>}
  */
-export function waitfor(fn, timeout, period = 0) {
-	let cancel
+export function waitfor(
+	fn,
+	timeout,
+	period
+) {
+	let rv
+	let cancel_arg_a
 	let promise = new Promise((resolve, reject)=>
 		promise_timeout(async ()=>{
-			let rv
-			for (; !cancel;) {
-				rv = await fn()
-				if (rv) return rv
-				await sleep(period)
+			for (; !cancel_arg_a;) {
+				let _rv = await fn()
+				rv = cancel_arg_a?.length ? cancel_arg_a[0] : _rv
+				if (rv || cancel_arg_a) return rv
+				if (typeof period === 'function') {
+					await period(promise)
+				} else {
+					await sleep(period ?? 0)
+				}
 			}
 			return rv
 		}, timeout)
 			.then(resolve)
 			.catch(err=>{
-				cancel = 1
+				cancel_arg_a = []
 				reject(err)
 			}))
-	promise.cancel = ()=>{
-		cancel = 1
+	promise.cancel = (...arg_a)=>{
+		cancel_arg_a = arg_a
 		return promise
 	}
 	return promise
 }
+/**
+ * @param {number}ms
+ * @param {()=>boolean}should_cancel_
+ * @param {Cancel_config_T}[Cancel_config]
+ * @returns {(promise:Promise<unknown>&{cancel():unknown})=>Promise<number>}
+ * @private
+ */
+export function cancel__period_(
+	ms,
+	should_cancel_,
+	Cancel_config
+) {
+	return promise=>{
+		if (should_cancel_()) {
+			promise.cancel()
+			throw new Cancel(Cancel_config)
+		}
+		return sleep(ms)
+	}
+}

package/all/waitfor/index.test.ts

@@ -1,5 +1,6 @@
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
+import { sleep } from '../sleep/index.js'
 import { waitfor } from './index.js'
 test('waitfor|success', async ()=>{
 	let count = 0
@@ -45,5 +46,65 @@ test('waitfor|cancel', async ()=>{
 	equal(count, 1)
 	equal(await promise, false)
 	equal(count, 1)
+	count = 0
+	const undefinable_promise = waitfor<boolean|undefined>(()=>{
+		count++
+		return false
+	}, 10)
+	equal(count, 1)
+	equal(await undefinable_promise.cancel(undefined), undefined)
+	equal(count, 1)
+	equal(await undefinable_promise, undefined)
+	equal(count, 1)
+})
+test('waitfor|period|number', async ()=>{
+	let count = 0
+	let ret = false
+	const promise = waitfor(()=>{
+		count++
+		return ret
+	}, 10, 2)
+	try {
+		equal(count, 1)
+		await sleep(2)
+		await sleep(0)
+		equal(count, 2)
+		await sleep(2)
+		equal(count, 3)
+		ret = true
+		equal(await promise, true)
+		equal(count, 4)
+	} finally {
+		await promise.cancel()
+	}
+})
+test('waitfor|period|async function', async ()=>{
+	let count = 0
+	let ret = false
+	const period_arg_aa:Promise<boolean>[][] = []
+	const promise = waitfor(()=>{
+		count++
+		return ret
+	}, 10, (...arg_a)=>{
+		period_arg_aa.push(arg_a)
+		return sleep(2)
+	})
+	try {
+		equal(count, 1)
+		await sleep(0)
+		equal(period_arg_aa, [[promise]])
+		await sleep(2)
+		equal(count, 2)
+		equal(period_arg_aa, [[promise], [promise]])
+		await sleep(2)
+		equal(count, 3)
+		equal(period_arg_aa, [[promise], [promise], [promise]])
+		ret = true
+		equal(await promise, true)
+		equal(count, 4)
+		equal(period_arg_aa, [[promise], [promise], [promise]])
+	} finally {
+		await promise.cancel()
+	}
 })
 test.run()

package/function/index.d.ts

@@ -17,6 +17,7 @@ export * from '../all/bind_map_call/index.js'
 export * from '../all/call/index.js'
 export * from '../all/call_fn_a/index.js'
 export * from '../all/call_or_fn/index.js'
+export * from '../all/cancel/index.js'
 export * from '../all/compose/index.js'
 export * from '../all/concat/index.js'
 export * from '../all/debounce/index.js'

package/function/index.js

@@ -17,6 +17,7 @@ export * from '../all/bind_map_call/index.js'
 export * from '../all/call/index.js'
 export * from '../all/call_fn_a/index.js'
 export * from '../all/call_or_fn/index.js'
+export * from '../all/cancel/index.js'
 export * from '../all/compose/index.js'
 export * from '../all/concat/index.js'
 export * from '../all/debounce/index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "5.8.0",
+  "version": "5.10.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",