logixlysia 3.1.0 → 3.3.0

package/.prettierrc

@@ -0,0 +1,9 @@
+{
+  "arrowParens": "avoid",
+  "singleQuote": true,
+  "bracketSpacing": true,
+  "endOfLine": "lf",
+  "semi": false,
+  "tabWidth": 2,
+  "trailingComma": "none"
+}

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [3.3.0](https://github.com/PunGrumpy/logixlysia/compare/v3.2.0...v3.3.0) (2024-05-22)
+
+
+### Features
+
+* **color:** new color for methods (matching Postman color) ([0528886](https://github.com/PunGrumpy/logixlysia/commit/0528886ef9fdaa466e4b78b46fb09d31731b0520))
+
+## [3.2.0](https://github.com/PunGrumpy/logixlysia/compare/v3.1.0...v3.2.0) (2024-05-07)
+
+
+### Features
+
+* update logger function name for clarity ([9badffc](https://github.com/PunGrumpy/logixlysia/commit/9badffc286fc13feda9eeffd28881990ae437c9f))
+
 ## [3.1.0](https://github.com/PunGrumpy/logixlysia/compare/v3.0.2...v3.1.0) (2024-04-09)
 
 

package/README.md

@@ -14,15 +14,22 @@ bun add logixlysia
 
 ```ts
 import { Elysia } from 'elysia'
-import { logger } from 'logixlysia'
+import { logixlysia } from 'logixlysia'
 
 const app = new Elysia({
   name: 'Logixlysia Example'
 }).use(
-  logger({
-    ip: false,
-    customLogMessage:
-      '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}'
+  logixlysia({
+    config: {
+      ip: true,
+      customLogFormat:
+        '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}',
+      logFilter: {
+        level: ['ERROR', 'WARNING'],
+        status: [500, 404],
+        method: 'GET'
+      }
+    }
   })
 )
 

package/eslint.config.js

@@ -0,0 +1,25 @@
+import pluginJs from '@eslint/js'
+import eslintPlugin from '@typescript-eslint/eslint-plugin'
+import eslintPluginSimpleImportSort from 'eslint-plugin-simple-import-sort'
+import globals from 'globals'
+import tseslint from 'typescript-eslint'
+
+export default [
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    languageOptions: {
+      globals: globals.browser
+    },
+    plugins: {
+      '@typescript-eslint': eslintPlugin,
+      'simple-import-sort': eslintPluginSimpleImportSort
+    },
+    rules: {
+      'no-undef': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+      'simple-import-sort/imports': 'error',
+      'simple-import-sort/exports': 'error'
+    }
+  }
+]

package/lint-staged.config.cjs

@@ -1,27 +1,8 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-const { existsSync } = require('fs')
-const { join } = require('path')
-
-const isBun = existsSync(join(process.cwd(), 'bun.lockb'))
-const isYarn = existsSync(join(process.cwd(), 'yarn.lock'))
-const isPnpm = existsSync(join(process.cwd(), 'pnpm-lock.yaml'))
-
-const packageManager = isBun ? 'bun' : isYarn ? 'yarn' : isPnpm ? 'pnpm' : 'npm'
-
-const options = {
-  // TypeScript & JavaScript files
-  '**/*.(ts|tsx)': () => `${packageManager} tsc --noEmit`,
-  '**/*.(ts|tsx|js)': filenames => [
-    `${packageManager} eslint --fix ${filenames.join(' ')}`,
-    `${packageManager} prettier --write ${filenames.join(' ')}`
+module.exports = {
+  '**/*.(ts)': () => `bun tsc --noEmit`,
+  '**/*.(ts|js|cjs)': filenames => [
+    `bun eslint --fix ${filenames.join(' ')}`,
+    `bun prettier --write ${filenames.join(' ')}`
   ],
-  '**/*.(css|less|scss)': filenames =>
-    `${packageManager} test --timeout 5000 --coverage --update-snapshots ${filenames.join(
-      ' '
-    )}`,
-  // Markdown & JSON files
-  '**/*.(md|json)': filenames =>
-    `${packageManager} prettier --write ${filenames.join(' ')}`
+  '**/*.(md|json)': filenames => `bun prettier --write ${filenames.join(' ')}`
 }
-
-module.exports = options

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -15,8 +15,8 @@
   },
   "license": "MIT",
   "scripts": {
-    "lint": "eslint **/*.ts --no-warn-ignored",
-    "lint:fix": "eslint **/*.ts --fix --no-warn-ignored",
+    "lint": "eslint ..",
+    "lint:fix": "eslint .. --fix",
     "test": "bun test --timeout 5000 --coverage",
     "test:ci": "bun test --timeout 5000 --coverage",
     "publish": "npm publish",
@@ -68,20 +68,23 @@
     "middleware"
   ],
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "^7.0.0",
-    "@typescript-eslint/parser": "^7.0.2",
+    "@eslint/js": "^9.3.0",
+    "@typescript-eslint/eslint-plugin": "^7.10.0",
+    "@typescript-eslint/parser": "^7.10.0",
     "chalk": "^5.3.0",
-    "elysia": "^1.0.4",
-    "eslint": "^9.0.0"
+    "elysia": "^1.0.21",
+    "eslint": "9.x",
+    "eslint-plugin-simple-import-sort": "^12.1.0",
+    "typescript-eslint": "^7.10.0"
   },
   "devDependencies": {
-    "@elysiajs/eden": "^1.0.4",
-    "bun-types": "^1.0.22",
+    "@elysiajs/eden": "^1.0.13",
+    "bun-types": "^1.1.9",
     "commitizen": "^4.3.0",
     "cz-conventional-changelog": "^3.3.0",
-    "husky": "^9.0.7",
-    "lint-staged": "^15.2.0",
-    "prettier": "^3.1.1"
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.4",
+    "prettier": "^3.2.5"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/index.ts

@@ -1,8 +1,10 @@
-import Elysia from 'elysia'
-import { createLogger, handleHttpError } from './logger'
-import startString from './utils/start'
 import { Server } from 'bun'
+import Elysia from 'elysia'
+
+import { createLogger } from './logger'
+import { handleHttpError } from './logger/handle'
 import { HttpError, Options } from './types'
+import startServer from './utils/start'
 
 /**
  * Creates a logger.
@@ -19,14 +21,14 @@ import { HttpError, Options } from './types'
  *
  * @returns {Elysia} The logger.
  */
-export const logger = (options?: Options): Elysia => {
+export default function logixlysia(options?: Options): Elysia {
   const log = createLogger(options)
 
   const elysia = new Elysia({
     name: 'Logixlysia'
   })
     .onStart(ctx => {
-      startString(ctx.server as Server)
+      startServer(ctx.server as Server)
     })
     .onRequest(ctx => {
       ctx.store = { beforeTime: process.hrtime.bigint() }

package/src/logger/filter.ts

@@ -0,0 +1,49 @@
+import { LogLevel, Options } from '~/types'
+
+/**
+ * Filters log messages.
+ *
+ * @param {LogLevel} logLevel The log level.
+ * @param {number} status The status code.
+ * @param {string} method The method.
+ * @param {Options} options The options.
+ * @returns {boolean} `true` if the log message should be logged, otherwise `false`.
+ */
+function filterLog(
+  logLevel: LogLevel,
+  status: number,
+  method: string,
+  options?: Options
+): boolean {
+  const filter = options?.config?.logFilter
+
+  if (!filter) return true
+
+  if (filter.level) {
+    if (Array.isArray(filter.level)) {
+      if (!filter.level.includes(logLevel)) return false
+    } else {
+      if (filter.level !== logLevel) return false
+    }
+  }
+
+  if (filter.status) {
+    if (Array.isArray(filter.status)) {
+      if (!filter.status.includes(status)) return false
+    } else {
+      if (filter.status !== status) return false
+    }
+  }
+
+  if (filter.method) {
+    if (Array.isArray(filter.method)) {
+      if (!filter.method.includes(method)) return false
+    } else {
+      if (filter.method !== method) return false
+    }
+  }
+
+  return true
+}
+
+export { filterLog }

package/src/logger/handle.ts

@@ -0,0 +1,30 @@
+import { HttpError, Options, RequestInfo, StoreData } from '~/types'
+
+import { buildLogMessage } from '.'
+
+/**
+ * Handles an HTTP error.
+ *
+ * @param {RequestInfo} request The request.
+ * @param {HttpError} error The HTTP error.
+ * @param {StoreData} store The store data.
+ * @param {Options} options The options.
+ */
+function handleHttpError(
+  request: RequestInfo,
+  error: HttpError,
+  store: StoreData,
+  options?: Options
+): void {
+  const statusCode = error.status || 500
+  const logMessage = buildLogMessage(
+    'ERROR',
+    request,
+    { status: statusCode },
+    store,
+    options
+  )
+  console.error(logMessage)
+}
+
+export { handleHttpError }

package/src/{logger.ts → logger/index.ts}

@@ -1,67 +1,20 @@
 import chalk from 'chalk'
-import durationString from './utils/duration'
-import methodString from './utils/method'
-import logString from './utils/log'
-import pathString from './utils/path'
-import statusString from './utils/status'
+
 import {
-  LogLevel,
   LogData,
   Logger,
-  StoreData,
+  LogLevel,
   Options,
   RequestInfo,
-  HttpError
-} from './types'
+  StoreData
+} from '~/types'
+import durationString from '~/utils/duration'
+import logString from '~/utils/log'
+import methodString from '~/utils/method'
+import pathString from '~/utils/path'
+import statusString from '~/utils/status'
 
-/**
- * Filters log messages.
- *
- * @param {LogLevel} logLevel The log level.
- * @param {number} status The status code.
- * @param {string} method The method.
- * @param {Options} options The options.
- * @returns {boolean} `true` if the log message should be logged, otherwise `false`.
- */
-function filterLog(
-  logLevel: LogLevel,
-  status: number,
-  method: string,
-  options?: Options
-): boolean {
-  const filter = options?.config?.logFilter
-
-  if (!filter) return true
-
-  // Level
-  if (filter.level) {
-    if (Array.isArray(filter.level)) {
-      if (!filter.level.includes(logLevel)) return false
-    }
-  } else {
-    if (filter.level !== logLevel) return false
-  }
-
-  // Status
-  if (filter.status) {
-    if (Array.isArray(filter.status)) {
-      if (!filter.status.includes(status)) return false
-    }
-  } else {
-    if (filter.status !== status) return false
-  }
-
-  // Method
-  if (filter.method) {
-    if (Array.isArray(filter.method)) {
-      if (!filter.method.includes(method)) return false
-    }
-  } else {
-    if (filter.method !== method) return false
-  }
-
-  return true
-}
+import { filterLog } from './filter'
 
 /**
  * Logs a message.
@@ -138,33 +91,12 @@ function buildLogMessage(
  * @param {Options} options The options.
  * @returns {Logger} The logger.
  */
-export const createLogger = (options?: Options): Logger => ({
-  log: (level, request, data, store) =>
-    log(level, request, data, store, options),
-  customLogFormat: options?.config?.customLogFormat
-})
-
-/**
- * Handles an HTTP error.
- *
- * @param {RequestInfo} request The request.
- * @param {HttpError} error The HTTP error.
- * @param {StoreData} store The store data.
- * @param {Options} options The options.
- */
-export const handleHttpError = (
-  request: RequestInfo,
-  error: HttpError,
-  store: StoreData,
-  options?: Options
-): void => {
-  const statusCode = error.status || 500
-  const logMessage = buildLogMessage(
-    'ERROR',
-    request,
-    { status: statusCode },
-    store,
-    options
-  )
-  console.error(logMessage)
+function createLogger(options?: Options): Logger {
+  return {
+    log: (level, request, data, store) =>
+      log(level, request, data, store, options),
+    customLogFormat: options?.config?.customLogFormat
+  }
 }
+
+export { buildLogMessage, createLogger, log }

package/src/types.ts

@@ -1,5 +1,5 @@
 interface RequestInfo {
-  headers: { get: (key: string) => any }
+  headers: { get: (key: string) => string | null }
   method: string
   url: string
 }
@@ -57,13 +57,13 @@ interface Options {
 }
 
 export {
-  RequestInfo,
-  Server,
   ColorMap,
-  LogLevel,
+  HttpError,
   LogData,
   Logger,
-  StoreData,
-  HttpError,
-  Options
+  LogLevel,
+  Options,
+  RequestInfo,
+  Server,
+  StoreData
 }

package/src/utils/colorMapping.ts

@@ -1,4 +1,5 @@
 import chalk from 'chalk'
+
 import { ColorMap } from '~/types'
 
 /**
@@ -22,19 +23,19 @@ const LogLevelColorMap: ColorMap = {
  * @property {chalk.Chalk} GET The color for the GET HTTP method.
  * @property {chalk.Chalk} POST The color for the POST HTTP method.
  * @property {chalk.Chalk} PUT The color for the PUT HTTP method.
- * @property {chalk.Chalk} DELETE The color for the DELETE HTTP method.
  * @property {chalk.Chalk} PATCH The color for the PATCH HTTP method.
- * @property {chalk.Chalk} OPTIONS The color for the OPTIONS HTTP method.
+ * @property {chalk.Chalk} DELETE The color for the DELETE HTTP method.
  * @property {chalk.Chalk} HEAD The color for the HEAD HTTP method.
+ * @property {chalk.Chalk} OPTIONS The color for the OPTIONS HTTP method.
  */
 const HttpMethodColorMap: ColorMap = {
-  GET: chalk.white,
+  GET: chalk.green,
   POST: chalk.yellow,
   PUT: chalk.blue,
+  PATCH: chalk.magentaBright,
   DELETE: chalk.red,
-  PATCH: chalk.green,
-  OPTIONS: chalk.cyan,
-  HEAD: chalk.magenta
+  HEAD: chalk.cyan,
+  OPTIONS: chalk.magenta
 }
 
-export { LogLevelColorMap, HttpMethodColorMap }
+export { HttpMethodColorMap, LogLevelColorMap }

package/src/utils/log.ts

@@ -1,20 +1,16 @@
+import { LogLevel } from '~/types'
+
 import { LogLevelColorMap } from './colorMapping'
 
 /**
- * Converts a log level to a colored string representation.
- *
- * @param {string} log The log level (e.g., 'INFO', 'WARNING').
+ * Converts the log level to a string.
  *
- * @returns {string} A colored string representing the log level.
+ * @param {LogLevel} level The log level.
+ * @returns {string} The log level as a string.
  */
-function logString(log: string): string {
-  const colorFunction = LogLevelColorMap[log]
-
-  if (colorFunction) {
-    return colorFunction(log.padEnd(7))
-  }
-
-  return log
+function logString(level: LogLevel): string {
+  const levelStr = level.toUpperCase()
+  return LogLevelColorMap[levelStr]?.(levelStr.padEnd(7)) || levelStr
 }
 
 export default logString

package/src/utils/start.ts

@@ -21,7 +21,7 @@ function createBoxText(text: string, width: number): string {
  *
  * @returns {void} The server string.
  */
-function startString(config: Server): void {
+function startServer(config: Server): void {
   const { hostname, port, protocol } = config
   const ELYSIA_VERSION = import.meta.require('elysia/package.json').version
   const title = `Elysia v${ELYSIA_VERSION}`
@@ -41,4 +41,4 @@ function startString(config: Server): void {
     `)
 }
 
-export default startString
+export default startServer

package/src/utils/status.ts

@@ -1,25 +1,24 @@
 import chalk from 'chalk'
 
 /**
- * Returns the status string.
+ * Converts the status code to a string.
  *
  * @param {number} status The status code.
  *
- * @returns {string} The status string.
+ * @returns {string} The status code as a string.
  */
 function statusString(status: number): string {
-  switch (true) {
-    case status >= 500:
-      return chalk.red(status.toString())
-    case status >= 400:
-      return chalk.yellow(status.toString())
-    case status >= 300:
-      return chalk.cyan(status.toString())
-    case status >= 200:
-      return chalk.green(status.toString())
-    default:
-      return status.toString()
-  }
+  const color =
+    status >= 500
+      ? 'red'
+      : status >= 400
+        ? 'yellow'
+        : status >= 300
+          ? 'cyan'
+          : status >= 200
+            ? 'green'
+            : 'white'
+  return chalk[color](status.toString())
 }
 
 export default statusString

package/test/logger/filter.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'bun:test'
+
+import { filterLog } from '~/logger/filter'
+import { LogLevel, Options } from '~/types'
+
+describe('filterLog', () => {
+  const logLevel: LogLevel = 'info'
+  const status = 200
+  const method = 'GET'
+
+  it('should return true if no filter is provided', () => {
+    expect(filterLog(logLevel, status, method)).toBe(true)
+  })
+
+  it('should filter by log level (single value)', () => {
+    const options: Options = { config: { logFilter: { level: 'error' } } }
+    expect(filterLog(logLevel, status, method, options)).toBe(false)
+  })
+
+  it('should filter by log level (array)', () => {
+    const options: Options = {
+      config: { logFilter: { level: ['error', 'info'] } }
+    }
+    expect(filterLog(logLevel, status, method, options)).toBe(true)
+  })
+
+  it('should filter by status (single value)', () => {
+    const options: Options = { config: { logFilter: { status: 404 } } }
+    expect(filterLog(logLevel, status, method, options)).toBe(false)
+  })
+
+  it('should filter by status (array)', () => {
+    const options: Options = { config: { logFilter: { status: [200, 404] } } }
+    expect(filterLog(logLevel, status, method, options)).toBe(true)
+  })
+
+  it('should filter by method (single value)', () => {
+    const options: Options = { config: { logFilter: { method: 'POST' } } }
+    expect(filterLog(logLevel, status, method, options)).toBe(false)
+  })
+
+  it('should filter by method (array)', () => {
+    const options: Options = {
+      config: { logFilter: { method: ['GET', 'POST'] } }
+    }
+    expect(filterLog(logLevel, status, method, options)).toBe(true)
+  })
+
+  it('should return false if any filter condition is not met', () => {
+    const options: Options = {
+      config: { logFilter: { level: 'info', status: 404, method: 'POST' } }
+    }
+    expect(filterLog(logLevel, status, method, options)).toBe(false)
+  })
+
+  it('should return true if all filter conditions are met', () => {
+    const options: Options = {
+      config: { logFilter: { level: 'info', status: 200, method: 'GET' } }
+    }
+    expect(filterLog(logLevel, status, method, options)).toBe(true)
+  })
+})

package/test/logixlysia.test.ts

@@ -1,17 +1,18 @@
-import { Elysia } from 'elysia'
 import { edenTreaty } from '@elysiajs/eden'
-import { describe, it, expect, beforeAll, beforeEach } from 'bun:test'
-import { logger } from '../src'
+import { beforeAll, beforeEach, describe, expect, it } from 'bun:test'
+import { Elysia } from 'elysia'
+
+import logixlysia from '../src'
 
 describe('Logixlysia with IP logging enabled', () => {
   let server: Elysia
-  let app: any
+  let app: ReturnType<typeof edenTreaty> | any
   let logs: string[] = []
 
   beforeAll(() => {
     server = new Elysia()
       .use(
-        logger({
+        logixlysia({
           config: {
             ip: true,
             customLogFormat:
@@ -19,8 +20,7 @@ describe('Logixlysia with IP logging enabled', () => {
           }
         })
       )
-      .get('/', ctx => {
-        const ipAddress = ctx.request.headers.get('x-forwarded-for') || 'null'
+      .get('/', () => {
         return '🦊 Logixlysia Getting'
       })
       .post('logixlysia', () => '🦊 Logixlysia Posting')
@@ -50,12 +50,6 @@ describe('Logixlysia with IP logging enabled', () => {
   })
 
   it("Logs 'null' for GET '/' requests when X-Forwarded-For header is not present", async () => {
-    const requestCount = 5
-
-    for (let i = 0; i < requestCount; i++) {
-      const response = await app.get('/')
-    }
-
     logs.forEach(log => {
       expect(log).toMatch(/^🦊 .+ INFO .+ .+ GET \/ .+ IP: null$/)
     })
@@ -64,13 +58,13 @@ describe('Logixlysia with IP logging enabled', () => {
 
 describe('Logixlysia with IP logging disabled', () => {
   let server: Elysia
-  let app: any
+  let app: ReturnType<typeof edenTreaty> | any
   let logs: string[] = []
 
   beforeAll(() => {
     server = new Elysia()
       .use(
-        logger({
+        logixlysia({
           config: {
             ip: false,
             customLogFormat:
@@ -127,13 +121,13 @@ describe('Logixlysia with IP logging disabled', () => {
 
 describe('Logixlysia with log filtering enabled', () => {
   let server: Elysia
-  let app: any
+  let app: ReturnType<typeof edenTreaty> | any
   let logs: string[] = []
 
   beforeAll(() => {
     server = new Elysia()
       .use(
-        logger({
+        logixlysia({
           config: {
             logFilter: {
               level: 'INFO',
@@ -193,13 +187,13 @@ describe('Logixlysia with log filtering enabled', () => {
 
 describe('Logixlysia with log filtering disabled', () => {
   let server: Elysia
-  let app: any
+  let app: ReturnType<typeof edenTreaty> | any
   let logs: string[] = []
 
   beforeAll(() => {
     server = new Elysia()
       .use(
-        logger({
+        logixlysia({
           config: {
             logFilter: null
           }

package/test/types/ColorMap.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'bun:test'
+
 import { ColorMap } from '~/types'
 
 describe('Color Mapping Interface', () => {

package/test/types/HttpError.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'bun:test'
+
 import { HttpError } from '~/types'
 
 describe('HttpError', () => {

package/test/types/Logger.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, jest } from 'bun:test'
-import { RequestInfo, LogData, StoreData } from '~/types'
+
+import { LogData, RequestInfo, StoreData } from '~/types'
 
 interface Logger {
   info(request: RequestInfo, data: LogData, store: StoreData): void

package/test/types/RequestInfo.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'bun:test'
+
 import { RequestInfo } from '~/types'
 
 describe('Request Infomation interface', () => {

package/test/types/Server.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'bun:test'
+
 import { Server } from '~/types'
 
 describe('Server interface', () => {

package/test/types/StoreData.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'bun:test'
+
 import { StoreData } from '~/types'
 
 describe('Store Data interface', () => {

package/test/utils/duration.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'bun:test'
+
 import durationString from '~/utils/duration'
 
 describe('Duration String', () => {

package/test/utils/log.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'bun:test'
 import chalk from 'chalk'
+
 import logString from '~/utils/log'
 
 describe('Log String', () => {

package/test/utils/method.test.ts

@@ -1,11 +1,12 @@
 import { describe, expect, it } from 'bun:test'
 import chalk from 'chalk'
+
 import methodString from '~/utils/method'
 
 describe('Method String', () => {
   it('Displays a colored string for the GET method', () => {
     const result = methodString('GET')
-    expect(result).toBe(chalk.white('GET    '))
+    expect(result).toBe(chalk.green('GET    '))
   })
 
   it('Displays a colored string for the POST method', () => {

package/test/utils/path.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'bun:test'
+
 import { RequestInfo } from '~/types'
 import pathString from '~/utils/path'
 

package/test/utils/start.test.ts

@@ -1,9 +1,10 @@
 import { afterEach, beforeEach, describe, expect, it, jest } from 'bun:test'
+
 import { Server } from '~/types'
-import startString from '~/utils/start'
+import startServer from '~/utils/start'
 
 describe('Start String', () => {
-  let originalConsoleLog: any
+  let originalConsoleLog: typeof console.log
   let mockConsoleLog: jest.Mock
 
   beforeEach(() => {
@@ -23,13 +24,13 @@ describe('Start String', () => {
       protocol: 'http'
     }
 
-    startString(config)
+    startServer(config)
 
     const expectedMessage = `🦊 Elysia is running at http://localhost:3000`
 
     // Extract the arguments passed to console.log during the function call
     const logMessage = mockConsoleLog.mock.calls
-      .map((args: any[]) => args.join(' '))
+      .map(args => args.join(' '))
       .join(' ')
 
     expect(logMessage).toMatch(expectedMessage)

package/test/utils/status.test.ts

@@ -1,5 +1,6 @@
-import chalk from 'chalk'
 import { describe, expect, it } from 'bun:test'
+import chalk from 'chalk'
+
 import statusString from '~/utils/status'
 
 describe('Status String', () => {
@@ -8,23 +9,23 @@ describe('Status String', () => {
     expect(result).toBe(chalk.green('200'))
   })
 
-  it('Presents the status string in green for a 301 status code', () => {
+  it('Presents the status string in cyan for a 301 status code', () => {
     const result = statusString(301)
     expect(result).toBe(chalk.cyan('301'))
   })
 
-  it('Presents the status string in green for a 404 status code', () => {
+  it('Presents the status string in yellow for a 404 status code', () => {
     const result = statusString(404)
     expect(result).toBe(chalk.yellow('404'))
   })
 
-  it('Presents the status string in green for a 500 status code', () => {
+  it('Presents the status string in red for a 500 status code', () => {
     const result = statusString(500)
     expect(result).toBe(chalk.red('500'))
   })
 
-  it('Presents the status string in green for a 100 status code', () => {
+  it('Presents the status string in white for a 100 status code', () => {
     const result = statusString(100)
-    expect(result).toBe('100')
+    expect(result).toBe(chalk.white('100'))
   })
 })

package/eslint.config.cjs

@@ -1,25 +0,0 @@
-module.exports = {
-  env: {
-    es2021: true,
-    node: true
-  },
-  extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module'
-  },
-  plugins: ['@typescript-eslint'],
-  rules: {
-    '@typescript-eslint/ban-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-    'no-mixed-spaces-and-tabs': 'off',
-    '@typescript-eslint/no-non-null-assertion': 'off',
-    '@typescript-eslint/no-extra-semi': 'off',
-    '@typescript-eslint/ban-ts-comment': 'off',
-    '@typescript-eslint/no-namespace': 'off',
-    'no-case-declarations': 'off',
-    'no-extra-semi': 'off'
-  },
-  ignorePatterns: ['example/*', 'tests/**/*', 'lint-staged.config.js']
-}

package/prettier.config.cjs

@@ -1,11 +0,0 @@
-const options = {
-  arrowParens: 'avoid',
-  singleQuote: true,
-  bracketSpacing: true,
-  endOfLine: 'lf',
-  semi: false,
-  tabWidth: 2,
-  trailingComma: 'none'
-}
-
-module.exports = options