@kikiutils/shared 20.1.0 → 20.1.2

package/src/classes/path.ts

@@ -241,8 +241,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.access}
      */
-    access(...args: DropFirstParameters<typeof fsp.access>) {
-        return fsp.access(this.#value, ...args);
+    async access(...args: DropFirstParameters<typeof fsp.access>) {
+        return await fsp.access(this.#value, ...args);
     }
 
     /**
@@ -253,8 +253,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.appendFile}
      */
-    appendFile(...args: DropFirstParameters<typeof fsp.appendFile>) {
-        return fsp.appendFile(this.#value, ...args);
+    async appendFile(...args: DropFirstParameters<typeof fsp.appendFile>) {
+        return await fsp.appendFile(this.#value, ...args);
     }
 
     /**
@@ -265,8 +265,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.chmod}
      */
-    chmod(...args: DropFirstParameters<typeof fsp.chmod>) {
-        return fsp.chmod(this.#value, ...args);
+    async chmod(...args: DropFirstParameters<typeof fsp.chmod>) {
+        return await fsp.chmod(this.#value, ...args);
     }
 
     /**
@@ -277,8 +277,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.chown}
      */
-    chown(...args: DropFirstParameters<typeof fsp.chown>) {
-        return fsp.chown(this.#value, ...args);
+    async chown(...args: DropFirstParameters<typeof fsp.chown>) {
+        return await fsp.chown(this.#value, ...args);
     }
 
     /**
@@ -289,8 +289,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.copyFile}
      */
-    copyFile(...args: DropFirstParameters<typeof fsp.copyFile>) {
-        return fsp.copyFile(this.#value, ...args);
+    async copyFile(...args: DropFirstParameters<typeof fsp.copyFile>) {
+        return await fsp.copyFile(this.#value, ...args);
     }
 
     /**
@@ -310,8 +310,8 @@ export class Path {
           | null,
     ): Promise<void>;
     mkdir(options?: fs.MakeDirectoryOptions | fs.Mode | null): Promise<string | undefined>;
-    mkdir(...args: any): any {
-        return fsp.mkdir(this.#value, ...args);
+    async mkdir(...args: any): Promise<any> {
+        return await fsp.mkdir(this.#value, ...args);
     }
 
     /**
@@ -322,8 +322,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.open}
      */
-    open(...args: DropFirstParameters<typeof fsp.open>) {
-        return fsp.open(this.#value, ...args);
+    async open(...args: DropFirstParameters<typeof fsp.open>) {
+        return await fsp.open(this.#value, ...args);
     }
 
     /**
@@ -374,8 +374,8 @@ export class Path {
             withFileTypes: true;
         },
     ): Promise<Array<fs.Dirent<Buffer>>>;
-    readdir(...args: any): any {
-        return fsp.readdir(this.#value, ...args);
+    async readdir(...args: any): Promise<any> {
+        return await fsp.readdir(this.#value, ...args);
     }
 
     /**
@@ -412,8 +412,8 @@ export class Path {
             | BufferEncoding
             | null,
     ): Promise<Buffer | string>;
-    readFile(...args: any): any {
-        return fsp.readFile(this.#value, ...args);
+    async readFile(...args: any): Promise<any> {
+        return await fsp.readFile(this.#value, ...args);
     }
 
     /**
@@ -426,8 +426,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.rename}
      */
-    rename(newPath: PathLike) {
-        return fsp.rename(this.#value, newPath.toString());
+    async rename(newPath: PathLike) {
+        return await fsp.rename(this.#value, newPath.toString());
     }
 
     /**
@@ -438,8 +438,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.rm}
      */
-    rm(...args: DropFirstParameters<typeof fsp.rm>) {
-        return fsp.rm(this.#value, ...args);
+    async rm(...args: DropFirstParameters<typeof fsp.rm>) {
+        return await fsp.rm(this.#value, ...args);
     }
 
     /**
@@ -450,8 +450,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.rmdir}
      */
-    rmdir(...args: DropFirstParameters<typeof fsp.rmdir>) {
-        return fsp.rmdir(this.#value, ...args);
+    async rmdir(...args: DropFirstParameters<typeof fsp.rmdir>) {
+        return await fsp.rmdir(this.#value, ...args);
     }
 
     /**
@@ -512,8 +512,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.truncate}
      */
-    truncate(...args: DropFirstParameters<typeof fsp.truncate>) {
-        return fsp.truncate(this.#value, ...args);
+    async truncate(...args: DropFirstParameters<typeof fsp.truncate>) {
+        return await fsp.truncate(this.#value, ...args);
     }
 
     /**
@@ -524,8 +524,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.unlink}
      */
-    unlink() {
-        return fsp.unlink(this.#value);
+    async unlink() {
+        return await fsp.unlink(this.#value);
     }
 
     /**
@@ -536,7 +536,7 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.writeFile}
      */
-    writeFile(...args: DropFirstParameters<typeof fsp.writeFile>) {
-        return fsp.writeFile(this.#value, ...args);
+    async writeFile(...args: DropFirstParameters<typeof fsp.writeFile>) {
+        return await fsp.writeFile(this.#value, ...args);
     }
 }

package/src/enum.ts

@@ -1,3 +1,9 @@
+import {
+    objectKeys,
+    objectValues,
+} from 'ts-extras';
+import type { ValueOf } from 'type-fest';
+
 /**
  * Extracts only the numeric values from an enumeration-like object.
  *
@@ -22,7 +28,7 @@
  * console.log(getEnumNumberValues(RecordType)); // => [0, 1]
  * ```
  */
-export function getEnumNumberValues<T extends Record<string, any>>(enumObject: T): Array<Extract<T[keyof T], number>> {
+export function getEnumNumberValues<T extends Record<string, any>>(enumObject: T): Array<Extract<ValueOf<T>, number>> {
     return getEnumValues(enumObject).filter((value) => typeof value === 'number');
 }
 
@@ -50,7 +56,7 @@ export function getEnumNumberValues<T extends Record<string, any>>(enumObject: T
  * console.log(getEnumStringValues(RecordType)); // => ['unknown']
  * ```
  */
-export function getEnumStringValues<T extends Record<string, any>>(enumObject: T): Array<Extract<T[keyof T], string>> {
+export function getEnumStringValues<T extends Record<string, any>>(enumObject: T): Array<Extract<ValueOf<T>, string>> {
     return getEnumValues(enumObject).filter((value) => typeof value === 'string');
 }
 
@@ -102,9 +108,9 @@ export function getEnumStringValues<T extends Record<string, any>>(enumObject: T
  * console.log(getEnumValues(RecordType)); // => [0, 1, 'unknown']
  * ```
  */
-export function getEnumValues<T extends Record<string, any>>(enumObject: T): Array<T[keyof T]> {
-    const values = Object.values(enumObject);
+export function getEnumValues<T extends Record<string, any>>(enumObject: T): Array<ValueOf<T>> {
+    const values = objectValues(enumObject);
     const hasNumberValues = values.some((value) => typeof value === 'number');
     if (!hasNumberValues) return values;
-    return Object.keys(enumObject).filter((key) => Number.isNaN(Number(key))).map((key) => enumObject[key]);
+    return objectKeys(enumObject).filter((key) => Number.isNaN(Number(key))).map((key) => enumObject[key]);
 }

package/src/event-awaiter.ts

@@ -58,8 +58,8 @@ export class EventAwaiter<T> {
      *
      * @throws Error through promise rejection if `strict` mode encounters an existing waiter.
      */
-    wait(key: string, timeoutMs?: number, mode?: 'override' | 'strict', signal?: AbortSignal) {
-        return new Promise<T | undefined>((resolve) => {
+    async wait(key: string, timeoutMs?: number, mode?: 'override' | 'strict', signal?: AbortSignal) {
+        return await new Promise<T | undefined>((resolve) => {
             const resolvers = this.#promiseResolvers.get(key) || [];
             if (resolvers.length) {
                 switch (mode) {
@@ -122,8 +122,8 @@ export class EventAwaiter<T> {
      *
      * @see {@link EventAwaiter.wait}
      */
-    waitExclusive(key: string, timeoutMs?: number, signal?: AbortSignal) {
-        return this.wait(key, timeoutMs, 'strict', signal);
+    async waitExclusive(key: string, timeoutMs?: number, signal?: AbortSignal) {
+        return await this.wait(key, timeoutMs, 'strict', signal);
     }
 
     /**
@@ -140,7 +140,7 @@ export class EventAwaiter<T> {
      *
      * @see {@link EventAwaiter.wait}
      */
-    waitLatest(key: string, timeoutMs?: number, signal?: AbortSignal) {
-        return this.wait(key, timeoutMs, 'override', signal);
+    async waitLatest(key: string, timeoutMs?: number, signal?: AbortSignal) {
+        return await this.wait(key, timeoutMs, 'override', signal);
     }
 }

package/src/general.ts

@@ -1,3 +1,5 @@
+import type { Arrayable } from 'type-fest';
+
 /* eslint-disable jsdoc/check-param-names */
 
 /**
@@ -31,9 +33,9 @@
  * console.log(extractFirstValue(undefined, 'fallback')); // => 'fallback'
  * ```
  */
-export function extractFirstValue<T>(value: T | T[]): T | undefined;
-export function extractFirstValue<T, D>(value: T | T[], defaultValue: D): D | NonNullable<T>;
-export function extractFirstValue<T, D>(value: T | T[], defaultValue?: D) {
+export function extractFirstValue<T>(value: Arrayable<T>): T | undefined;
+export function extractFirstValue<T, D>(value: Arrayable<T>, defaultValue: D): D | NonNullable<T>;
+export function extractFirstValue<T, D>(value: Arrayable<T>, defaultValue?: D) {
     return (Array.isArray(value) ? value[0] : value) ?? defaultValue;
 }
 

package/src/logger/_internals/logger.ts

@@ -1,3 +1,8 @@
+import {
+    objectHasOwn,
+    objectKeys,
+} from 'ts-extras';
+
 import type {
     Logger,
     LoggerDiagnostic,
@@ -172,7 +177,7 @@ export function createLoggerCore(options: LoggerOptions, hooks: LoggerHooks): Re
         },
     } as Logger;
 
-    for (const type of Object.keys(loggerMethods) as LoggerMethod[]) {
+    for (const type of objectKeys(loggerMethods) as LoggerMethod[]) {
         logger[type] = async (...args: unknown[]) => {
             try {
                 refreshLevel();
@@ -202,7 +207,7 @@ function getLevelSeverity(level: LoggerLevel | LoggerMethod): number {
 
 function isLevel(value: unknown): value is LoggerLevel {
     return typeof value === 'string'
-      && (value === 'silent' || (value !== 'success' && Object.hasOwn(loggerMethods, value)));
+      && (value === 'silent' || (value !== 'success' && objectHasOwn(loggerMethods, value)));
 }
 
 function readEnvironmentLevel(): string | undefined {

package/src/logger/node/_internals/file-writer.ts

@@ -141,8 +141,8 @@ export async function createFileWriter(
     }
 
     return Object.freeze({
-        close() {
-            if (closePromise) return closePromise;
+        async close() {
+            if (closePromise) return await closePromise;
             closing = true;
             closePromise = new Promise<void>((resolveClosed) => {
                 if (closed) {
@@ -158,21 +158,21 @@ export async function createFileWriter(
                 }
             });
 
-            return closePromise;
+            return await closePromise;
         },
         getStats: () => Object.freeze({
             droppedCount,
             pendingBytes,
             writeErrorCount,
         }),
-        write(text: string) {
+        async write(text: string) {
             if (closing || closed || failed) {
                 report({
                     message: 'File output is closed or unavailable.',
                     type: 'closed',
                 });
 
-                return Promise.resolve();
+                return await Promise.resolve();
             }
 
             const bytes = Buffer.byteLength(text);
@@ -184,11 +184,11 @@ export async function createFileWriter(
                     type: 'overflow',
                 });
 
-                return Promise.resolve();
+                return await Promise.resolve();
             }
 
             pendingBytes += bytes;
-            return new Promise<void>((resolveWritten) => {
+            return await new Promise<void>((resolveWritten) => {
                 let settled = false;
                 const settle = () => {
                     if (settled) return;

package/src/logger/node/index.ts

@@ -47,7 +47,7 @@ export async function createNodeLogger(options: NodeLoggerOptions = {}): Promise
         options,
         {
             report,
-            write(record) {
+            async write(record) {
                 if (closed) {
                     report({
                         message: 'Logger is closed.',
@@ -69,14 +69,14 @@ export async function createNodeLogger(options: NodeLoggerOptions = {}): Promise
                     void completion.then(() => consoleWrites.delete(completion));
                     const fileCompletion = writer?.write(`${stripVTControlCharacters(text)}\n`);
                     return fileCompletion
-                        ? Promise.all([
+                        ? await Promise.all([
                             completion,
                             fileCompletion,
                         ]).then(() => {})
-                        : completion;
+                        : await completion;
                 }
 
-                return writer?.write(`${stripVTControlCharacters(text)}\n`);
+                return await writer?.write(`${stripVTControlCharacters(text)}\n`);
             },
         },
     );
@@ -85,8 +85,8 @@ export async function createNodeLogger(options: NodeLoggerOptions = {}): Promise
 
     return Object.freeze({
         ...logger,
-        close() {
-            if (closePromise) return closePromise;
+        async close() {
+            if (closePromise) return await closePromise;
             closed = true;
             closePromise = (async () => {
                 await Promise.all([
@@ -108,7 +108,7 @@ export async function createNodeLogger(options: NodeLoggerOptions = {}): Promise
                 consoleTargets.clear();
             })();
 
-            return closePromise;
+            return await closePromise;
         },
         getStats: () => writer?.getStats() ?? Object.freeze({
             droppedCount: 0,
@@ -121,7 +121,7 @@ export async function createNodeLogger(options: NodeLoggerOptions = {}): Promise
 /**
  * One error listener per shared output stream; retained until its last owning logger calls close().
  */
-function writeConsole(
+async function writeConsole(
     target: NodeJS.WriteStream,
     text: string,
     report: (event: LoggerDiagnostic) => void,
@@ -149,7 +149,7 @@ function writeConsole(
 
     state.owners.add(owner);
     const current = state;
-    return new Promise<void>((resolveWritten) => {
+    return await new Promise<void>((resolveWritten) => {
         let settled = false;
         const settle = (error?: Error | null) => {
             if (settled) return;

package/src/storages/redis/keyed-store.ts

@@ -20,18 +20,18 @@ import type { RedisLikeStorage } from './types';
  */
 export function createRedisKeyedStore<D = unknown>(storage: MaybeReadonly<RedisLikeStorage>) {
     return <P extends any[]>(keyFn: (...args: P) => string) => Object.freeze({
-        getAndRemoveItem: (...args: P) => storage.getAndRemoveItem<D>(keyFn(...args)),
-        getItem: (...args: P) => storage.getItem<D>(keyFn(...args)),
-        getItemTtl: (...args: P) => storage.getItemTtl(keyFn(...args)),
-        hasItem: (...args: P) => storage.hasItem(keyFn(...args)),
-        removeItem: (...args: P) => storage.removeItem(keyFn(...args)),
+        getAndRemoveItem: async (...args: P) => await storage.getAndRemoveItem<D>(keyFn(...args)),
+        getItem: async (...args: P) => await storage.getItem<D>(keyFn(...args)),
+        getItemTtl: async (...args: P) => await storage.getItemTtl(keyFn(...args)),
+        hasItem: async (...args: P) => await storage.hasItem(keyFn(...args)),
+        removeItem: async (...args: P) => await storage.removeItem(keyFn(...args)),
         resolveKey: (...args: P) => keyFn(...args),
-        setItem: (value: D, ...args: P) => storage.setItem(keyFn(...args), value),
-        setItemWithTtl(ttlSeconds: number, value: D, ...args: P) {
-            return storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);
+        setItem: async (value: D, ...args: P) => await storage.setItem(keyFn(...args), value),
+        async setItemWithTtl(ttlSeconds: number, value: D, ...args: P) {
+            return await storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);
         },
-        setItemWithTtlIfAbsent(ttlSeconds: number, value: D, ...args: P) {
-            return storage.setItemWithTtlIfAbsent(keyFn(...args), ttlSeconds, value);
+        async setItemWithTtlIfAbsent(ttlSeconds: number, value: D, ...args: P) {
+            return await storage.setItemWithTtlIfAbsent(keyFn(...args), ttlSeconds, value);
         },
     });
 }

package/src/storages/redis/msgpack.ts

@@ -73,8 +73,8 @@ export function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<R
             const rawValue = await adapter.getBuffer(key);
             return rawValue ? decode(rawValue) as T : null;
         },
-        getItemTtl: (key: string) => adapter.ttl(key),
-        hasItem: (key: string) => adapter.has(key),
+        getItemTtl: async (key: string) => await adapter.ttl(key),
+        hasItem: async (key: string) => await adapter.has(key),
         removeItem: async (key: string) => await adapter.delete(key) === 1,
         setItem: async (key: string, value: any) => await adapter.setBuffer(key, encode(value)) === 'OK',
         async setItemWithTtl(key: string, ttlSeconds: number, value: any) {

package/src/time.ts

@@ -18,8 +18,8 @@
  * await delay(5000, controller.signal);
  * ```
  */
-export function delay(ms: number, signal?: AbortSignal): Promise<void> {
-    return new Promise((resolve) => {
+export async function delay(ms: number, signal?: AbortSignal): Promise<void> {
+    return await new Promise((resolve) => {
         if (signal?.aborted) {
             resolve();
             return;
@@ -61,8 +61,8 @@ export function delay(ms: number, signal?: AbortSignal): Promise<void> {
  * }
  * ```
  */
-export function delayOrThrow(ms: number, signal?: AbortSignal): Promise<void> {
-    return new Promise((resolve, reject) => {
+export async function delayOrThrow(ms: number, signal?: AbortSignal): Promise<void> {
+    return await new Promise((resolve, reject) => {
         if (signal?.aborted) {
             reject(signal.reason);
             return;