rajt 0.0.57 → 0.0.58

package/src/utils/func.ts

@@ -1,8 +1,8 @@
 export const isAsyncFn = (fn: any) => {
-  return fn?.constructor?.name === 'AsyncFunction'
+  return fn?.constructor?.name == 'AsyncFunction'
     || fn.toString().toLowerCase().trim().startsWith('async')
 }
 
 export const isAnonFn = (fn: any) => {
-    return fn?.name === '' || fn?.name === 'anonymous'
+    return fn?.name === '' || fn?.name == 'anonymous'
 }

package/src/utils/local-date.ts

@@ -0,0 +1,13 @@
+const getFullYear = Date.prototype.getFullYear
+const getMonth = Date.prototype.getMonth
+const getDate = Date.prototype.getDate
+const getHours = Date.prototype.getHours
+const getMinutes = Date.prototype.getMinutes
+const getSeconds = Date.prototype.getSeconds
+const pad = (n: number) => n > 9 ? n : '0' + n
+
+export const getLocalDateTime = (date = new Date()) =>
+  getFullYear.call(date) + '-' + pad(getMonth.call(date) + 1) + '-' + pad(getDate.call(date))
+   + ' ' + pad(getHours.call(date)) + ':' + pad(getMinutes.call(date)) + ':' + pad(getSeconds.call(date))
+
+export default getLocalDateTime

package/src/utils/logger.ts

@@ -0,0 +1,61 @@
+import colors from 'picocolors'
+
+const _console = { ...console }
+
+export interface ILogger {
+  write(...data: Array<string | ArrayBufferView | ArrayBuffer>): number;
+  error(...data: any[]): void;
+  info(...data: any[]): void;
+  log(...data: any[]): void;
+  // TODO: table(tabularData?: any, properties?: string[]): void;
+  trace(...data: any[]): void;
+  warn(...data: any[]): void;
+  // custom
+  step(...data: any[]): void;
+  substep(...data: any[]): void;
+  ln(): void;
+}
+
+export const logger = {
+	step(...args: any[]) {
+		if (args?.length && args.length < 2) return _console.log(colors.blue('⁕') +` ${args[0]}\n`)
+		const length = args.length - 1
+		args.forEach((arg, index) => {
+				switch (index) {
+					case 0:
+						return _console.log(colors.blue('⁕') + ' ' + arg)
+						// return _console.log(colors.blue('⁕') +` ${arg} \n`)
+					case length:
+						return _console.log(`   ${colors.gray('⁕')} ${arg}\n`)
+					default:
+						return _console.log(`   ${colors.gray('⁕')} ` + arg)
+				}
+    })
+	},
+	substep(...args: any[]) {
+		args.forEach(arg => _console.log(`   ${colors.gray('⁕')} ` + arg))
+	},
+	ln() {
+		_console.log('\n')
+	},
+  log(...args: any[]) {
+    _console.log(...args)
+  },
+  info(...args: any[]) {
+    _console.info(...args)
+  },
+  warn(...args: any[]) {
+    _console.warn(...args)
+  },
+  error(...args: any[]) {
+    _console.error(...args)
+  },
+  trace(...args: any[]) {
+    _console.trace(...args)
+  },
+  write(...args: any[]) {
+    _console.write(...args)
+  },
+}
+
+export default logger

package/src/utils/port.ts

@@ -18,9 +18,7 @@ export async function getAvailablePort(startPort: number, maxAttempts = 100) {
   while (attempts < maxAttempts) {
     const inUse = await isPortInUse(port)
 
-    if (!inUse) {
-      return port
-    }
+    if (!inUse) return port
 
     port++
     attempts++

package/src/utils/resolve.ts

@@ -2,7 +2,7 @@ import Action, { ActionType } from '../action'
 import { MiddlewareType } from '../middleware'
 
 export function resolve(obj: ActionType, id: string) {
-  if (typeof obj === 'function' && obj?.length === 2)
+  if (typeof obj == 'function' && obj?.length == 2)
     return [obj]
 
   if (obj?.run)
@@ -22,7 +22,7 @@ export function resolve(obj: ActionType, id: string) {
 }
 
 export function resolveMiddleware(obj: MiddlewareType) {
-  if (typeof obj === 'function' && obj.length === 2)
+  if (typeof obj == 'function' && obj.length == 2)
     return obj
 
   if (obj?.factory)

package/src/utils/shutdown.ts

@@ -0,0 +1,19 @@
+export default function shutdown(cb: (signal: string, e: unknown) => void | Promise<void>) {
+  if (!process) return
+  const down = (signal: string) => (e?: unknown) => {
+    try {
+      cb(signal, e)
+      setTimeout(() => process.exit(0), 100)
+    } catch (e) {
+      process.exit(1)
+    }
+  }
+
+  process.on('SIGINT', down('SIGINT'))
+  process.on('SIGTERM', down('SIGTERM'))
+  process.on('SIGHUP', down('SIGHUP'))
+  process.on('unhandledRejection', down('UNCAUGHT_REJECTION'))
+  process.on('uncaughtException', down('UNCAUGHT_EXCEPTION'))
+  // process.on('beforeExit', down('BEFORE_EXIT'))
+  // process.on('exit', down('EXIT'))
+}

package/src/enum.ts

@@ -1,75 +0,0 @@
-type EnumType<T> = T extends string[]
-  ? { [K in T[number]]: K }
-  : T extends Record<string, string | number>
-  ? T
-  : never
-
-type EnumValue<T> = T extends string[]
-  ? T[number]
-  : T extends Record<string, infer V>
-    ? V
-    : never
-
-type EnumStatic<T> = {
-  has(search: string | number): boolean
-  key(search: string | number): string | null
-  value(search: string | number): EnumValue<T> | null
-  readonly keys: string[]
-  readonly values: Array<EnumValue<T>>
-  toObject(): EnumType<T>
-} & EnumType<T>
-
-export default function Enum<T extends string[] | Record<string, string | number>>(definition: T): EnumStatic<T> {
-  const enumObj = Array.isArray(definition)
-    ? Object.fromEntries(definition.map(key => [key, key])) as EnumType<T>
-    : definition as EnumType<T>
-
-  const keyToValueMap = new Map<string | number, string | number>()
-  const valueToKeyMap = new Map<string | number, string>()
-
-  Object.entries(enumObj).forEach(([key, value]) => {
-    keyToValueMap.set(key, value)
-    valueToKeyMap.set(String(value), key)
-    if (typeof value === 'number') valueToKeyMap.set(value.toString(), key)
-  })
-
-  const GeneratedEnum = class {
-    static has(search: string | number): boolean {
-      return keyToValueMap.has(search as string) || valueToKeyMap.has(String(search))
-    }
-
-    static key(search: string | number): string | null {
-      if (keyToValueMap.has(search as string))
-        return search as string
-
-      return valueToKeyMap.get(String(search)) || null
-    }
-
-    static value(search: string | number): EnumValue<T> | null {
-      if (keyToValueMap.has(search as string))
-        return keyToValueMap.get(search as string) as EnumValue<T>
-
-      return valueToKeyMap.has(String(search))
-        ? keyToValueMap.get(valueToKeyMap.get(String(search))!) as EnumValue<T>
-        : null
-    }
-
-    static get keys(): string[] {
-      return Object.keys(enumObj)
-    }
-
-    static get values(): Array<EnumValue<T>> {
-      return Object.values(enumObj) as Array<EnumValue<T>>
-    }
-
-    static toObject(): EnumType<T> {
-      return { ...enumObj }
-    }
-  }
-
-  Object.entries(enumObj).forEach(([key, value]) => {
-    (GeneratedEnum as any)[key] = value
-  })
-
-  return GeneratedEnum as unknown as EnumStatic<T>
-}

package/src/utils/lenght.ts

@@ -1,32 +0,0 @@
-export default function getLength(item: any, type?: string): number {
-  if (!type) type = typeof item
-
-  switch (type) {
-    case 'string':
-      return item.length
-
-    case 'number':
-    case 'bigint':
-    // case 'function':
-      return item.toString().length
-
-    // case 'boolean':
-    //   return item ? 1 : 0
-
-    // case 'symbol':
-    //   return item.toString().length - 8
-
-    case 'object':
-      if (item === null)
-        return 0
-
-      if (Array.isArray(item))
-        return item.length
-
-      return Object.keys(item).length
-
-    case 'undefined':
-    default:
-      return 0
-  }
-}