@naturalcycles/js-lib 15.83.0 → 15.84.1

package/src/decorators/decorator.util.ts

@@ -1,5 +1,16 @@
 import type { AnyObject, InstanceId } from '../types.js'
 
+/**
+ * Generic override of TypeScript's built-in legacy MethodDecorator, that
+ * allows us to infer the parameters of the decorated method from the parameters
+ * of a decorator.
+ */
+export type MethodDecorator<T> = (
+  target: AnyObject,
+  propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<T>,
+) => TypedPropertyDescriptor<T> | undefined
+
 /**
  * @returns
  * e.g `NameOfYourClass.methodName`

package/src/decorators/memo.decorator.ts

@@ -2,8 +2,9 @@ import { _assert, _assertTypeOf } from '../error/assert.js'
 import type { CommonLogger } from '../log/commonLogger.js'
 import type { AnyFunction, AnyObject, MaybeParameters } from '../types.js'
 import { _objectAssign } from '../types.js'
+import type { MethodDecorator } from './decorator.util.js'
 import { _getTargetMethodSignature } from './decorator.util.js'
-import type { MemoCache, MethodDecorator } from './memo.util.js'
+import type { MemoCache } from './memo.util.js'
 import { jsonMemoSerializer, MapMemoCache } from './memo.util.js'
 
 export interface MemoOptions<FN> {

package/src/decorators/memo.util.ts

@@ -1,6 +1,6 @@
 import { _isPrimitive } from '../is.util.js'
 import { pDelay } from '../promise/pDelay.js'
-import type { AnyObject, UnixTimestamp } from '../types.js'
+import type { UnixTimestamp } from '../types.js'
 import { MISS } from '../types.js'
 
 export type MemoSerializer = (args: any[]) => any
@@ -147,14 +147,3 @@ export class MapAsyncMemoCache<KEY = any, VALUE = any> implements AsyncMemoCache
     this.m.clear()
   }
 }
-
-/**
- * Generic override of Typescript's built in legacy MethodDecorator, that
- * allows us to infer the parameters of the decorated method from the parameters
- * of a decorator.
- */
-export type MethodDecorator<T> = (
-  target: AnyObject,
-  propertyKey: string | symbol,
-  descriptor: TypedPropertyDescriptor<T>,
-) => TypedPropertyDescriptor<T> | undefined

package/src/promise/pGradualQueue.ts

@@ -159,7 +159,8 @@ function runSafe<R>(fn: AsyncFunction<R>): Promise<R> {
     return fn()
   } catch (err) {
     // Handle synchronous throws
-    return Promise.reject(err as Error)
+    // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+    return Promise.reject(err)
   }
 }
 

package/src/promise/pQueue.ts

@@ -150,7 +150,8 @@ function runSafe<R>(fn: AsyncFunction<R>): Promise<R> {
     return fn()
   } catch (err) {
     // Handle synchronous throws - ensure inFlight is decremented
-    return Promise.reject(err as Error)
+    // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+    return Promise.reject(err)
   }
 }
 

package/src/promise/pTimeout.ts

@@ -108,7 +108,8 @@ export async function pTimeout<T>(
     try {
       resolve(await fn(signal))
     } catch (err) {
-      reject(err as Error)
+      // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+      reject(err)
     } finally {
       clearTimeout(timer)
     }

package/src/typeFest.ts

@@ -57,9 +57,9 @@ export type Except<ObjectType, KeysType extends keyof ObjectType> = {
  * When you use a type that will iterate through an object that has indexed keys and explicitly defined keys you end up with a type where only the indexed keys are kept. This is because `keyof` of an indexed type always returns `string | number | symbol`, because every key is possible in that object. With this type, you can save the indexed keys and reinject them later, like in the second example below.
  */
 export type PickIndexSignature<ObjectType> = {
-  [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-    ? KeyType
-    : never]: ObjectType[KeyType]
+  [
+    KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never
+  ]: ObjectType[KeyType]
 }
 
 /**
@@ -73,9 +73,9 @@ export type PickIndexSignature<ObjectType> = {
  * (The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
  */
 export type OmitIndexSignature<ObjectType> = {
-  [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-    ? never
-    : KeyType]: ObjectType[KeyType]
+  [
+    KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType
+  ]: ObjectType[KeyType]
 }
 
 /**