Implement function scoped Warning

README.md

@@ -31,7 +31,7 @@ const warning = createWarning({
   message: 'Hello %s',
   unlimited: true
 })
-warning.emit('world')
+warning('world')
 ```
 
 #### Methods
@@ -60,7 +60,7 @@ This is a wrapper for `warning.create`. It is equivalent to invoking
 Deprecation warnings have extended support for the Node.js CLI options:
 `--throw-deprecation`, `--no-deprecation`, and `--trace-deprecation`.
 
-##### `warning.emit([, a [, b [, c]]])`
+##### `warning([, a [, b [, c]]])`
 
 The utility also contains an `emit` function that you can use for emitting the
 warnings you have previously created by passing their respective code.
@@ -71,35 +71,35 @@ A warning is guaranteed to be emitted at least once.
 ```js
 const { createWarning } = require('process-warning')
 const FST_ERROR_CODE = createWarning({ name: 'FastifyWarning', code: 'FST_ERROR_CODE', message: 'message' })
-FST_ERROR_CODE.emit()
+FST_ERROR_CODE()
 ```
 
 How to use an interpolated string:
 ```js
 const { createWarning } = require('process-warning')
 const FST_ERROR_CODE = createWarning({ name: 'FastifyWarning', code: 'FST_ERROR_CODE', message: 'Hello %s'})
-FST_ERROR_CODE.emit('world')
+FST_ERROR_CODE('world')
 ```
 
 The `warning` object has methods and properties for managing the warning's state. Useful for testing.
 ```js
 const { createWarning } = require('process-warning')
 const FST_ERROR_CODE = createWarning({ name: 'FastifyWarning', code: 'FST_ERROR_CODE', message: 'Hello %s'})
 console.log(FST_ERROR_CODE.emitted) // false
-FST_ERROR_CODE.emit('world')
+FST_ERROR_CODE('world')
 console.log(FST_ERROR_CODE.emitted) // true
 
 const FST_ERROR_CODE_2 = createWarning('FastifyWarning', 'FST_ERROR_CODE_2', 'Hello %s')
 FST_ERROR_CODE_2.emitted = true
-FST_ERROR_CODE_2.emit('world') // will not be emitted
+FST_ERROR_CODE_2('world') // will not be emitted
 ```
 
 How to use an unlimited warning:
 ```js
 const { createWarning } = require('process-warning')
 const FST_ERROR_CODE = createWarning({ name: 'FastifyWarning', code: 'FST_ERROR_CODE', message: 'Hello %s', unlimited: true })
-FST_ERROR_CODE.emit('world') // will be emitted
-FST_ERROR_CODE.emit('world') // will be emitted again
+FST_ERROR_CODE('world') // will be emitted
+FST_ERROR_CODE('world') // will be emitted again
 ```
 
 #### Suppressing warnings

benchmarks/warn.js

@@ -16,8 +16,8 @@ const err2 = createWarning({
 
 new Suite()
   .add('warn', function () {
-    err1.emit()
-    err2.emit()
+    err1()
+    err2()
   })
   .on('cycle', function (event) {
     console.log(String(event.target))

examples/example.js

@@ -8,4 +8,4 @@ const CUSTDEP001 = createWarning({
   message: 'This is a deprecation warning'
 })
 
-CUSTDEP001.emit()
+CUSTDEP001()

index.js

@@ -8,7 +8,10 @@ const { format } = require('node:util')
 
 /**
  * Represents a warning item with details.
- * @typedef {Object} WarningItem
+ * @typedef {Function} WarningItem
+ * @param {*} [a] Possible message interpolation value.
+ * @param {*} [b] Possible message interpolation value.
+ * @param {*} [c] Possible message interpolation value.
  * @property {string} name - The name of the warning.
  * @property {string} code - The code associated with the warning.
  * @property {string} message - The warning message.
@@ -44,6 +47,14 @@ function createDeprecation (params) {
   return createWarning({ ...params, name: 'DeprecationWarning' })
 }
 
+/**
+ * Emits the warning.
+ * @typedef WarningEmitter
+ * @param {*} [a] Possible message interpolation value.
+ * @param {*} [b] Possible message interpolation value.
+ * @param {*} [c] Possible message interpolation value.
+ */
+
 /**
  * Creates a warning item.
  * @function
@@ -60,41 +71,31 @@ function createWarning ({ name, code, message, unlimited = false } = {}) {
 
   code = code.toUpperCase()
 
-  return new WarningItem(name, code, message, unlimited)
-}
+  const warningContainer = unlimited
+    ? {
+        [name]: function (a, b, c) {
+          warning.emitted = true
 
-/**
- * Represents a warning item with details.
- * @class
- * @memberof processWarning
- * @param {string} name - The name of the warning.
- * @param {string} code - The code associated with the warning.
- * @param {string} message - The warning message.
- * @param {boolean} unlimited - If true, allows unlimited emissions of the warning.
- */
-class WarningItem {
-  constructor (name, code, message, unlimited) {
-    this.name = name
-    this.code = code
-    this.message = message
-    this.unlimited = unlimited
-    this.emitted = false
-  }
+          process.emitWarning(warning.format(a, b, c), warning.name, warning.code)
+        }
 
-  /**
-   * Emits the warning.
-   * @param {*} [a] Possible message interpolation value.
-   * @param {*} [b] Possible message interpolation value.
-   * @param {*} [c] Possible message interpolation value.
-   */
-  emit (a, b, c) {
-    if (this.emitted === true && this.unlimited === false) {
-      return
-    }
+      }
+    : {
+        [name]: function (a, b, c) {
+          if (warning.emitted === true && warning.unlimited !== true) {
+            return
+          }
+          warning.emitted = true
 
-    this.emitted = true
-    process.emitWarning(this.format(a, b, c), this.name, this.code)
-  }
+          process.emitWarning(warning.format(a, b, c), warning.name, warning.code)
+        }
+      }
+  const warning = warningContainer[name]
+
+  warning.emitted = false
+  warning.message = message
+  warning.unlimited = unlimited
+  warning.code = code
 
   /**
    * Formats the warning message.
@@ -103,19 +104,21 @@ class WarningItem {
    * @param {*} [c] Possible message interpolation value.
    * @returns {string} The formatted warning message.
    */
-  format (a, b, c) {
+  warning.format = function (a, b, c) {
     let formatted
     if (a && b && c) {
-      formatted = format(this.message, a, b, c)
+      formatted = format(message, a, b, c)
     } else if (a && b) {
-      formatted = format(this.message, a, b)
+      formatted = format(message, a, b)
     } else if (a) {
-      formatted = format(this.message, a)
+      formatted = format(message, a)
     } else {
-      formatted = this.message
+      formatted = message
     }
     return formatted
   }
+
+  return warning
 }
 
 /**

test/emit-interpolated-string.test.js

@@ -19,8 +19,8 @@ test('emit with interpolated string', t => {
     code: 'CODE',
     message: 'Hello %s'
   })
-  codeWarning.emit('world')
-  codeWarning.emit('world')
+  codeWarning('world')
+  codeWarning('world')
 
   setImmediate(() => {
     process.removeListener('warning', onWarning)

test/emit-once-only.test.js

@@ -19,8 +19,8 @@ test('emit should emit a given code only once', t => {
     code: 'CODE',
     message: 'Hello world'
   })
-  warn.emit()
-  warn.emit()
+  warn()
+  warn()
   setImmediate(() => {
     process.removeListener('warning', onWarning)
     t.end()

test/emit-set.test.js

@@ -20,7 +20,7 @@ test('emit should set the emitted state', t => {
   warn.emitted = true
   t.ok(warn.emitted)
 
-  warn.emit()
+  warn()
   t.ok(warn.emitted)
 
   setImmediate(() => {

test/emit-unlimited.test.js

@@ -28,7 +28,7 @@ test('emit should emit a given code unlimited times', t => {
 
   for (let i = 0; i < times; i++) {
     expectedRun.push(i)
-    warn.emit()
+    warn()
   }
   setImmediate(() => {
     process.removeListener('warning', onWarning)

test/issue-88.test.js

@@ -23,8 +23,8 @@ test('Must not overwrite config', t => {
   })
 
   process.on('warning', onWarning)
-  a.emit('CODE_1')
-  a.emit('CODE_1')
+  a('CODE_1')
+  a('CODE_1')
 
   setImmediate(() => {
     process.removeListener('warning', onWarning)

test/jest.test.js

@@ -9,7 +9,7 @@ test('works with jest', done => {
     code: 'CODE',
     message: 'Hello world'
   })
-  code.emit('world')
+  code('world')
 
   // we cannot actually listen to process warning event
   // because jest messes with it (that's the point of this test)

types/index.d.ts

@@ -1,11 +1,11 @@
 declare namespace processWarning {
-  export type WarningItem = {
+  export interface WarningItem {
+    (a?: any, b?: any, c?: any): void;
     name: string;
     code: string;
     message: string;
     emitted: boolean;
     unlimited: boolean;
-    emit(a?: any, b?: any, c?: any): void;
     format(a?: any, b?: any, c?: any): string;
   }
 

types/index.test-d.ts

@@ -13,9 +13,9 @@ expectType<string>(WarnInstance.name)
 expectType<boolean>(WarnInstance.emitted)
 expectType<boolean>(WarnInstance.unlimited)
 
-expectType<void>(WarnInstance.emit())
-expectType<void>(WarnInstance.emit('foo'))
-expectType<void>(WarnInstance.emit('foo', 'bar'))
+expectType<void>(WarnInstance())
+expectType<void>(WarnInstance('foo'))
+expectType<void>(WarnInstance('foo', 'bar'))
 
 const buildWarnUnlimited = createWarning({
   name: 'FastifyWarning',
@@ -31,6 +31,6 @@ const DeprecationInstance = createDeprecation({
 })
 expectType<string>(DeprecationInstance.code)
 
-DeprecationInstance.emit()
-DeprecationInstance.emit('foo')
-DeprecationInstance.emit('foo', 'bar')
+DeprecationInstance()
+DeprecationInstance('foo')
+DeprecationInstance('foo', 'bar')