ctx-core 5.3.0 → 5.4.0

package/all/file_exists/index.js

@@ -8,10 +8,11 @@ import { waitfor } from '../waitfor/index.js'
 export async function file_exists_(path) {
 	return (
 		(process_release_name ?? false)
-		&& import('node:fs/promises').then(({ access, constants })=>
-			access(path, constants.F_OK)
+		&& import('node:fs/promises').then(({ access, constants })=>{
+			return access(path, constants.F_OK)
 				.then(()=>true)
-				.catch(()=>false)))
+				.catch(()=>false)
+		}))
 }
 export {
 	file_exists_ as path__exists_

package/all/is_browser/index.d.ts

@@ -1 +1 @@
-export declare function is_server_():boolean
+export declare function is_browser_():boolean

package/all/is_browser/index.js

@@ -1,3 +1,3 @@
-export function is_server_() {
-	return !!globalThis.process?.release?.name
+export function is_browser_() {
+	return !globalThis.process?.release?.name
 }

package/all/is_server/index.js

@@ -1,3 +1,3 @@
-export function is_browser_() {
-	return !globalThis.process?.release?.name
+export function is_server_() {
+	return !!globalThis.process?.release?.name
 }

package/all/promise_timeout/index.test.ts

@@ -0,0 +1,32 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { run } from '../run/index.js'
+import { sleep } from '../sleep/index.js'
+import { promise_timeout } from './index.js'
+test('promise_timeout|success', async ()=>{
+	let count = 0
+	const promise = promise_timeout(run(async ()=>{
+		count++
+		await sleep(10)
+		return true
+	}), 100)
+	equal(count, 1)
+	equal(await promise, true)
+	equal(count, 1)
+})
+test('promise_timeout|timeout', async ()=>{
+	let count = 0
+	let err:Error|undefined = undefined
+	try {
+		await promise_timeout(run(async ()=>{
+			count++
+			await sleep(10)
+			return false
+		}), 1)
+	} catch (_err) {
+		err = _err as Error
+	}
+	equal(count, 1)
+	equal(err?.message, 'Timeout 1ms')
+})
+test.run()

package/all/sleep/index.test.ts

@@ -0,0 +1,9 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { sleep } from './index.js'
+test('sleep', async ()=>{
+	const now0 = performance.now()
+	await sleep(10)
+	equal(performance.now() >= now0 + 10, true)
+})
+test.run()

package/all/waitfor/index.d.ts

@@ -1,5 +1,5 @@
-export declare function waitfor(
-	fn:()=>Promise<boolean>|boolean,
+export declare function waitfor<V>(
+	fn:()=>Promise<V>|V,
 	timeout:number,
 	period?:number
-):Promise<void>
+):Promise<V>&{ cancel: ()=>Promise<V> }

package/all/waitfor/index.js

@@ -1,22 +1,31 @@
 import { promise_timeout } from '../promise_timeout/index.js'
 import { sleep } from '../sleep/index.js'
 /**
- * @param {()=>Promise<boolean>}fn
+ * @param {()=>Promise<unknown>}fn
  * @param {unknown}timeout
  * @param {unknown}[period]
  * @returns {Promise<void>}
  */
-export async function waitfor(fn, timeout, period = 0) {
+export function waitfor(fn, timeout, period = 0) {
 	let cancel
-	try {
-		await promise_timeout(async ()=>{
+	let promise = new Promise((resolve, reject)=>
+		promise_timeout(async ()=>{
+			let rv
 			for (; !cancel;) {
-				if (await fn()) return
+				rv = await fn()
+				if (rv) return rv
 				await sleep(period)
 			}
+			return rv
 		}, timeout)
-	} catch (err) {
+			.then(resolve)
+			.catch(err=>{
+				cancel = 1
+				reject(err)
+			}))
+	promise.cancel = ()=>{
 		cancel = 1
-		throw err
+		return promise
 	}
+	return promise
 }

package/all/waitfor/index.test.ts

@@ -0,0 +1,49 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { waitfor } from './index.js'
+test('waitfor|success', async ()=>{
+	let count = 0
+	let ret = false
+	const returned_value_a:boolean[] = []
+	const promise = waitfor(()=>{
+		count++
+		return ret
+	}, 10)
+		.then(returned_value=>{
+			returned_value_a.push(returned_value)
+			return returned_value
+		})
+	equal(count, 1)
+	equal(returned_value_a, [])
+	ret = true
+	equal(await promise, true)
+	equal(count, 2)
+	equal(returned_value_a, [true])
+})
+test('waitfor|timeout', async ()=>{
+	let count = 0
+	let err:Error|undefined = undefined
+	try {
+		await waitfor(()=>{
+			count++
+			return false
+		}, 1)
+	} catch (_err) {
+		err = _err as Error
+	}
+	equal(count, 1)
+	equal(err?.message, 'Timeout 1ms')
+})
+test('waitfor|cancel', async ()=>{
+	let count = 0
+	const promise = waitfor(()=>{
+		count++
+		return false
+	}, 10)
+	equal(count, 1)
+	equal(await promise.cancel(), false)
+	equal(count, 1)
+	equal(await promise, false)
+	equal(count, 1)
+})
+test.run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -121,7 +121,7 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.13.4",
+    "@arethetypeswrong/cli": "^0.13.5",
     "@ctx-core/preprocess": "^0.1.0",
     "@size-limit/preset-small-lib": "^11.0.1",
     "@types/node": "^20.10.5",