@kikiutils/shared 20.1.0 → 20.1.1

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;