adapt-authoring-logger 1.2.0 → 1.3.0

package/.github/workflows/releases.yml

@@ -25,7 +25,7 @@ jobs:
       - name: Update npm
         run: npm install -g npm@latest
       - name: Install dependencies
-        run: npm ci
+        run: npm install
       - name: Release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/.github/workflows/standardjs.yml

@@ -9,5 +9,5 @@ jobs:
         with:
           node-version: 'lts/*'
           cache: 'npm'
-      - run: npm ci
+      - run: npm install
       - run: npx standard

package/.github/workflows/tests.yml

@@ -11,5 +11,5 @@ jobs:
         with:
           node-version: 'lts/*'
           cache: 'npm'
-      - run: npm ci
+      - run: npm install
       - run: npm test

package/lib/LoggerModule.js

@@ -1,45 +1,12 @@
 import { AbstractModule, Hook } from 'adapt-authoring-core'
 import chalk from 'chalk'
+import { colourise, getDateStamp, getModuleOverrides, isLevelEnabled, isLoggingEnabled } from './utils.js'
 /**
  * Module for logging message to the console
  * @memberof logger
  * @extends {AbstractModule}
  */
 class LoggerModule extends AbstractModule {
-  /**
-   * Colours an input string
-   * @param {String} str
-   * @param {String} colour
-   * @return {String}
-   */
-  static colourise (str, colourFunc) {
-    if (typeof colourFunc === 'string') colourFunc = chalk[colourFunc]
-    return colourFunc ? colourFunc(str) : str
-  }
-
-  /**
-   * Returns a formatted date stamp
-   * @param {Object} config
-   * @return {String}
-   */
-  static getDateStamp (config) {
-    if (!config.timestamp) {
-      return ''
-    }
-    let str
-    if (config.dateFormat === 'iso') {
-      str = new Date().toISOString()
-    } else if (config.dateFormat === 'short') {
-      const d = new Date()
-      const m = d.getMonth() + 1
-      const s = d.getSeconds()
-      const date = `${d.getDate()}/${m < 10 ? `0${m}` : m}/${d.getFullYear().toString().slice(2)}`
-      const time = `${d.getHours()}:${d.getMinutes()}:${s < 10 ? `0${s}` : s}`
-      str = `${date}-${time}`
-    }
-    return LoggerModule.colourise(`${str} `, chalk.dim)
-  }
-
   /** @override */
   async init () {
     await this.app.waitForModule('config')
@@ -60,33 +27,33 @@ class LoggerModule extends AbstractModule {
     this.config = {
       levels: {
         error: {
-          enable: this.isLevelEnabled('error'),
-          moduleOverrides: this.getModuleOverrides('error'),
+          enable: isLevelEnabled(this.levelsConfig, 'error'),
+          moduleOverrides: getModuleOverrides(this.levelsConfig, 'error'),
           colour: chalk.red
         },
         warn: {
-          enable: this.isLevelEnabled('warn'),
-          moduleOverrides: this.getModuleOverrides('warn'),
+          enable: isLevelEnabled(this.levelsConfig, 'warn'),
+          moduleOverrides: getModuleOverrides(this.levelsConfig, 'warn'),
           colour: chalk.yellow
         },
         success: {
-          enable: this.isLevelEnabled('success'),
-          moduleOverrides: this.getModuleOverrides('success'),
+          enable: isLevelEnabled(this.levelsConfig, 'success'),
+          moduleOverrides: getModuleOverrides(this.levelsConfig, 'success'),
           colour: chalk.green
         },
         info: {
-          enable: this.isLevelEnabled('info'),
-          moduleOverrides: this.getModuleOverrides('info'),
+          enable: isLevelEnabled(this.levelsConfig, 'info'),
+          moduleOverrides: getModuleOverrides(this.levelsConfig, 'info'),
           colour: chalk.cyan
         },
         debug: {
-          enable: this.isLevelEnabled('debug'),
-          moduleOverrides: this.getModuleOverrides('debug'),
+          enable: isLevelEnabled(this.levelsConfig, 'debug'),
+          moduleOverrides: getModuleOverrides(this.levelsConfig, 'debug'),
           colour: chalk.dim
         },
         verbose: {
-          enable: this.isLevelEnabled('verbose'),
-          moduleOverrides: this.getModuleOverrides('verbose'),
+          enable: isLevelEnabled(this.levelsConfig, 'verbose'),
+          moduleOverrides: getModuleOverrides(this.levelsConfig, 'verbose'),
           colour: chalk.grey.italic
         }
       },
@@ -100,42 +67,6 @@ class LoggerModule extends AbstractModule {
     this.app.logger = this
   }
 
-  /**
-   * Determines whether a specific log level is enabled
-   * @param {String} level
-   * @return {Boolean}
-   */
-  isLevelEnabled (level) { // note explicit disable takes preference
-    return !this.levelsConfig.includes(`!${level}`) && this.levelsConfig.includes(level)
-  }
-
-  /**
-   * Returns a list of log levels with overrides, either inclusive or exclusive
-   * @param {String} level
-   * @return {Array}
-   */
-  getModuleOverrides (level) {
-    const levels = []
-    this.levelsConfig.forEach(l => {
-      const s = `${level}.`; const notS = `!${level}.`
-      if (l.indexOf(s) === 0 || l.indexOf(notS) === 0) levels.push(l)
-    })
-    return levels
-  }
-
-  /**
-   * Returns whether a message should be logged (i.e. not disabled in the config)
-   * @param {string} level Logging level
-   * @param {string} id Id of log caller
-   * @returns {boolean}
-   */
-  isLoggingEnabled (level, id) {
-    const { enable, moduleOverrides = [] } = this?.config?.levels[level] || {}
-    const isEnabled = enable || moduleOverrides.includes(`${level}.${id}`)
-    const disableOverride = moduleOverrides.includes(`!${level}.${id}`)
-    return isEnabled && !disableOverride
-  }
-
   /**
    * Logs a message to the console
    * @param {String} level Severity of the message
@@ -150,12 +81,12 @@ class LoggerModule extends AbstractModule {
       id = this.name.split('-').pop()
       args = [AbstractModule.MODULE_READY, ...args]
     }
-    if (!this.isLoggingEnabled(level, id)) {
+    if (!isLoggingEnabled(this.config?.levels, level, id)) {
       return
     }
     const colour = this?.config?.levels[level]?.colour
     const logFunc = console[level] ?? console.log
-    logFunc(`${LoggerModule.getDateStamp(this.config)}${LoggerModule.colourise(level, colour)} ${LoggerModule.colourise(id, chalk.magenta)}`, ...args)
+    logFunc(`${getDateStamp(this.config)}${colourise(level, colour)} ${colourise(id, chalk.magenta)}`, ...args)
     this.logHook.invoke(new Date(), level, id, ...args)
   }
 }

package/lib/utils/colourise.js

@@ -0,0 +1,12 @@
+import chalk from 'chalk'
+/**
+ * Colours an input string using a chalk function or colour name
+ * @param {String} str The string to colourise
+ * @param {String|Function} colourFunc A chalk colour function or string name of a chalk colour
+ * @return {String} The colourised string
+ * @memberof logger
+ */
+export function colourise (str, colourFunc) {
+  if (typeof colourFunc === 'string') colourFunc = chalk[colourFunc]
+  return colourFunc ? colourFunc(str) : str
+}

package/lib/utils/getDateStamp.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk'
+import { colourise } from './colourise.js'
+/**
+ * Returns a formatted date stamp string based on config
+ * @param {Object} config Logger configuration object
+ * @param {Boolean} config.timestamp Whether to include a timestamp
+ * @param {String} config.dateFormat Date format ('iso' or 'short')
+ * @return {String} The formatted date stamp (empty string if timestamps disabled)
+ * @memberof logger
+ */
+export function getDateStamp (config) {
+  if (!config.timestamp) {
+    return ''
+  }
+  let str
+  if (config.dateFormat === 'iso') {
+    str = new Date().toISOString()
+  } else if (config.dateFormat === 'short') {
+    const d = new Date()
+    const m = d.getMonth() + 1
+    const s = d.getSeconds()
+    const date = `${d.getDate()}/${m < 10 ? `0${m}` : m}/${d.getFullYear().toString().slice(2)}`
+    const time = `${d.getHours()}:${d.getMinutes()}:${s < 10 ? `0${s}` : s}`
+    str = `${date}-${time}`
+  }
+  return colourise(`${str} `, chalk.dim)
+}

package/lib/utils/getModuleOverrides.js

@@ -0,0 +1,15 @@
+/**
+ * Returns a list of module-specific log level overrides from the levels config
+ * @param {Array<String>} levelsConfig Array of level configuration strings
+ * @param {String} level The log level to find overrides for
+ * @return {Array<String>} Array of override strings (e.g. ['debug.mymod', '!debug.other'])
+ * @memberof logger
+ */
+export function getModuleOverrides (levelsConfig, level) {
+  const levels = []
+  levelsConfig.forEach(l => {
+    const s = `${level}.`; const notS = `!${level}.`
+    if (l.indexOf(s) === 0 || l.indexOf(notS) === 0) levels.push(l)
+  })
+  return levels
+}

package/lib/utils/isLevelEnabled.js

@@ -0,0 +1,10 @@
+/**
+ * Determines whether a specific log level is enabled in the levels config
+ * @param {Array<String>} levelsConfig Array of level configuration strings
+ * @param {String} level The log level to check (e.g. 'error', 'warn', 'debug')
+ * @return {Boolean} Whether the level is enabled
+ * @memberof logger
+ */
+export function isLevelEnabled (levelsConfig, level) {
+  return !levelsConfig.includes(`!${level}`) && levelsConfig.includes(level)
+}

package/lib/utils/isLoggingEnabled.js

@@ -0,0 +1,14 @@
+/**
+ * Returns whether a message should be logged based on the resolved config
+ * @param {Object} configLevels The resolved levels config object (e.g. { error: { enable, moduleOverrides }, ... })
+ * @param {String} level Logging level (e.g. 'error', 'warn', 'debug')
+ * @param {String} id Id of log caller (module name)
+ * @returns {Boolean} Whether logging is enabled for this level and caller
+ * @memberof logger
+ */
+export function isLoggingEnabled (configLevels, level, id) {
+  const { enable, moduleOverrides = [] } = configLevels?.[level] || {}
+  const isEnabled = enable || moduleOverrides.includes(`${level}.${id}`)
+  const disableOverride = moduleOverrides.includes(`!${level}.${id}`)
+  return isEnabled && !disableOverride
+}

package/lib/utils.js

@@ -0,0 +1,5 @@
+export { colourise } from './utils/colourise.js'
+export { getDateStamp } from './utils/getDateStamp.js'
+export { getModuleOverrides } from './utils/getModuleOverrides.js'
+export { isLevelEnabled } from './utils/isLevelEnabled.js'
+export { isLoggingEnabled } from './utils/isLoggingEnabled.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-logger",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Basic logger for the Adapt authoring tool",
   "homepage": "https://github.com/adapt-security/adapt-authoring-logger",
   "license": "GPL-3.0",
@@ -8,7 +8,7 @@
   "main": "index.js",
   "repository": "adapt-security/adapt-authoring-logger",
   "dependencies": {
-    "adapt-authoring-core": "^1.7.0",
+    "adapt-authoring-core": "^2.0.0",
     "chalk": "^5.3.0"
   },
   "peerDependencies": {

package/tests/LoggerModule.spec.js

@@ -3,220 +3,191 @@ import assert from 'node:assert/strict'
 import chalk from 'chalk'
 import { AbstractModule } from 'adapt-authoring-core'
 import LoggerModule from '../lib/LoggerModule.js'
+import { colourise, getDateStamp, isLevelEnabled, getModuleOverrides, isLoggingEnabled } from '../lib/utils.js'
 
 describe('LoggerModule', () => {
-  describe('#colourise()', () => {
+  describe('colourise()', () => {
     it('should return string with colour function applied', () => {
-      const result = LoggerModule.colourise('test', chalk.red)
+      const result = colourise('test', chalk.red)
       assert.ok(result.includes('test'))
     })
 
     it('should accept colour name as string', () => {
-      const result = LoggerModule.colourise('test', 'green')
+      const result = colourise('test', 'green')
       assert.ok(result.includes('test'))
     })
 
     it('should return uncoloured string if no colour function provided', () => {
-      const result = LoggerModule.colourise('test', null)
+      const result = colourise('test', null)
       assert.equal(result, 'test')
     })
 
     it('should handle undefined colour function', () => {
-      const result = LoggerModule.colourise('test', undefined)
+      const result = colourise('test', undefined)
       assert.equal(result, 'test')
     })
 
     it('should return empty string unchanged when no colour', () => {
-      const result = LoggerModule.colourise('', null)
+      const result = colourise('', null)
       assert.equal(result, '')
     })
 
     it('should apply colour function to empty string', () => {
-      const result = LoggerModule.colourise('', chalk.red)
+      const result = colourise('', chalk.red)
       assert.equal(typeof result, 'string')
     })
   })
 
-  describe('#getDateStamp()', () => {
+  describe('getDateStamp()', () => {
     it('should return empty string when timestamp is disabled', () => {
       const config = { timestamp: false }
-      const result = LoggerModule.getDateStamp(config)
+      const result = getDateStamp(config)
       assert.equal(result, '')
     })
 
     it('should return ISO format date when dateFormat is "iso"', () => {
       const config = { timestamp: true, dateFormat: 'iso' }
-      const result = LoggerModule.getDateStamp(config)
+      const result = getDateStamp(config)
       assert.ok(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(result))
     })
 
     it('should return short format date when dateFormat is "short"', () => {
       const config = { timestamp: true, dateFormat: 'short' }
-      const result = LoggerModule.getDateStamp(config)
+      const result = getDateStamp(config)
       assert.ok(/\d{1,2}\/\d{2}\/\d{2}-\d{1,2}:\d{1,2}:\d{2}/.test(result))
     })
 
     it('should return undefined-based string for unrecognised dateFormat', () => {
       const config = { timestamp: true, dateFormat: 'unknown' }
-      const result = LoggerModule.getDateStamp(config)
+      const result = getDateStamp(config)
       assert.ok(result.includes('undefined'))
     })
 
     it('should include trailing space in formatted timestamp', () => {
       const config = { timestamp: true, dateFormat: 'iso' }
-      const result = LoggerModule.getDateStamp(config)
+      const result = getDateStamp(config)
       assert.ok(result.includes(' '))
     })
   })
 
-  describe('#isLevelEnabled()', () => {
-    let logger
-
-    beforeEach(() => {
-      logger = new LoggerModule('test-logger')
-      logger.levelsConfig = ['error', 'warn', 'info']
-    })
-
+  describe('isLevelEnabled()', () => {
     it('should return true for enabled levels', () => {
-      assert.equal(logger.isLevelEnabled('error'), true)
-      assert.equal(logger.isLevelEnabled('warn'), true)
-      assert.equal(logger.isLevelEnabled('info'), true)
+      const levelsConfig = ['error', 'warn', 'info']
+      assert.equal(isLevelEnabled(levelsConfig, 'error'), true)
+      assert.equal(isLevelEnabled(levelsConfig, 'warn'), true)
+      assert.equal(isLevelEnabled(levelsConfig, 'info'), true)
     })
 
     it('should return false for disabled levels', () => {
-      assert.equal(logger.isLevelEnabled('debug'), false)
-      assert.equal(logger.isLevelEnabled('verbose'), false)
+      const levelsConfig = ['error', 'warn', 'info']
+      assert.equal(isLevelEnabled(levelsConfig, 'debug'), false)
+      assert.equal(isLevelEnabled(levelsConfig, 'verbose'), false)
     })
 
     it('should return false when level is explicitly disabled', () => {
-      logger.levelsConfig = ['error', '!warn', 'info']
-      assert.equal(logger.isLevelEnabled('warn'), false)
+      const levelsConfig = ['error', '!warn', 'info']
+      assert.equal(isLevelEnabled(levelsConfig, 'warn'), false)
     })
 
     it('should give preference to explicit disable', () => {
-      logger.levelsConfig = ['warn', '!warn']
-      assert.equal(logger.isLevelEnabled('warn'), false)
+      const levelsConfig = ['warn', '!warn']
+      assert.equal(isLevelEnabled(levelsConfig, 'warn'), false)
     })
 
     it('should return false for empty levelsConfig', () => {
-      logger.levelsConfig = []
-      assert.equal(logger.isLevelEnabled('error'), false)
+      assert.equal(isLevelEnabled([], 'error'), false)
     })
 
     it('should not match partial level names', () => {
-      logger.levelsConfig = ['info']
-      assert.equal(logger.isLevelEnabled('inf'), false)
-      assert.equal(logger.isLevelEnabled('information'), false)
+      const levelsConfig = ['info']
+      assert.equal(isLevelEnabled(levelsConfig, 'inf'), false)
+      assert.equal(isLevelEnabled(levelsConfig, 'information'), false)
     })
   })
 
-  describe('#getModuleOverrides()', () => {
-    let logger
-
-    beforeEach(() => {
-      logger = new LoggerModule('test-logger')
-    })
-
+  describe('getModuleOverrides()', () => {
     it('should return module-specific overrides for a level', () => {
-      logger.levelsConfig = ['error', 'error.myModule', 'error.anotherModule', 'warn']
-      const result = logger.getModuleOverrides('error')
+      const levelsConfig = ['error', 'error.myModule', 'error.anotherModule', 'warn']
+      const result = getModuleOverrides(levelsConfig, 'error')
       assert.ok(result.includes('error.myModule'))
       assert.ok(result.includes('error.anotherModule'))
       assert.equal(result.length, 2)
     })
 
     it('should include negative overrides', () => {
-      logger.levelsConfig = ['error', '!error.myModule']
-      const result = logger.getModuleOverrides('error')
+      const levelsConfig = ['error', '!error.myModule']
+      const result = getModuleOverrides(levelsConfig, 'error')
       assert.ok(result.includes('!error.myModule'))
     })
 
     it('should return empty array when no overrides exist', () => {
-      logger.levelsConfig = ['error', 'warn']
-      const result = logger.getModuleOverrides('info')
+      const levelsConfig = ['error', 'warn']
+      const result = getModuleOverrides(levelsConfig, 'info')
       assert.equal(result.length, 0)
     })
 
     it('should not include overrides for other levels', () => {
-      logger.levelsConfig = ['error', 'error.moduleA', 'warn.moduleB']
-      const result = logger.getModuleOverrides('error')
+      const levelsConfig = ['error', 'error.moduleA', 'warn.moduleB']
+      const result = getModuleOverrides(levelsConfig, 'error')
       assert.ok(!result.includes('warn.moduleB'))
     })
 
     it('should return both positive and negative overrides together', () => {
-      logger.levelsConfig = ['error', 'error.modA', '!error.modB']
-      const result = logger.getModuleOverrides('error')
+      const levelsConfig = ['error', 'error.modA', '!error.modB']
+      const result = getModuleOverrides(levelsConfig, 'error')
       assert.equal(result.length, 2)
       assert.ok(result.includes('error.modA'))
       assert.ok(result.includes('!error.modB'))
     })
 
     it('should return empty array for empty levelsConfig', () => {
-      logger.levelsConfig = []
-      const result = logger.getModuleOverrides('error')
-      assert.deepEqual(result, [])
+      assert.deepEqual(getModuleOverrides([], 'error'), [])
     })
   })
 
-  describe('#isLoggingEnabled()', () => {
-    let logger
-
-    beforeEach(() => {
-      logger = new LoggerModule('test-logger')
-      logger.config = {
-        levels: {
-          error: { enable: true, moduleOverrides: [] },
-          warn: { enable: false, moduleOverrides: ['warn.specific'] },
-          info: { enable: true, moduleOverrides: ['!info.blocked'] }
-        }
-      }
-    })
-
+  describe('isLoggingEnabled()', () => {
     it('should return true for enabled levels', () => {
-      assert.equal(logger.isLoggingEnabled('error', 'anyId'), true)
+      const levels = { error: { enable: true, moduleOverrides: [] } }
+      assert.equal(isLoggingEnabled(levels, 'error', 'anyId'), true)
     })
 
     it('should return false for disabled levels without overrides', () => {
-      assert.equal(logger.isLoggingEnabled('warn', 'generic'), false)
+      const levels = { warn: { enable: false, moduleOverrides: ['warn.specific'] } }
+      assert.equal(isLoggingEnabled(levels, 'warn', 'generic'), false)
     })
 
     it('should return true for disabled level with positive override', () => {
-      assert.equal(logger.isLoggingEnabled('warn', 'specific'), true)
+      const levels = { warn: { enable: false, moduleOverrides: ['warn.specific'] } }
+      assert.equal(isLoggingEnabled(levels, 'warn', 'specific'), true)
     })
 
     it('should return false for enabled level with negative override', () => {
-      assert.equal(logger.isLoggingEnabled('info', 'blocked'), false)
+      const levels = { info: { enable: true, moduleOverrides: ['!info.blocked'] } }
+      assert.equal(isLoggingEnabled(levels, 'info', 'blocked'), false)
     })
 
     it('should return true for enabled level without override', () => {
-      assert.equal(logger.isLoggingEnabled('info', 'allowed'), true)
+      const levels = { info: { enable: true, moduleOverrides: ['!info.blocked'] } }
+      assert.equal(isLoggingEnabled(levels, 'info', 'allowed'), true)
     })
 
     it('should handle missing level config gracefully', () => {
-      assert.equal(logger.isLoggingEnabled('nonexistent', 'id'), false)
+      const levels = { error: { enable: true, moduleOverrides: [] } }
+      assert.equal(isLoggingEnabled(levels, 'nonexistent', 'id'), false)
     })
 
     it('should default moduleOverrides to empty array when undefined', () => {
-      logger.config = {
-        levels: {
-          error: { enable: true }
-        }
-      }
-      assert.equal(logger.isLoggingEnabled('error', 'anyId'), true)
+      const levels = { error: { enable: true } }
+      assert.equal(isLoggingEnabled(levels, 'error', 'anyId'), true)
     })
 
     it('should return false when both enable is false and no matching override', () => {
-      logger.config = {
-        levels: {
-          debug: { enable: false, moduleOverrides: ['debug.other'] }
-        }
-      }
-      assert.equal(logger.isLoggingEnabled('debug', 'notOther'), false)
+      const levels = { debug: { enable: false, moduleOverrides: ['debug.other'] } }
+      assert.equal(isLoggingEnabled(levels, 'debug', 'notOther'), false)
     })
 
     it('should handle config being undefined gracefully', () => {
-      logger.config = undefined
-      assert.equal(logger.isLoggingEnabled('error', 'id'), false)
+      assert.equal(isLoggingEnabled(undefined, 'error', 'id'), false)
     })
   })
 

package/tests/utils-colourise.spec.js

@@ -0,0 +1,36 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { colourise } from '../lib/utils/colourise.js'
+
+describe('colourise()', () => {
+  it('should return string unchanged when colourFunc is undefined', () => {
+    assert.equal(colourise('hello', undefined), 'hello')
+  })
+
+  it('should return string unchanged when colourFunc is null', () => {
+    assert.equal(colourise('hello', null), 'hello')
+  })
+
+  it('should apply a function colour', () => {
+    const mockColour = (s) => `[coloured]${s}[/coloured]`
+    assert.equal(colourise('hello', mockColour), '[coloured]hello[/coloured]')
+  })
+
+  it('should resolve string colour names via chalk', () => {
+    // chalk resolves 'red' to chalk.red and applies it
+    const result = colourise('hello', 'red')
+    assert.ok(result.includes('hello'))
+    // chalk.red is a function, so the result should be the return value of that function
+    // In non-TTY environments chalk may strip ANSI codes, so just verify it resolved and ran
+    assert.equal(typeof result, 'string')
+  })
+
+  it('should return string unchanged for invalid chalk colour name', () => {
+    assert.equal(colourise('hello', 'notARealColour'), 'hello')
+  })
+
+  it('should handle empty string input', () => {
+    const mockColour = (s) => `[c]${s}[/c]`
+    assert.equal(colourise('', mockColour), '[c][/c]')
+  })
+})

package/tests/utils-getDateStamp.spec.js

@@ -0,0 +1,34 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { getDateStamp } from '../lib/utils/getDateStamp.js'
+
+// eslint-disable-next-line no-control-regex
+const ANSI_REGEX = /\u001b\[\d+m/g
+
+describe('getDateStamp()', () => {
+  it('should return empty string when timestamp is falsy', () => {
+    assert.equal(getDateStamp({ timestamp: false, dateFormat: 'iso' }), '')
+  })
+
+  it('should return empty string when timestamp is undefined', () => {
+    assert.equal(getDateStamp({ dateFormat: 'iso' }), '')
+  })
+
+  it('should return an ISO date string when dateFormat is "iso"', () => {
+    const result = getDateStamp({ timestamp: true, dateFormat: 'iso' })
+    const stripped = result.replace(ANSI_REGEX, '')
+    assert.ok(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z /.test(stripped))
+  })
+
+  it('should return a short date string when dateFormat is "short"', () => {
+    const result = getDateStamp({ timestamp: true, dateFormat: 'short' })
+    const stripped = result.replace(ANSI_REGEX, '')
+    assert.ok(/^\d{1,2}\/\d{2}\/\d{2}-\d{1,2}:\d{1,2}:\d{1,2} /.test(stripped))
+  })
+
+  it('should handle unknown dateFormat by returning "undefined " (colourised)', () => {
+    const result = getDateStamp({ timestamp: true, dateFormat: 'unknown' })
+    const stripped = result.replace(ANSI_REGEX, '')
+    assert.equal(stripped, 'undefined ')
+  })
+})

package/tests/utils-getModuleOverrides.spec.js

@@ -0,0 +1,39 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { getModuleOverrides } from '../lib/utils/getModuleOverrides.js'
+
+describe('getModuleOverrides()', () => {
+  it('should return empty array when no overrides exist', () => {
+    assert.deepEqual(getModuleOverrides(['error', 'warn', 'info'], 'debug'), [])
+  })
+
+  it('should return module-specific includes', () => {
+    const config = ['error', 'debug.mymod', 'debug.other']
+    assert.deepEqual(getModuleOverrides(config, 'debug'), ['debug.mymod', 'debug.other'])
+  })
+
+  it('should return module-specific excludes', () => {
+    const config = ['error', '!debug.mymod']
+    assert.deepEqual(getModuleOverrides(config, 'debug'), ['!debug.mymod'])
+  })
+
+  it('should return both includes and excludes', () => {
+    const config = ['error', 'debug.mymod', '!debug.other', 'debug.third']
+    const result = getModuleOverrides(config, 'debug')
+    assert.deepEqual(result, ['debug.mymod', '!debug.other', 'debug.third'])
+  })
+
+  it('should not include plain level entries', () => {
+    const config = ['debug', 'debug.mymod']
+    assert.deepEqual(getModuleOverrides(config, 'debug'), ['debug.mymod'])
+  })
+
+  it('should not match other levels with similar prefixes', () => {
+    const config = ['error.mymod', 'warn.mymod']
+    assert.deepEqual(getModuleOverrides(config, 'error'), ['error.mymod'])
+  })
+
+  it('should handle empty config', () => {
+    assert.deepEqual(getModuleOverrides([], 'error'), [])
+  })
+})

package/tests/utils-isLevelEnabled.spec.js

@@ -0,0 +1,33 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { isLevelEnabled } from '../lib/utils/isLevelEnabled.js'
+
+describe('isLevelEnabled()', () => {
+  it('should return true when level is in config', () => {
+    assert.equal(isLevelEnabled(['error', 'warn', 'info'], 'error'), true)
+  })
+
+  it('should return false when level is not in config', () => {
+    assert.equal(isLevelEnabled(['error', 'warn'], 'debug'), false)
+  })
+
+  it('should return false when level is explicitly disabled', () => {
+    assert.equal(isLevelEnabled(['error', '!warn', 'warn'], 'warn'), false)
+  })
+
+  it('should return true when level is present and not explicitly disabled', () => {
+    assert.equal(isLevelEnabled(['error', 'warn', '!debug'], 'warn'), true)
+  })
+
+  it('should return false for empty config', () => {
+    assert.equal(isLevelEnabled([], 'error'), false)
+  })
+
+  it('should not match partial level names', () => {
+    assert.equal(isLevelEnabled(['error.mymod'], 'error'), false)
+  })
+
+  it('should handle explicit disable taking precedence even when level is included', () => {
+    assert.equal(isLevelEnabled(['debug', '!debug'], 'debug'), false)
+  })
+})

package/tests/utils-isLoggingEnabled.spec.js

@@ -0,0 +1,50 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { isLoggingEnabled } from '../lib/utils/isLoggingEnabled.js'
+
+describe('isLoggingEnabled()', () => {
+  it('should return true when level is globally enabled', () => {
+    const levels = { error: { enable: true, moduleOverrides: [] } }
+    assert.equal(isLoggingEnabled(levels, 'error', 'mymod'), true)
+  })
+
+  it('should return false when level is globally disabled and no override', () => {
+    const levels = { error: { enable: false, moduleOverrides: [] } }
+    assert.equal(isLoggingEnabled(levels, 'error', 'mymod'), false)
+  })
+
+  it('should return true when module has an include override', () => {
+    const levels = { debug: { enable: false, moduleOverrides: ['debug.mymod'] } }
+    assert.equal(isLoggingEnabled(levels, 'debug', 'mymod'), true)
+  })
+
+  it('should return false when module has a disable override', () => {
+    const levels = { error: { enable: true, moduleOverrides: ['!error.mymod'] } }
+    assert.equal(isLoggingEnabled(levels, 'error', 'mymod'), false)
+  })
+
+  it('should return false when both include and disable override exist', () => {
+    const levels = { debug: { enable: false, moduleOverrides: ['debug.mymod', '!debug.mymod'] } }
+    assert.equal(isLoggingEnabled(levels, 'debug', 'mymod'), false)
+  })
+
+  it('should return false when level is not in config', () => {
+    const levels = { error: { enable: true, moduleOverrides: [] } }
+    assert.equal(isLoggingEnabled(levels, 'debug', 'mymod'), false)
+  })
+
+  it('should handle null/undefined configLevels gracefully', () => {
+    assert.equal(isLoggingEnabled(null, 'error', 'mymod'), false)
+    assert.equal(isLoggingEnabled(undefined, 'error', 'mymod'), false)
+  })
+
+  it('should default moduleOverrides to empty array when missing', () => {
+    const levels = { error: { enable: true } }
+    assert.equal(isLoggingEnabled(levels, 'error', 'mymod'), true)
+  })
+
+  it('should not match overrides for different modules', () => {
+    const levels = { debug: { enable: false, moduleOverrides: ['debug.other'] } }
+    assert.equal(isLoggingEnabled(levels, 'debug', 'mymod'), false)
+  })
+})