@knowark/loggarkjs 0.3.10 → 0.4.0

package/README.md

@@ -1,2 +1,52 @@
 # loggark
 Utilitarian Logging Library
+
+## Logger output format
+
+`Logger` now emits a single JSON object per log line by default (JSON Lines). This format is easier to consume with `journalctl` pipelines (`jq`, `grep`, field selection).
+
+- Default: `format: 'json'`
+- Backward compatibility: `format: 'plain'`
+- Context flattening in JSON mode: `flat: true` (default)
+
+Example:
+
+```js
+import { Logger } from '@knowark/loggarkjs'
+
+const logger = new Logger({ namespace: 'api' })
+logger.info('User login', { userId: 'u-123' })
+```
+
+Outputs:
+
+```json
+{"timestamp":"2025-02-15T00:00:00.000Z","level":"info","namespace":"api","message":"User login","userId":"u-123"}
+```
+
+Additional object parameters are merged into the base log object. If keys collide, later merged values overwrite earlier keys.
+
+If you prefer context keys at top level (for simpler `jq` filters), enable flattening:
+
+```js
+const logger = new Logger({
+  namespace: 'api',
+  context: { correlationId: 'ABCD1234', interactor: 'Informer' },
+  flat: true
+})
+
+logger.info('User login')
+```
+
+```json
+{"timestamp":"2025-02-15T00:00:00.000Z","level":"info","namespace":"api","correlationId":"ABCD1234","interactor":"Informer","message":"User login"}
+```
+
+To keep nested context under `context`, disable flattening:
+
+```js
+const logger = new Logger({
+  context: { correlationId: 'ABCD1234' },
+  flat: false
+})
+```

package/lib/index.d.ts

@@ -4,7 +4,9 @@ export declare class Logger {
   constructor (dependencies?: {
     namespace?: string,
     context?: object,
-    global?: object
+    global?: object,
+    format?: 'json' | 'plain',
+    flat?: boolean
   })
 
   context?: object | null
@@ -32,4 +34,6 @@ export declare class Translator {
   t(key: string, options?: object): string
 }
 
-export declare function t(key: string, options?: object): string
+export declare function t(key: string, options?: object): string
+
+export declare function lt(key: string, options?: object): () => string

package/lib/logger.js

@@ -5,8 +5,11 @@ export class Logger {
 
   #context = {}
 
-  constructor ({ namespace = '', context = null, global = globalThis } = {}) {
+  constructor ({ namespace = '', context = null, global = globalThis, format = 'json', flat = true } = {}) {
     this.levels = ['error', 'warn', 'info', 'debug']
+    this.namespace = namespace
+    this.format = format
+    this.flat = flat
     this.logvar = [namespace, 'LOGLEVEL'].filter(
       Boolean).join('_').toUpperCase().replaceAll(' ', '_')
     this.global = global
@@ -24,28 +27,91 @@ export class Logger {
   }
 
   log (...args) {
-    if (this.logindex >= 0) log(this.global, 'log', this.context, args)
+    if (this.logindex >= 0) log(this.global, 'log', this.context, args, this.namespace, this.format, this.flat)
   }
 
   error (...args) {
-    if (this.logindex >= 0) log(this.global, 'error', this.context, args) 
+    if (this.logindex >= 0) log(this.global, 'error', this.context, args, this.namespace, this.format, this.flat)
   }
 
   warn (...args) {
-    if (this.logindex >= 1) log(this.global, 'warn', this.context, args)
+    if (this.logindex >= 1) log(this.global, 'warn', this.context, args, this.namespace, this.format, this.flat)
   }
 
   info (...args) {
-    if (this.logindex >= 2) log(this.global, 'info', this.context, args)
+    if (this.logindex >= 2) log(this.global, 'info', this.context, args, this.namespace, this.format, this.flat)
   }
 
   debug (...args) {
-    if (this.logindex >= 3) log(this.global, 'debug', this.context, args)
+    if (this.logindex >= 3) log(this.global, 'debug', this.context, args, this.namespace, this.format, this.flat)
   }
 }
 
-function log (global, level, context, args) {
-  return global.console[level](
-  `${new global.Date().toISOString()} [${level.toUpperCase()}]`,
-  ...[context ? JSON.stringify(context) : false, ...args].filter(Boolean))
-}
+function parseArgs (args) {
+  const payload = {}
+
+  args.forEach((value, index) => {
+    if (index === 0 && typeof value === 'string') {
+      payload.message = value
+      return
+    }
+
+    Object.assign(payload, toLogFields(value, index))
+  })
+
+  return payload
+}
+
+function toLogFields (value, index) {
+  if (value instanceof Error) return toSerializableError(value)
+  if (value && typeof value === 'object' && !Array.isArray(value)) return value
+  return { [`arg${index}`]: value }
+}
+
+function toSerializableError (error) {
+  return {
+    name: error.name,
+    message: error.message,
+    stack: error.stack,
+    ...error
+  }
+}
+
+function stringifyJson (payload) {
+  const seen = new WeakSet()
+  return JSON.stringify(payload, (_key, value) => {
+    if (typeof value === 'bigint') return value.toString()
+    if (typeof value === 'function') return `[Function ${value.name || 'anonymous'}]`
+    if (typeof value === 'symbol') return value.toString()
+    if (value instanceof Error) return toSerializableError(value)
+
+    if (value && typeof value === 'object') {
+      if (seen.has(value)) return '[Circular]'
+      seen.add(value)
+    }
+
+    return value
+  })
+}
+
+function log (global, level, context, args, namespace, format, flat) {
+  const timestamp = new global.Date().toISOString()
+
+  if (format === 'plain') {
+    const message = [`${timestamp} [${level.toUpperCase()}]`]
+    if (context) message.push(stringifyJson(context))
+    message.push(...args)
+    return global.console[level](...message)
+  }
+
+  const record = {
+    ...(flat && context ? context : {}),
+    timestamp,
+    level,
+    ...(namespace ? { namespace } : {}),
+    ...(!flat && context ? { context } : {}),
+    ...parseArgs(args)
+  }
+
+  return global.console[level](stringifyJson(record))
+}

package/lib/logger.test.js

@@ -1,4 +1,5 @@
-import { it, expect } from '@jest/globals'
+import assert from 'node:assert/strict'
+import { it } from 'node:test'
 import { Logger } from './logger.js'
 
 function setup () {
@@ -11,22 +12,29 @@ function setup () {
       debug (...args) { mockGlobal.debugArgs = args }
     },
     Date: class {
-      toISOString() {
+      toISOString () {
         return new Date('2025-02-15').toISOString()
       }
     }
   }
-  return {mockGlobal}
+
+  return { mockGlobal }
+}
+
+function parseRecord (args) {
+  assert.ok(args)
+  assert.strictEqual(args.length, 1)
+  return JSON.parse(args[0])
 }
 
 it('can be instantiated', () => {
   const logger = new Logger()
-  expect(logger).toBeTruthy()
+  assert.ok(logger)
 })
 
-it('can be instantiated', () => {
+it('returns null context when no static or instance context is available', () => {
   const logger = new Logger()
-  expect(logger).toBeTruthy()
+  assert.strictEqual(logger.context, null)
 })
 
 it('is disabled by default', () => {
@@ -34,98 +42,353 @@ it('is disabled by default', () => {
   const logger = new Logger({ global: mockGlobal })
 
   logger.log('Logging something...')
-  expect(mockGlobal.logArgs).toBeFalsy()
+  assert.ok(!mockGlobal.logArgs)
 
   logger.error('Logging something...')
-  expect(mockGlobal.errorArgs).toBeFalsy()
+  assert.ok(!mockGlobal.errorArgs)
 
   logger.warn('Logging something...')
-  expect(mockGlobal.warnArgs).toBeFalsy()
+  assert.ok(!mockGlobal.warnArgs)
 
   logger.info('Logging something...')
-  expect(mockGlobal.infoArgs).toBeFalsy()
+  assert.ok(!mockGlobal.infoArgs)
 
   logger.debug('Logging something...')
-  expect(mockGlobal.debugArgs).toBeFalsy()
+  assert.ok(!mockGlobal.debugArgs)
 })
 
-it('adds a prefix to the logging methods according to loglevel', () => {
+it('emits JSON logs by default according to loglevel', () => {
   const { mockGlobal } = setup()
   mockGlobal.LOGLEVEL = 'debug'
   const logger = new Logger({ global: mockGlobal })
 
   logger.log('Logging something...')
-  expect(mockGlobal.logArgs).toEqual(
-    ['2025-02-15T00:00:00.000Z [LOG]', 'Logging something...'])
+  assert.deepStrictEqual(parseRecord(mockGlobal.logArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'log',
+    message: 'Logging something...'
+  })
 
   logger.error('Logging something...')
-  expect(mockGlobal.errorArgs).toEqual(
-    ['2025-02-15T00:00:00.000Z [ERROR]', 'Logging something...'])
+  assert.deepStrictEqual(parseRecord(mockGlobal.errorArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'error',
+    message: 'Logging something...'
+  })
 
   logger.warn('Logging something...')
-  expect(mockGlobal.warnArgs).toEqual(
-    ['2025-02-15T00:00:00.000Z [WARN]', 'Logging something...'])
+  assert.deepStrictEqual(parseRecord(mockGlobal.warnArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'warn',
+    message: 'Logging something...'
+  })
 
   logger.info('Logging something...')
-  expect(mockGlobal.infoArgs).toEqual(
-    ['2025-02-15T00:00:00.000Z [INFO]', 'Logging something...'])
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    message: 'Logging something...'
+  })
 
   logger.debug('Logging something...')
-  expect(mockGlobal.debugArgs).toEqual(
-    ['2025-02-15T00:00:00.000Z [DEBUG]', 'Logging something...'])
+  assert.deepStrictEqual(parseRecord(mockGlobal.debugArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'debug',
+    message: 'Logging something...'
+  })
+})
+
+it('merges object parameters into the base JSON log object', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal })
+
+  logger.info('Logging something...', { action: 'create', entity: 'product' })
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    message: 'Logging something...',
+    action: 'create',
+    entity: 'product'
+  })
 })
 
-it('adds the provided logging context labels to its final output', () => {
+it('can emit JSON logs without message arguments', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal })
+
+  logger.info()
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info'
+  })
+})
+
+it('can emit JSON logs without context when flat is disabled', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal, flat: false })
+
+  logger.info('Logging something...')
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    message: 'Logging something...'
+  })
+})
+
+it('flattens provided logging context labels by default', () => {
   const { mockGlobal } = setup()
   mockGlobal.LOGLEVEL = 'debug'
   const context = { correlationId: 'ABCD1234', interactor: 'Informer' }
   const logger = new Logger({ global: mockGlobal, context })
 
-  logger.log('Logging something...')
-  expect(mockGlobal.logArgs).toEqual([
-    '2025-02-15T00:00:00.000Z [LOG]',
-    JSON.stringify({ correlationId: 'ABCD1234', interactor: 'Informer' }),
-    'Logging something...'])
+  logger.info('Logging something...')
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    correlationId: 'ABCD1234',
+    interactor: 'Informer',
+    message: 'Logging something...'
+  })
+})
 
-  logger.error('Logging something...')
-  expect(mockGlobal.errorArgs).toEqual([
-    '2025-02-15T00:00:00.000Z [ERROR]', 
-    JSON.stringify({ correlationId: 'ABCD1234', interactor: 'Informer' }),
-    'Logging something...'])
+it('can flatten context labels into top-level JSON fields with flat option', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const context = { correlationId: 'ABCD1234', interactor: 'Informer' }
+  const logger = new Logger({ global: mockGlobal, context, flat: true })
 
-  logger.warn('Logging something...')
-  expect(mockGlobal.warnArgs).toEqual([
-    '2025-02-15T00:00:00.000Z [WARN]', 
-    JSON.stringify({ correlationId: 'ABCD1234', interactor: 'Informer' }),
-    'Logging something...'])
+  logger.info('Logging something...')
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    correlationId: 'ABCD1234',
+    interactor: 'Informer',
+    message: 'Logging something...'
+  })
+})
+
+it('can keep nested context when flat option is disabled', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const context = { correlationId: 'ABCD1234', interactor: 'Informer' }
+  const logger = new Logger({ global: mockGlobal, context, flat: false })
 
   logger.info('Logging something...')
-  expect(mockGlobal.infoArgs).toEqual([
-    '2025-02-15T00:00:00.000Z [INFO]', 
-    JSON.stringify({ correlationId: 'ABCD1234', interactor: 'Informer' }),
-    'Logging something...'])
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    context,
+    message: 'Logging something...'
+  })
+})
 
-  logger.debug('Logging something...')
-  expect(mockGlobal.debugArgs).toEqual([
-    '2025-02-15T00:00:00.000Z [DEBUG]',
-    JSON.stringify({ correlationId: 'ABCD1234', interactor: 'Informer' }),
-    'Logging something...'])
+it('keeps log metadata and payload fields over flat context collisions', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.CORE_LOGLEVEL = 'info'
+  const context = {
+    timestamp: 'old',
+    level: 'fatal',
+    namespace: 'context-namespace',
+    message: 'context message',
+    args: ['context args'],
+    correlationId: 'ABCD1234'
+  }
+  const logger = new Logger({
+    global: mockGlobal,
+    namespace: 'core',
+    context,
+    flat: true
+  })
+
+  logger.info('real message', 'value')
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    namespace: 'core',
+    message: 'real message',
+    args: ['context args'],
+    correlationId: 'ABCD1234',
+    arg1: 'value'
+  })
 })
 
 it('supports including static context labels', () => {
+  const originalContext = Logger.context
   Logger.context = () => {
     return { correlationId: 'ABCD1234' }
   }
 
+  try {
+    const { mockGlobal } = setup()
+    mockGlobal.LOGLEVEL = 'debug'
+    const context = { model: 'Product' }
+    const logger = new Logger({ global: mockGlobal, context })
+
+    logger.info('Logging something...')
+    assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+      timestamp: '2025-02-15T00:00:00.000Z',
+      level: 'info',
+      correlationId: 'ABCD1234',
+      model: 'Product',
+      message: 'Logging something...'
+    })
+  } finally {
+    Logger.context = originalContext
+  }
+})
+
+it('includes namespace in JSON output and uses the namespace loglevel variable', () => {
   const { mockGlobal } = setup()
-  mockGlobal.LOGLEVEL = 'debug'
-  const context = { model: 'Product' }
-  const logger = new Logger({ global: mockGlobal, context })
+  mockGlobal.CORE_LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal, namespace: 'core' })
 
   logger.info('Logging something...')
-  expect(mockGlobal.infoArgs).toEqual([
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    namespace: 'core',
+    message: 'Logging something...'
+  })
+})
+
+it('merges non-string object payloads into the JSON record', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal })
+
+  logger.info({ code: 'E_UNEXPECTED' })
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    code: 'E_UNEXPECTED'
+  })
+})
+
+it('stores null payloads as positional fields in JSON format', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal })
+
+  logger.info(null)
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    arg0: null
+  })
+})
+
+it('serializes Error payloads in JSON format', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'error'
+  const logger = new Logger({ global: mockGlobal })
+  const error = new Error('Unexpected failure')
+  error.code = 'E_UNEXPECTED'
+
+  logger.error(error)
+  const record = parseRecord(mockGlobal.errorArgs)
+
+  assert.strictEqual(record.level, 'error')
+  assert.strictEqual(record.name, 'Error')
+  assert.strictEqual(record.message, 'Unexpected failure')
+  assert.strictEqual(record.code, 'E_UNEXPECTED')
+  assert.match(record.stack, /Unexpected failure/)
+})
+
+it('serializes nested Error values inside object payloads', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal })
+  const nested = new Error('Nested failure')
+  nested.code = 'E_NESTED'
+
+  logger.info({ nested })
+  const record = parseRecord(mockGlobal.infoArgs)
+
+  assert.strictEqual(record.nested.name, 'Error')
+  assert.strictEqual(record.nested.message, 'Nested failure')
+  assert.strictEqual(record.nested.code, 'E_NESTED')
+  assert.match(record.nested.stack, /Nested failure/)
+})
+
+it('lets additional payload fields overwrite previously defined keys', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal })
+  const error = new TypeError('Bad input')
+  error.field = 'name'
+
+  logger.info('Validation failed', error)
+  const record = parseRecord(mockGlobal.infoArgs)
+
+  assert.strictEqual(record.message, 'Bad input')
+  assert.strictEqual(record.name, 'TypeError')
+  assert.strictEqual(record.field, 'name')
+  assert.match(record.stack, /Bad input/)
+})
+
+it('serializes special values and circular references in merged JSON fields', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal })
+  const payload = {
+    count: 10n,
+    token: Symbol('auth')
+  }
+  payload.self = payload
+
+  logger.info('Special payload', (function () {}), function namedFn () {}, payload)
+  const record = parseRecord(mockGlobal.infoArgs)
+
+  assert.strictEqual(record.message, 'Special payload')
+  assert.strictEqual(record.arg1, '[Function anonymous]')
+  assert.strictEqual(record.arg2, '[Function namedFn]')
+  assert.strictEqual(record.count, '10')
+  assert.strictEqual(record.token, 'Symbol(auth)')
+  assert.strictEqual(record.self.count, '10')
+  assert.strictEqual(record.self.token, 'Symbol(auth)')
+  assert.strictEqual(record.self.self, '[Circular]')
+})
+
+it('stores array payloads as positional fields in JSON format', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal })
+
+  logger.info('Array payload', [1, 2, 3])
+  assert.deepStrictEqual(parseRecord(mockGlobal.infoArgs), {
+    timestamp: '2025-02-15T00:00:00.000Z',
+    level: 'info',
+    message: 'Array payload',
+    arg1: [1, 2, 3]
+  })
+})
+
+it('supports plain formatting for backward compatibility', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const context = { correlationId: 'ABCD1234' }
+  const logger = new Logger({ global: mockGlobal, context, format: 'plain' })
+
+  logger.info('Logging something...', 0, false)
+  assert.deepStrictEqual(mockGlobal.infoArgs, [
     '2025-02-15T00:00:00.000Z [INFO]',
-    JSON.stringify({ correlationId: 'ABCD1234', model: 'Product' }),
-    'Logging something...'])
+    JSON.stringify(context),
+    'Logging something...',
+    0,
+    false
+  ])
+})
 
-})
+it('supports plain formatting without context labels', () => {
+  const { mockGlobal } = setup()
+  mockGlobal.LOGLEVEL = 'info'
+  const logger = new Logger({ global: mockGlobal, format: 'plain' })
+
+  logger.info()
+  assert.deepStrictEqual(mockGlobal.infoArgs, [
+    '2025-02-15T00:00:00.000Z [INFO]'
+  ])
+})

package/lib/translator.test.js

@@ -1,9 +1,10 @@
-import { it, expect } from '@jest/globals'
+import assert from 'node:assert/strict'
+import { it } from 'node:test'
 import { Translator, t, lt } from './translator.js'
 
 it('can be instantiated', () => {
   const translator = new Translator()
-  expect(translator).toBeTruthy()
+  assert.ok(translator)
 })
 
 it('defines a translate function with options', () => {
@@ -11,7 +12,7 @@ it('defines a translate function with options', () => {
 
   const result = translator.translate('any.key') 
 
-  expect(result).toBe('any.key')
+  assert.strictEqual(result, 'any.key')
 })
 
 it('defines a t shortcut for function translate', () => {
@@ -19,30 +20,36 @@ it('defines a t shortcut for function translate', () => {
 
   const result = t('any.key') 
 
-  expect(result).toBe('any.key')
+  assert.strictEqual(result, 'any.key')
 })
 
 it('defines a global t shortcut translate', () => {
   const originalTranslate = Translator.translate
-  Translator.translate = (key, _options) => {
-    return `translated:${key}`
-  }
+  try {
+    Translator.translate = (key, _options) => {
+      return `translated:${key}`
+    }
 
-  const result = t('any.key') 
+    const result = t('any.key') 
 
-  expect(result).toBe('translated:any.key')
-  Translator.translate = originalTranslate
+    assert.strictEqual(result, 'translated:any.key')
+  } finally {
+    Translator.translate = originalTranslate
+  }
 })
 
 it('defines a global lt lazy-translation function', () => {
   const originalTranslate = Translator.translate
-  Translator.translate = (key, _options) => {
-    return `translated:${key}`
-  }
+  try {
+    Translator.translate = (key, _options) => {
+      return `translated:${key}`
+    }
 
-  const result = lt('any.key') 
+    const result = lt('any.key') 
 
-  expect(result).toBeInstanceOf(Function)
-  expect(result()).toBe('translated:any.key')
-  Translator.translate = originalTranslate
+    assert.ok(result instanceof Function)
+    assert.strictEqual(result(), 'translated:any.key')
+  } finally {
+    Translator.translate = originalTranslate
+  }
 })

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@knowark/loggarkjs",
-  "version": "0.3.10",
+  "version": "0.4.0",
   "description": "Utilitarian Logging Library",
   "main": "./lib/index.js",
   "type": "module",
   "scripts": {
-    "options": "NODE_OPTIONS='--experimental-vm-modules --no-warnings'",
-    "test": "npm run options -- npx jest --coverage"
+    "test": "node --test --experimental-test-coverage --test-coverage-exclude='**/*.test.js'"
   },
   "repository": {
     "type": "git",
@@ -21,8 +20,5 @@
   "bugs": {
     "url": "https://github.com/knowark/loggarkjs/issues"
   },
-  "homepage": "https://github.com/knowark/loggarkjs#readme",
-  "devDependencies": {
-    "jest": "^29.7.0"
-  }
+  "homepage": "https://github.com/knowark/loggarkjs#readme"
 }

package/.vscode/settings.json

@@ -1,7 +0,0 @@
-{
-  "workbench.colorCustomizations": {
-    "activityBar.background": "#2C2D34",
-    "titleBar.activeBackground": "#3E3F49",
-    "titleBar.activeForeground": "#FAFAFB"
-  }
-}