runtime-reporter 0.2.0 → 0.4.0

package/README.md

@@ -1,19 +1,19 @@
 # Runtime Reporter
 
-Runtime messaging that is convenient in development and secure in production.
+Structured runtime events for applications and frameworks. A composable foundation for logging, messaging, and runtime reporting.
 
 ## Features
 
-- **Security minded**: Pass an empty message set in production to avoid exposing internal messaging.
+- **Security focused**: Pass an empty message set in production to avoid exposing internal messaging.
 - **Centralized messages**: Define message text once; reference by a unique code everywhere else.
 - **Tokenized templates**: Apply runtime data to messages via templated strings and tokenized variables.
 - **Type-safe**: Autocomplete and compile-time validation for message codes and token names.
 - **Tree-shakeable**: Pass an empty message set in production to reduce your bundle size
 - **Test friendly**: Use `message()` to assert on final output without duplicating message text.
-- **Dual module output**: Works with both ESM and CJS project environments.
-- **Code-based messaging**: Coded messages make it easy to identify and find errors to perform debugging tasks.
+- **Code-based messaging**: Coded messages make it easy to identify errors to perform debugging tasks.
 - **Small footprint**: Minimal bundle size (~2 KB minified) so it adds negligible weight to your app.
 - **Zero dependencies**: No runtime dependencies; the published package is fully self-contained.
+- **Scalable pattern**: Can scale to fit your specific needs regardless of your project's size.
 
 ## Installation
 
@@ -25,26 +25,23 @@ npm install runtime-reporter
 
 ### 1) Define your messages
 
-Define the message “schema” (code + template + tokens), then create a `messages` record keyed by the codes.
+Define your messages by creating an object with the message "schema" (code + template + tokens) and keyed by their codes.
 
 ```ts
 import type { RuntimeReporterMessages } from "runtime-reporter";
 
-type MyMessages = Array<
+const messages: RuntimeReporterMessages<
     | {
           code: "ERR01";
-          template: "{{ componentName }} failed to mount";
-          tokens: ["componentName"];
+          template: "{{ componentName }} failed at {{ phase }}";
+          tokens: "componentName" | "phase";
       }
     | {
           code: "INFO01";
           template: "Ready";
-          tokens?: undefined;
       }
->;
-
-const messages: RuntimeReporterMessages<MyMessages> = {
-    ERR01: "{{ componentName }} failed to mount",
+> = {
+    ERR01: "{{ componentName }} failed at {{ phase }}",
     INFO01: "Ready",
 };
 ```
@@ -67,8 +64,8 @@ export const reporter = createReporter(
 Call the various reporter methods wherever you need them.
 
 ```ts
-reporter.error("ERR01", { componentName: "MyComponent" });
-// logs: "MyComponent failed to mount (ERR01)"
+reporter.error("ERR01", { componentName: "Router", phase: "mount" });
+// logs: "Router failed at mount (ERR01)"
 
 reporter.message("INFO01");
 // returns: "Ready (INFO01)"
@@ -107,6 +104,8 @@ Takes a list of messages, an optional set of configuration options, and returns
 
 ### Custom formatting
 
+You can customize the format of the message by providing a custom `formatMessage` function.
+
 ```ts
 const reporter = createReporter(messages, {
     formatMessage: (msg, code) => `[${code}] ${msg}`,
@@ -116,6 +115,32 @@ reporter.message("INFO01");
 // "[INFO01] Ready"
 ```
 
+### Using the reporter in production
+
+When the `createReporter` function is called in production with an empty message set, the `fail` method will use the customizable `defaultTemplate` option which defaults to "An error occurred". This message is intended to be generic so that it does not reveal sensitive information about the system, while still providing a code for debugging purposes.
+
+```ts
+const reporter = createReporter(
+    // Pass an empty object in production for better security and a smaller bundle size
+    process.env.NODE_ENV === "production" ? ({} as typeof messages) : messages
+);
+
+reporter.fail("ERR01", { componentName: "Router", phase: "mount" });
+// throws: "An error occurred (ERR01)"
+```
+
+The remaining reporter methods will not log anything in production when the code is missing from the message set.
+
+```ts
+const reporter = createReporter(
+    // Pass an empty object in production for better security and a smaller bundle size
+    process.env.NODE_ENV === "production" ? ({} as typeof messages) : messages
+);
+
+reporter.error("ERR01", { componentName: "Router", phase: "mount" });
+// does not log anything
+```
+
 ### Using `message()` in tests
 
 The `message` method returns the resolved string without side effects, allowing you to validate precise messaging without duplicating text.
@@ -129,18 +154,51 @@ describe("reporter messages", () => {
         vi.spyOn(console, "error").mockImplementation(() => {});
         reporter.error("ERR01", { componentName: "Widget" });
 
-        expect(console.error).toHaveBeenCalledWidth(
+        expect(console.error).toHaveBeenCalledWith(
             reporter.message("ERR01", { componentName: "Widget" })
         );
     });
 });
 ```
 
+### Using the reporter without TypeScript
+
+You can use the reporter without TypeScript, you will just lose the type safety and autocomplete.
+
+```js
+import { createReporter } from "runtime-reporter";
+
+const reporter = createReporter({
+    ERR01: "{{ componentName }} failed at {{ phase }}",
+});
+
+reporter.error("ERR01", { componentName: "Router", phase: "mount" });
+// logs: "Router failed at mount (ERR01)"
+```
+
+However, you can still get the same benefits as TypeScript by using JSDoc-style type annotations.
+
+```js
+/**
+ * @type {import("runtime-reporter").RuntimeReporterMessages<{
+ *     code: "ERR01";
+ *     template: "{{ componentName }} failed at {{ phase }}";
+ *     tokens: "componentName" | "phase";
+ * } | {
+ *     code: "INFO01";
+ *     template: "Ready";
+ * }>}
+ */
+const messages = {
+    ERR01: "{{ componentName }} failed at {{ phase }}",
+    INFO01: "Ready",
+};
+```
+
 ### CommonJS support
 
 If needed, Common JS imports are also available.
 
 ```js
-// CJS
 const { createReporter } = require("runtime-reporter");
 ```

package/dist/index.cjs

@@ -29,8 +29,8 @@ var resolveTemplate = function resolveTemplate2(template, tokens) {
     Object.entries(tokens || {}).forEach((entry) => {
       const [token, value] = entry;
       const replace = value instanceof Error ? value.message : String(value ?? "");
-      const santized = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      message = message.replace(new RegExp(`\\{\\{\\s*${santized}\\s*\\}\\}`, "g"), replace);
+      const sanitized = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      message = message.replace(new RegExp(`\\{\\{\\s*${sanitized}\\s*\\}\\}`, "g"), replace);
     });
   }
   return message;
@@ -40,27 +40,26 @@ function createReporter(messages, options = {}) {
     formatMessage = (message, code) => `${message} (${code})`,
     defaultTemplate = "An error occurred"
   } = options;
+  const messagesByCode = messages;
   const getMessage = function getMessage2(code, ...args) {
-    const template = messages[code] || defaultTemplate;
+    const template = messagesByCode[code] || defaultTemplate;
     const tokens = args[0];
     const text = resolveTemplate(template, tokens);
     return formatMessage(text, code);
   };
   return {
-    message: (code, ...args) => {
-      return getMessage(code, ...args);
-    },
+    message: (code, ...args) => getMessage(code, ...args),
     error: (code, ...args) => {
       const message = getMessage(code, ...args);
-      if (messages[code]) console.error(message);
+      if (messagesByCode[code]) console.error(message);
     },
     warn: (code, ...args) => {
       const message = getMessage(code, ...args);
-      if (messages[code]) console.warn(message);
+      if (messagesByCode[code]) console.warn(message);
     },
     log: (code, ...args) => {
       const message = getMessage(code, ...args);
-      if (messages[code]) console.log(message);
+      if (messagesByCode[code]) console.log(message);
     },
     fail: (code, ...args) => {
       const message = getMessage(code, ...args);

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * The type information for a single runtime reporter message\n * @since v0.1.0\n */\nexport type RuntimeReporterMessage = {\n    code: string;\n    template: string;\n    tokens?: string[];\n};\n\n/**\n * The type for a full list of messages with their associated code and template\n * @since v0.1.0\n */\nexport type RuntimeReporterMessages<T extends RuntimeReporterMessage[]> = {\n    [K in T[number][\"code\"]]: Extract<T[number], { code: K }>[\"template\"];\n};\n\n/**\n * The type for the supported values of a placeholder token\n * @since v0.1.0\n */\nexport type RuntimeReporterToken = string | number | boolean | Error | null | undefined;\n\n/**\n * The type for a record of placeholder token names and their values\n * @since v0.2.0\n */\nexport type RuntimeReporterTokens = Record<string, RuntimeReporterToken>;\n\n/**\n * A utility type used to determine the second argument of the runtime reporter methods\n * @private\n */\ntype RuntimeReporterTokensArgs<\n    T extends RuntimeReporterMessages<RuntimeReporterMessage[]>,\n    U extends keyof T,\n> =\n    T extends RuntimeReporterMessages<infer V extends RuntimeReporterMessage[]>\n        ? Extract<V[number], { code: U }>[\"tokens\"] extends infer Tokens\n            ? Tokens extends readonly string[]\n                ? [tokens: Record<Tokens[number], RuntimeReporterToken>]\n                : []\n            : []\n        : never;\n\n/**\n * The runtime report object with all of it's associated methods; the result\n * of the primary export: `createReporter`\n * @private\n */\ninterface RuntimeReporter<T extends RuntimeReporterMessages<RuntimeReporterMessage[]>> {\n    /**\n     * Retrieves the full text of the targeted message\n     *\n     * _Tip: This method is particularly useful in the test environment; allowing you\n     * to make precise assertions without having to duplicate an of the raw message text._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    message<U extends Extract<keyof T, string>>(\n        code: U,\n        ...args: RuntimeReporterTokensArgs<T, U>\n    ): string;\n\n    /**\n     * Logs a warning to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty array._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    warn<U extends Extract<keyof T, string>>(\n        code: U,\n        ...args: RuntimeReporterTokensArgs<T, U>\n    ): void;\n\n    /**\n     * Logs an error to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty array._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    error<U extends Extract<keyof T, string>>(\n        code: U,\n        ...args: RuntimeReporterTokensArgs<T, U>\n    ): void;\n\n    /**\n     * Logs a message to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty array._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    log<U extends Extract<keyof T, string>>(\n        code: U,\n        ...args: RuntimeReporterTokensArgs<T, U>\n    ): void;\n\n    /**\n     * Throws an error with the full text of the targeted message in all environments\n     *\n     * _Note: When the `createReporter` function is called in production with an empty\n     * array, this method will use the \"defaultTemplate\" option in this format: \"<defaultTemplate> (<code>)\"_\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    fail<U extends Extract<keyof T, string>>(\n        code: U,\n        ...args: RuntimeReporterTokensArgs<T, U>\n    ): void;\n}\n\nexport interface RuntimeReporterOptions {\n    /**\n     * A hook to format the message text univerally. By default, it\n     * outputs the message in the following format: \"<message> (<code>)\"\n     * @param message The resolved message text; the placeholders have been replaced by their token values\n     * @param code The unique code associated with the message\n     * @returns The final, fully formatted message\n     */\n    formatMessage?: (message: string, code: string) => string;\n\n    /**\n     * The default template to fallback on when a provided code does not\n     * have an associated message. Defaults to \"An error occurred\"\n     *\n     * _Note: This is only used when the `fail` method is called in production\n     * environments when the `createReporter` function is provided an empty array._\n     */\n    defaultTemplate?: string;\n}\n\n/**\n * Resolves the message text via the message template and the associated tokens\n * @param template The template string for the reported message\n * @param tokens The token names and values for the instance\n * @returns The resolved message text; returns an empty string if the template is falsy\n */\nconst resolveTemplate = function resolveTemplate(\n    template: string,\n    tokens?: Record<string, RuntimeReporterToken>\n): string {\n    let message = template;\n\n    if (message) {\n        Object.entries(tokens || {}).forEach((entry) => {\n            const [token, value] = entry;\n            const replace = value instanceof Error ? value.message : String(value ?? \"\");\n            const santized = token.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n            message = message.replace(new RegExp(`\\\\{\\\\{\\\\s*${santized}\\\\s*\\\\}\\\\}`, \"g\"), replace);\n        });\n    }\n\n    return message;\n};\n\n/**\n * Creates a reporter object with various helpful runtime methods\n * @param messages The messages record organized by code and template\n * @param options Optional configuration options\n * @returns A runtime report object\n */\nexport function createReporter<T extends RuntimeReporterMessages<RuntimeReporterMessage[]>>(\n    messages: T,\n    options: RuntimeReporterOptions = {}\n): RuntimeReporter<T> {\n    const {\n        formatMessage = (message, code) => `${message} (${code})`,\n        defaultTemplate = \"An error occurred\",\n    } = options;\n\n    /**\n     * Retrieves the final message for a give code and its associated tokens\n     * @param code The unique code associated with the message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     * @returns The fully resolve message or an empty string if there was no template\n     */\n    const getMessage = function getMessage(\n        code: string,\n        ...args: Array<Record<string, RuntimeReporterToken>>\n    ): string {\n        const template = messages[code] || defaultTemplate;\n        const tokens = args[0];\n        const text = resolveTemplate(template, tokens);\n        return formatMessage(text, code);\n    };\n\n    return {\n        message: (code, ...args) => {\n            return getMessage(code, ...args);\n        },\n        error: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messages[code]) console.error(message);\n        },\n        warn: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messages[code]) console.warn(message);\n        },\n        log: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messages[code]) console.log(message);\n        },\n        fail: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            throw new Error(message);\n        },\n    };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAmJA,IAAM,kBAAkB,SAASA,iBAC7B,UACA,QACM;AACN,MAAI,UAAU;AAEd,MAAI,SAAS;AACT,WAAO,QAAQ,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,UAAU;AAC5C,YAAM,CAAC,OAAO,KAAK,IAAI;AACvB,YAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,SAAS,EAAE;AAC3E,YAAM,WAAW,MAAM,QAAQ,uBAAuB,MAAM;AAC5D,gBAAU,QAAQ,QAAQ,IAAI,OAAO,aAAa,QAAQ,cAAc,GAAG,GAAG,OAAO;AAAA,IACzF,CAAC;AAAA,EACL;AAEA,SAAO;AACX;AAQO,SAAS,eACZ,UACA,UAAkC,CAAC,GACjB;AAClB,QAAM;AAAA,IACF,gBAAgB,CAAC,SAAS,SAAS,GAAG,OAAO,KAAK,IAAI;AAAA,IACtD,kBAAkB;AAAA,EACtB,IAAI;AAQJ,QAAM,aAAa,SAASC,YACxB,SACG,MACG;AACN,UAAM,WAAW,SAAS,IAAI,KAAK;AACnC,UAAM,SAAS,KAAK,CAAC;AACrB,UAAM,OAAO,gBAAgB,UAAU,MAAM;AAC7C,WAAO,cAAc,MAAM,IAAI;AAAA,EACnC;AAEA,SAAO;AAAA,IACH,SAAS,CAAC,SAAS,SAAS;AACxB,aAAO,WAAW,MAAM,GAAG,IAAI;AAAA,IACnC;AAAA,IACA,OAAO,CAAC,SAAS,SAAS;AACtB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,SAAS,IAAI,EAAG,SAAQ,MAAM,OAAO;AAAA,IAC7C;AAAA,IACA,MAAM,CAAC,SAAS,SAAS;AACrB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,SAAS,IAAI,EAAG,SAAQ,KAAK,OAAO;AAAA,IAC5C;AAAA,IACA,KAAK,CAAC,SAAS,SAAS;AACpB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,SAAS,IAAI,EAAG,SAAQ,IAAI,OAAO;AAAA,IAC3C;AAAA,IACA,MAAM,CAAC,SAAS,SAAS;AACrB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,YAAM,IAAI,MAAM,OAAO;AAAA,IAC3B;AAAA,EACJ;AACJ;","names":["resolveTemplate","getMessage"]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * The type information for a single runtime reporter message\n * @since v0.1.0\n */\nexport type RuntimeReporterMessage = {\n    code: string;\n    template: string;\n    tokens?: string;\n};\n\n/**\n * The type for a full list of messages with their associated code and template\n * @since v0.1.0\n */\nexport type RuntimeReporterMessages<T extends RuntimeReporterMessage> = {\n    [K in T[\"code\"]]: Extract<T, { code: K }>[\"template\"];\n};\n\n/**\n * The type for the supported values of a placeholder token\n * @since v0.1.0\n */\nexport type RuntimeReporterToken = string | number | boolean | Error | null | undefined;\n\n/**\n * The type for a record of placeholder token names and their values\n * @since v0.2.0\n */\nexport type RuntimeReporterTokens = Record<string, RuntimeReporterToken>;\n\n/**\n * A utility type used to determine the second argument of the runtime reporter methods\n * @private\n */\ntype ReporterTokensArgs<T extends RuntimeReporterMessage, U extends T[\"code\"]> = Extract<\n    T,\n    { code: U }\n>[\"tokens\"] extends infer Tokens\n    ? [Tokens] extends [string]\n        ? [tokens: Record<Tokens, RuntimeReporterToken>]\n        : []\n    : [];\n\n/**\n * Return type for message(); displays the template + code in default format on hover.\n * The runtime value is the resolved string (tokens substituted); the type is for DX only.\n * @private\n */\ntype MessageReturnType<T extends RuntimeReporterMessage, U extends T[\"code\"]> =\n    Extract<T, { code: U }> extends { template: infer Template }\n        ? Template extends string\n            ? `${Template} (${U})`\n            : string\n        : string;\n\n/**\n * The runtime report object with all of it's associated methods; the result\n * of the primary export: `createReporter`\n * @private\n */\ninterface RuntimeReporter<T extends RuntimeReporterMessage> {\n    /**\n     * Retrieves the full text of the targeted message\n     *\n     * _Note: As a convenience, the return type will attempt to show the literal type of the template\n     * pattern and code suffix (in the default format) for the message on hover; the actual output may\n     * vary based on the tokens provided and the `formatMessage` option._\n     *\n     * _Tip: This method is particularly useful in the test environment; allowing you\n     * to make precise assertions without having to duplicate any of the raw message text._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    message<U extends T[\"code\"]>(\n        code: U,\n        ...args: ReporterTokensArgs<T, U>\n    ): MessageReturnType<T, U>;\n\n    /**\n     * Logs a warning to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty message set._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    warn<U extends T[\"code\"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;\n\n    /**\n     * Logs an error to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty message set._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    error<U extends T[\"code\"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;\n\n    /**\n     * Logs a message to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty message set._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    log<U extends T[\"code\"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;\n\n    /**\n     * Throws an error with the full text of the targeted message in all environments\n     *\n     * _Note: When the `createReporter` function is called in production with an empty\n     * message set, this method will use the \"defaultTemplate\" option in this format: \"<defaultTemplate> (<code>)\"_\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    fail<U extends T[\"code\"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;\n}\n\nexport interface RuntimeReporterOptions {\n    /**\n     * A hook to format the message text universally. By default, it\n     * outputs the message in the following format: \"<message> (<code>)\"\n     * @param message The resolved message text; the placeholders have been replaced by their token values\n     * @param code The unique code associated with the message\n     * @returns The final, fully formatted message\n     */\n    formatMessage?: (message: string, code: string) => string;\n\n    /**\n     * The default template to fallback on when a provided code does not\n     * have an associated message. Defaults to \"An error occurred\"\n     *\n     * _Note: This is only used when the `fail` method is called in production\n     * environments when the `createReporter` function is provided an empty message set._\n     */\n    defaultTemplate?: string;\n}\n\n/**\n * Resolves the message text via the message template and the associated tokens\n * @param template The template string for the reported message\n * @param tokens The token names and values for the instance\n * @returns The resolved message text; returns an empty string if the template is falsy\n */\nconst resolveTemplate = function resolveTemplate(\n    template: string,\n    tokens?: Record<string, RuntimeReporterToken>\n): string {\n    let message = template;\n\n    if (message) {\n        Object.entries(tokens || {}).forEach((entry) => {\n            const [token, value] = entry;\n            const replace = value instanceof Error ? value.message : String(value ?? \"\");\n            const sanitized = token.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n            message = message.replace(new RegExp(`\\\\{\\\\{\\\\s*${sanitized}\\\\s*\\\\}\\\\}`, \"g\"), replace);\n        });\n    }\n\n    return message;\n};\n\n/**\n * Creates a reporter object with various helpful runtime methods\n * @param messages The messages record organized by code and template\n * @param options Optional configuration options\n * @returns A runtime report object\n */\nexport function createReporter<T extends RuntimeReporterMessage>(\n    messages: RuntimeReporterMessages<T>,\n    options: RuntimeReporterOptions = {}\n): RuntimeReporter<T> {\n    const {\n        formatMessage = (message, code) => `${message} (${code})`,\n        defaultTemplate = \"An error occurred\",\n    } = options;\n    const messagesByCode = messages as Record<string, string>;\n\n    /**\n     * Retrieves the final message for a give code and its associated tokens\n     * @param code The unique code associated with the message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     * @returns The fully resolve message or an empty string if there was no template\n     */\n    const getMessage = function getMessage(\n        code: string,\n        ...args: Array<Record<string, RuntimeReporterToken>>\n    ): string {\n        const template = messagesByCode[code] || defaultTemplate;\n        const tokens = args[0];\n        const text = resolveTemplate(template, tokens);\n        return formatMessage(text, code);\n    };\n\n    return {\n        message: (code, ...args) =>\n            getMessage(code, ...args) as MessageReturnType<T, typeof code & T[\"code\"]>,\n        error: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messagesByCode[code]) console.error(message);\n        },\n        warn: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messagesByCode[code]) console.warn(message);\n        },\n        log: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messagesByCode[code]) console.log(message);\n        },\n        fail: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            throw new Error(message);\n        },\n    };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoJA,IAAM,kBAAkB,SAASA,iBAC7B,UACA,QACM;AACN,MAAI,UAAU;AAEd,MAAI,SAAS;AACT,WAAO,QAAQ,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,UAAU;AAC5C,YAAM,CAAC,OAAO,KAAK,IAAI;AACvB,YAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,SAAS,EAAE;AAC3E,YAAM,YAAY,MAAM,QAAQ,uBAAuB,MAAM;AAC7D,gBAAU,QAAQ,QAAQ,IAAI,OAAO,aAAa,SAAS,cAAc,GAAG,GAAG,OAAO;AAAA,IAC1F,CAAC;AAAA,EACL;AAEA,SAAO;AACX;AAQO,SAAS,eACZ,UACA,UAAkC,CAAC,GACjB;AAClB,QAAM;AAAA,IACF,gBAAgB,CAAC,SAAS,SAAS,GAAG,OAAO,KAAK,IAAI;AAAA,IACtD,kBAAkB;AAAA,EACtB,IAAI;AACJ,QAAM,iBAAiB;AAQvB,QAAM,aAAa,SAASC,YACxB,SACG,MACG;AACN,UAAM,WAAW,eAAe,IAAI,KAAK;AACzC,UAAM,SAAS,KAAK,CAAC;AACrB,UAAM,OAAO,gBAAgB,UAAU,MAAM;AAC7C,WAAO,cAAc,MAAM,IAAI;AAAA,EACnC;AAEA,SAAO;AAAA,IACH,SAAS,CAAC,SAAS,SACf,WAAW,MAAM,GAAG,IAAI;AAAA,IAC5B,OAAO,CAAC,SAAS,SAAS;AACtB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,eAAe,IAAI,EAAG,SAAQ,MAAM,OAAO;AAAA,IACnD;AAAA,IACA,MAAM,CAAC,SAAS,SAAS;AACrB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,eAAe,IAAI,EAAG,SAAQ,KAAK,OAAO;AAAA,IAClD;AAAA,IACA,KAAK,CAAC,SAAS,SAAS;AACpB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,eAAe,IAAI,EAAG,SAAQ,IAAI,OAAO;AAAA,IACjD;AAAA,IACA,MAAM,CAAC,SAAS,SAAS;AACrB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,YAAM,IAAI,MAAM,OAAO;AAAA,IAC3B;AAAA,EACJ;AACJ;","names":["resolveTemplate","getMessage"]}

package/dist/index.d.cts

@@ -5,14 +5,14 @@
 type RuntimeReporterMessage = {
     code: string;
     template: string;
-    tokens?: string[];
+    tokens?: string;
 };
 /**
  * The type for a full list of messages with their associated code and template
  * @since v0.1.0
  */
-type RuntimeReporterMessages<T extends RuntimeReporterMessage[]> = {
-    [K in T[number]["code"]]: Extract<T[number], {
+type RuntimeReporterMessages<T extends RuntimeReporterMessage> = {
+    [K in T["code"]]: Extract<T, {
         code: K;
     }>["template"];
 };
@@ -30,67 +30,81 @@ type RuntimeReporterTokens = Record<string, RuntimeReporterToken>;
  * A utility type used to determine the second argument of the runtime reporter methods
  * @private
  */
-type RuntimeReporterTokensArgs<T extends RuntimeReporterMessages<RuntimeReporterMessage[]>, U extends keyof T> = T extends RuntimeReporterMessages<infer V extends RuntimeReporterMessage[]> ? Extract<V[number], {
+type ReporterTokensArgs<T extends RuntimeReporterMessage, U extends T["code"]> = Extract<T, {
     code: U;
-}>["tokens"] extends infer Tokens ? Tokens extends readonly string[] ? [tokens: Record<Tokens[number], RuntimeReporterToken>] : [] : [] : never;
+}>["tokens"] extends infer Tokens ? [Tokens] extends [string] ? [tokens: Record<Tokens, RuntimeReporterToken>] : [] : [];
+/**
+ * Return type for message(); displays the template + code in default format on hover.
+ * The runtime value is the resolved string (tokens substituted); the type is for DX only.
+ * @private
+ */
+type MessageReturnType<T extends RuntimeReporterMessage, U extends T["code"]> = Extract<T, {
+    code: U;
+}> extends {
+    template: infer Template;
+} ? Template extends string ? `${Template} (${U})` : string : string;
 /**
  * The runtime report object with all of it's associated methods; the result
  * of the primary export: `createReporter`
  * @private
  */
-interface RuntimeReporter<T extends RuntimeReporterMessages<RuntimeReporterMessage[]>> {
+interface RuntimeReporter<T extends RuntimeReporterMessage> {
     /**
      * Retrieves the full text of the targeted message
      *
+     * _Note: As a convenience, the return type will attempt to show the literal type of the template
+     * pattern and code suffix (in the default format) for the message on hover; the actual output may
+     * vary based on the tokens provided and the `formatMessage` option._
+     *
      * _Tip: This method is particularly useful in the test environment; allowing you
-     * to make precise assertions without having to duplicate an of the raw message text._
+     * to make precise assertions without having to duplicate any of the raw message text._
      * @param code A direct reference to the unique code for the targeted message
      * @param args The remaining optional argument for the function; a record containing the placeholder token values
      */
-    message<U extends Extract<keyof T, string>>(code: U, ...args: RuntimeReporterTokensArgs<T, U>): string;
+    message<U extends T["code"]>(code: U, ...args: ReporterTokensArgs<T, U>): MessageReturnType<T, U>;
     /**
      * Logs a warning to the console with the full text of the targeted message in non-production environments
      *
      * _Note: This method will only log when the message associated with the code is found;
      * meaning it will not be called in production if the `createReporter` function
-     * is provided an empty array._
+     * is provided an empty message set._
      * @param code A direct reference to the unique code for the targeted message
      * @param args The remaining optional argument for the function; a record containing the placeholder token values
      */
-    warn<U extends Extract<keyof T, string>>(code: U, ...args: RuntimeReporterTokensArgs<T, U>): void;
+    warn<U extends T["code"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;
     /**
      * Logs an error to the console with the full text of the targeted message in non-production environments
      *
      * _Note: This method will only log when the message associated with the code is found;
      * meaning it will not be called in production if the `createReporter` function
-     * is provided an empty array._
+     * is provided an empty message set._
      * @param code A direct reference to the unique code for the targeted message
      * @param args The remaining optional argument for the function; a record containing the placeholder token values
      */
-    error<U extends Extract<keyof T, string>>(code: U, ...args: RuntimeReporterTokensArgs<T, U>): void;
+    error<U extends T["code"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;
     /**
      * Logs a message to the console with the full text of the targeted message in non-production environments
      *
      * _Note: This method will only log when the message associated with the code is found;
      * meaning it will not be called in production if the `createReporter` function
-     * is provided an empty array._
+     * is provided an empty message set._
      * @param code A direct reference to the unique code for the targeted message
      * @param args The remaining optional argument for the function; a record containing the placeholder token values
      */
-    log<U extends Extract<keyof T, string>>(code: U, ...args: RuntimeReporterTokensArgs<T, U>): void;
+    log<U extends T["code"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;
     /**
      * Throws an error with the full text of the targeted message in all environments
      *
      * _Note: When the `createReporter` function is called in production with an empty
-     * array, this method will use the "defaultTemplate" option in this format: "<defaultTemplate> (<code>)"_
+     * message set, this method will use the "defaultTemplate" option in this format: "<defaultTemplate> (<code>)"_
      * @param code A direct reference to the unique code for the targeted message
      * @param args The remaining optional argument for the function; a record containing the placeholder token values
      */
-    fail<U extends Extract<keyof T, string>>(code: U, ...args: RuntimeReporterTokensArgs<T, U>): void;
+    fail<U extends T["code"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;
 }
 interface RuntimeReporterOptions {
     /**
-     * A hook to format the message text univerally. By default, it
+     * A hook to format the message text universally. By default, it
      * outputs the message in the following format: "<message> (<code>)"
      * @param message The resolved message text; the placeholders have been replaced by their token values
      * @param code The unique code associated with the message
@@ -102,7 +116,7 @@ interface RuntimeReporterOptions {
      * have an associated message. Defaults to "An error occurred"
      *
      * _Note: This is only used when the `fail` method is called in production
-     * environments when the `createReporter` function is provided an empty array._
+     * environments when the `createReporter` function is provided an empty message set._
      */
     defaultTemplate?: string;
 }
@@ -112,6 +126,6 @@ interface RuntimeReporterOptions {
  * @param options Optional configuration options
  * @returns A runtime report object
  */
-declare function createReporter<T extends RuntimeReporterMessages<RuntimeReporterMessage[]>>(messages: T, options?: RuntimeReporterOptions): RuntimeReporter<T>;
+declare function createReporter<T extends RuntimeReporterMessage>(messages: RuntimeReporterMessages<T>, options?: RuntimeReporterOptions): RuntimeReporter<T>;
 
 export { type RuntimeReporterMessage, type RuntimeReporterMessages, type RuntimeReporterOptions, type RuntimeReporterToken, type RuntimeReporterTokens, createReporter };

package/dist/index.d.ts

@@ -5,14 +5,14 @@
 type RuntimeReporterMessage = {
     code: string;
     template: string;
-    tokens?: string[];
+    tokens?: string;
 };
 /**
  * The type for a full list of messages with their associated code and template
  * @since v0.1.0
  */
-type RuntimeReporterMessages<T extends RuntimeReporterMessage[]> = {
-    [K in T[number]["code"]]: Extract<T[number], {
+type RuntimeReporterMessages<T extends RuntimeReporterMessage> = {
+    [K in T["code"]]: Extract<T, {
         code: K;
     }>["template"];
 };
@@ -30,67 +30,81 @@ type RuntimeReporterTokens = Record<string, RuntimeReporterToken>;
  * A utility type used to determine the second argument of the runtime reporter methods
  * @private
  */
-type RuntimeReporterTokensArgs<T extends RuntimeReporterMessages<RuntimeReporterMessage[]>, U extends keyof T> = T extends RuntimeReporterMessages<infer V extends RuntimeReporterMessage[]> ? Extract<V[number], {
+type ReporterTokensArgs<T extends RuntimeReporterMessage, U extends T["code"]> = Extract<T, {
     code: U;
-}>["tokens"] extends infer Tokens ? Tokens extends readonly string[] ? [tokens: Record<Tokens[number], RuntimeReporterToken>] : [] : [] : never;
+}>["tokens"] extends infer Tokens ? [Tokens] extends [string] ? [tokens: Record<Tokens, RuntimeReporterToken>] : [] : [];
+/**
+ * Return type for message(); displays the template + code in default format on hover.
+ * The runtime value is the resolved string (tokens substituted); the type is for DX only.
+ * @private
+ */
+type MessageReturnType<T extends RuntimeReporterMessage, U extends T["code"]> = Extract<T, {
+    code: U;
+}> extends {
+    template: infer Template;
+} ? Template extends string ? `${Template} (${U})` : string : string;
 /**
  * The runtime report object with all of it's associated methods; the result
  * of the primary export: `createReporter`
  * @private
  */
-interface RuntimeReporter<T extends RuntimeReporterMessages<RuntimeReporterMessage[]>> {
+interface RuntimeReporter<T extends RuntimeReporterMessage> {
     /**
      * Retrieves the full text of the targeted message
      *
+     * _Note: As a convenience, the return type will attempt to show the literal type of the template
+     * pattern and code suffix (in the default format) for the message on hover; the actual output may
+     * vary based on the tokens provided and the `formatMessage` option._
+     *
      * _Tip: This method is particularly useful in the test environment; allowing you
-     * to make precise assertions without having to duplicate an of the raw message text._
+     * to make precise assertions without having to duplicate any of the raw message text._
      * @param code A direct reference to the unique code for the targeted message
      * @param args The remaining optional argument for the function; a record containing the placeholder token values
      */
-    message<U extends Extract<keyof T, string>>(code: U, ...args: RuntimeReporterTokensArgs<T, U>): string;
+    message<U extends T["code"]>(code: U, ...args: ReporterTokensArgs<T, U>): MessageReturnType<T, U>;
     /**
      * Logs a warning to the console with the full text of the targeted message in non-production environments
      *
      * _Note: This method will only log when the message associated with the code is found;
      * meaning it will not be called in production if the `createReporter` function
-     * is provided an empty array._
+     * is provided an empty message set._
      * @param code A direct reference to the unique code for the targeted message
      * @param args The remaining optional argument for the function; a record containing the placeholder token values
      */
-    warn<U extends Extract<keyof T, string>>(code: U, ...args: RuntimeReporterTokensArgs<T, U>): void;
+    warn<U extends T["code"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;
     /**
      * Logs an error to the console with the full text of the targeted message in non-production environments
      *
      * _Note: This method will only log when the message associated with the code is found;
      * meaning it will not be called in production if the `createReporter` function
-     * is provided an empty array._
+     * is provided an empty message set._
      * @param code A direct reference to the unique code for the targeted message
      * @param args The remaining optional argument for the function; a record containing the placeholder token values
      */
-    error<U extends Extract<keyof T, string>>(code: U, ...args: RuntimeReporterTokensArgs<T, U>): void;
+    error<U extends T["code"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;
     /**
      * Logs a message to the console with the full text of the targeted message in non-production environments
      *
      * _Note: This method will only log when the message associated with the code is found;
      * meaning it will not be called in production if the `createReporter` function
-     * is provided an empty array._
+     * is provided an empty message set._
      * @param code A direct reference to the unique code for the targeted message
      * @param args The remaining optional argument for the function; a record containing the placeholder token values
      */
-    log<U extends Extract<keyof T, string>>(code: U, ...args: RuntimeReporterTokensArgs<T, U>): void;
+    log<U extends T["code"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;
     /**
      * Throws an error with the full text of the targeted message in all environments
      *
      * _Note: When the `createReporter` function is called in production with an empty
-     * array, this method will use the "defaultTemplate" option in this format: "<defaultTemplate> (<code>)"_
+     * message set, this method will use the "defaultTemplate" option in this format: "<defaultTemplate> (<code>)"_
      * @param code A direct reference to the unique code for the targeted message
      * @param args The remaining optional argument for the function; a record containing the placeholder token values
      */
-    fail<U extends Extract<keyof T, string>>(code: U, ...args: RuntimeReporterTokensArgs<T, U>): void;
+    fail<U extends T["code"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;
 }
 interface RuntimeReporterOptions {
     /**
-     * A hook to format the message text univerally. By default, it
+     * A hook to format the message text universally. By default, it
      * outputs the message in the following format: "<message> (<code>)"
      * @param message The resolved message text; the placeholders have been replaced by their token values
      * @param code The unique code associated with the message
@@ -102,7 +116,7 @@ interface RuntimeReporterOptions {
      * have an associated message. Defaults to "An error occurred"
      *
      * _Note: This is only used when the `fail` method is called in production
-     * environments when the `createReporter` function is provided an empty array._
+     * environments when the `createReporter` function is provided an empty message set._
      */
     defaultTemplate?: string;
 }
@@ -112,6 +126,6 @@ interface RuntimeReporterOptions {
  * @param options Optional configuration options
  * @returns A runtime report object
  */
-declare function createReporter<T extends RuntimeReporterMessages<RuntimeReporterMessage[]>>(messages: T, options?: RuntimeReporterOptions): RuntimeReporter<T>;
+declare function createReporter<T extends RuntimeReporterMessage>(messages: RuntimeReporterMessages<T>, options?: RuntimeReporterOptions): RuntimeReporter<T>;
 
 export { type RuntimeReporterMessage, type RuntimeReporterMessages, type RuntimeReporterOptions, type RuntimeReporterToken, type RuntimeReporterTokens, createReporter };

package/dist/index.js

@@ -5,8 +5,8 @@ var resolveTemplate = function resolveTemplate2(template, tokens) {
     Object.entries(tokens || {}).forEach((entry) => {
       const [token, value] = entry;
       const replace = value instanceof Error ? value.message : String(value ?? "");
-      const santized = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      message = message.replace(new RegExp(`\\{\\{\\s*${santized}\\s*\\}\\}`, "g"), replace);
+      const sanitized = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      message = message.replace(new RegExp(`\\{\\{\\s*${sanitized}\\s*\\}\\}`, "g"), replace);
     });
   }
   return message;
@@ -16,27 +16,26 @@ function createReporter(messages, options = {}) {
     formatMessage = (message, code) => `${message} (${code})`,
     defaultTemplate = "An error occurred"
   } = options;
+  const messagesByCode = messages;
   const getMessage = function getMessage2(code, ...args) {
-    const template = messages[code] || defaultTemplate;
+    const template = messagesByCode[code] || defaultTemplate;
     const tokens = args[0];
     const text = resolveTemplate(template, tokens);
     return formatMessage(text, code);
   };
   return {
-    message: (code, ...args) => {
-      return getMessage(code, ...args);
-    },
+    message: (code, ...args) => getMessage(code, ...args),
     error: (code, ...args) => {
       const message = getMessage(code, ...args);
-      if (messages[code]) console.error(message);
+      if (messagesByCode[code]) console.error(message);
     },
     warn: (code, ...args) => {
       const message = getMessage(code, ...args);
-      if (messages[code]) console.warn(message);
+      if (messagesByCode[code]) console.warn(message);
     },
     log: (code, ...args) => {
       const message = getMessage(code, ...args);
-      if (messages[code]) console.log(message);
+      if (messagesByCode[code]) console.log(message);
     },
     fail: (code, ...args) => {
       const message = getMessage(code, ...args);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * The type information for a single runtime reporter message\n * @since v0.1.0\n */\nexport type RuntimeReporterMessage = {\n    code: string;\n    template: string;\n    tokens?: string[];\n};\n\n/**\n * The type for a full list of messages with their associated code and template\n * @since v0.1.0\n */\nexport type RuntimeReporterMessages<T extends RuntimeReporterMessage[]> = {\n    [K in T[number][\"code\"]]: Extract<T[number], { code: K }>[\"template\"];\n};\n\n/**\n * The type for the supported values of a placeholder token\n * @since v0.1.0\n */\nexport type RuntimeReporterToken = string | number | boolean | Error | null | undefined;\n\n/**\n * The type for a record of placeholder token names and their values\n * @since v0.2.0\n */\nexport type RuntimeReporterTokens = Record<string, RuntimeReporterToken>;\n\n/**\n * A utility type used to determine the second argument of the runtime reporter methods\n * @private\n */\ntype RuntimeReporterTokensArgs<\n    T extends RuntimeReporterMessages<RuntimeReporterMessage[]>,\n    U extends keyof T,\n> =\n    T extends RuntimeReporterMessages<infer V extends RuntimeReporterMessage[]>\n        ? Extract<V[number], { code: U }>[\"tokens\"] extends infer Tokens\n            ? Tokens extends readonly string[]\n                ? [tokens: Record<Tokens[number], RuntimeReporterToken>]\n                : []\n            : []\n        : never;\n\n/**\n * The runtime report object with all of it's associated methods; the result\n * of the primary export: `createReporter`\n * @private\n */\ninterface RuntimeReporter<T extends RuntimeReporterMessages<RuntimeReporterMessage[]>> {\n    /**\n     * Retrieves the full text of the targeted message\n     *\n     * _Tip: This method is particularly useful in the test environment; allowing you\n     * to make precise assertions without having to duplicate an of the raw message text._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    message<U extends Extract<keyof T, string>>(\n        code: U,\n        ...args: RuntimeReporterTokensArgs<T, U>\n    ): string;\n\n    /**\n     * Logs a warning to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty array._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    warn<U extends Extract<keyof T, string>>(\n        code: U,\n        ...args: RuntimeReporterTokensArgs<T, U>\n    ): void;\n\n    /**\n     * Logs an error to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty array._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    error<U extends Extract<keyof T, string>>(\n        code: U,\n        ...args: RuntimeReporterTokensArgs<T, U>\n    ): void;\n\n    /**\n     * Logs a message to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty array._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    log<U extends Extract<keyof T, string>>(\n        code: U,\n        ...args: RuntimeReporterTokensArgs<T, U>\n    ): void;\n\n    /**\n     * Throws an error with the full text of the targeted message in all environments\n     *\n     * _Note: When the `createReporter` function is called in production with an empty\n     * array, this method will use the \"defaultTemplate\" option in this format: \"<defaultTemplate> (<code>)\"_\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    fail<U extends Extract<keyof T, string>>(\n        code: U,\n        ...args: RuntimeReporterTokensArgs<T, U>\n    ): void;\n}\n\nexport interface RuntimeReporterOptions {\n    /**\n     * A hook to format the message text univerally. By default, it\n     * outputs the message in the following format: \"<message> (<code>)\"\n     * @param message The resolved message text; the placeholders have been replaced by their token values\n     * @param code The unique code associated with the message\n     * @returns The final, fully formatted message\n     */\n    formatMessage?: (message: string, code: string) => string;\n\n    /**\n     * The default template to fallback on when a provided code does not\n     * have an associated message. Defaults to \"An error occurred\"\n     *\n     * _Note: This is only used when the `fail` method is called in production\n     * environments when the `createReporter` function is provided an empty array._\n     */\n    defaultTemplate?: string;\n}\n\n/**\n * Resolves the message text via the message template and the associated tokens\n * @param template The template string for the reported message\n * @param tokens The token names and values for the instance\n * @returns The resolved message text; returns an empty string if the template is falsy\n */\nconst resolveTemplate = function resolveTemplate(\n    template: string,\n    tokens?: Record<string, RuntimeReporterToken>\n): string {\n    let message = template;\n\n    if (message) {\n        Object.entries(tokens || {}).forEach((entry) => {\n            const [token, value] = entry;\n            const replace = value instanceof Error ? value.message : String(value ?? \"\");\n            const santized = token.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n            message = message.replace(new RegExp(`\\\\{\\\\{\\\\s*${santized}\\\\s*\\\\}\\\\}`, \"g\"), replace);\n        });\n    }\n\n    return message;\n};\n\n/**\n * Creates a reporter object with various helpful runtime methods\n * @param messages The messages record organized by code and template\n * @param options Optional configuration options\n * @returns A runtime report object\n */\nexport function createReporter<T extends RuntimeReporterMessages<RuntimeReporterMessage[]>>(\n    messages: T,\n    options: RuntimeReporterOptions = {}\n): RuntimeReporter<T> {\n    const {\n        formatMessage = (message, code) => `${message} (${code})`,\n        defaultTemplate = \"An error occurred\",\n    } = options;\n\n    /**\n     * Retrieves the final message for a give code and its associated tokens\n     * @param code The unique code associated with the message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     * @returns The fully resolve message or an empty string if there was no template\n     */\n    const getMessage = function getMessage(\n        code: string,\n        ...args: Array<Record<string, RuntimeReporterToken>>\n    ): string {\n        const template = messages[code] || defaultTemplate;\n        const tokens = args[0];\n        const text = resolveTemplate(template, tokens);\n        return formatMessage(text, code);\n    };\n\n    return {\n        message: (code, ...args) => {\n            return getMessage(code, ...args);\n        },\n        error: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messages[code]) console.error(message);\n        },\n        warn: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messages[code]) console.warn(message);\n        },\n        log: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messages[code]) console.log(message);\n        },\n        fail: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            throw new Error(message);\n        },\n    };\n}\n"],"mappings":";AAmJA,IAAM,kBAAkB,SAASA,iBAC7B,UACA,QACM;AACN,MAAI,UAAU;AAEd,MAAI,SAAS;AACT,WAAO,QAAQ,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,UAAU;AAC5C,YAAM,CAAC,OAAO,KAAK,IAAI;AACvB,YAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,SAAS,EAAE;AAC3E,YAAM,WAAW,MAAM,QAAQ,uBAAuB,MAAM;AAC5D,gBAAU,QAAQ,QAAQ,IAAI,OAAO,aAAa,QAAQ,cAAc,GAAG,GAAG,OAAO;AAAA,IACzF,CAAC;AAAA,EACL;AAEA,SAAO;AACX;AAQO,SAAS,eACZ,UACA,UAAkC,CAAC,GACjB;AAClB,QAAM;AAAA,IACF,gBAAgB,CAAC,SAAS,SAAS,GAAG,OAAO,KAAK,IAAI;AAAA,IACtD,kBAAkB;AAAA,EACtB,IAAI;AAQJ,QAAM,aAAa,SAASC,YACxB,SACG,MACG;AACN,UAAM,WAAW,SAAS,IAAI,KAAK;AACnC,UAAM,SAAS,KAAK,CAAC;AACrB,UAAM,OAAO,gBAAgB,UAAU,MAAM;AAC7C,WAAO,cAAc,MAAM,IAAI;AAAA,EACnC;AAEA,SAAO;AAAA,IACH,SAAS,CAAC,SAAS,SAAS;AACxB,aAAO,WAAW,MAAM,GAAG,IAAI;AAAA,IACnC;AAAA,IACA,OAAO,CAAC,SAAS,SAAS;AACtB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,SAAS,IAAI,EAAG,SAAQ,MAAM,OAAO;AAAA,IAC7C;AAAA,IACA,MAAM,CAAC,SAAS,SAAS;AACrB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,SAAS,IAAI,EAAG,SAAQ,KAAK,OAAO;AAAA,IAC5C;AAAA,IACA,KAAK,CAAC,SAAS,SAAS;AACpB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,SAAS,IAAI,EAAG,SAAQ,IAAI,OAAO;AAAA,IAC3C;AAAA,IACA,MAAM,CAAC,SAAS,SAAS;AACrB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,YAAM,IAAI,MAAM,OAAO;AAAA,IAC3B;AAAA,EACJ;AACJ;","names":["resolveTemplate","getMessage"]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * The type information for a single runtime reporter message\n * @since v0.1.0\n */\nexport type RuntimeReporterMessage = {\n    code: string;\n    template: string;\n    tokens?: string;\n};\n\n/**\n * The type for a full list of messages with their associated code and template\n * @since v0.1.0\n */\nexport type RuntimeReporterMessages<T extends RuntimeReporterMessage> = {\n    [K in T[\"code\"]]: Extract<T, { code: K }>[\"template\"];\n};\n\n/**\n * The type for the supported values of a placeholder token\n * @since v0.1.0\n */\nexport type RuntimeReporterToken = string | number | boolean | Error | null | undefined;\n\n/**\n * The type for a record of placeholder token names and their values\n * @since v0.2.0\n */\nexport type RuntimeReporterTokens = Record<string, RuntimeReporterToken>;\n\n/**\n * A utility type used to determine the second argument of the runtime reporter methods\n * @private\n */\ntype ReporterTokensArgs<T extends RuntimeReporterMessage, U extends T[\"code\"]> = Extract<\n    T,\n    { code: U }\n>[\"tokens\"] extends infer Tokens\n    ? [Tokens] extends [string]\n        ? [tokens: Record<Tokens, RuntimeReporterToken>]\n        : []\n    : [];\n\n/**\n * Return type for message(); displays the template + code in default format on hover.\n * The runtime value is the resolved string (tokens substituted); the type is for DX only.\n * @private\n */\ntype MessageReturnType<T extends RuntimeReporterMessage, U extends T[\"code\"]> =\n    Extract<T, { code: U }> extends { template: infer Template }\n        ? Template extends string\n            ? `${Template} (${U})`\n            : string\n        : string;\n\n/**\n * The runtime report object with all of it's associated methods; the result\n * of the primary export: `createReporter`\n * @private\n */\ninterface RuntimeReporter<T extends RuntimeReporterMessage> {\n    /**\n     * Retrieves the full text of the targeted message\n     *\n     * _Note: As a convenience, the return type will attempt to show the literal type of the template\n     * pattern and code suffix (in the default format) for the message on hover; the actual output may\n     * vary based on the tokens provided and the `formatMessage` option._\n     *\n     * _Tip: This method is particularly useful in the test environment; allowing you\n     * to make precise assertions without having to duplicate any of the raw message text._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    message<U extends T[\"code\"]>(\n        code: U,\n        ...args: ReporterTokensArgs<T, U>\n    ): MessageReturnType<T, U>;\n\n    /**\n     * Logs a warning to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty message set._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    warn<U extends T[\"code\"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;\n\n    /**\n     * Logs an error to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty message set._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    error<U extends T[\"code\"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;\n\n    /**\n     * Logs a message to the console with the full text of the targeted message in non-production environments\n     *\n     * _Note: This method will only log when the message associated with the code is found;\n     * meaning it will not be called in production if the `createReporter` function\n     * is provided an empty message set._\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    log<U extends T[\"code\"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;\n\n    /**\n     * Throws an error with the full text of the targeted message in all environments\n     *\n     * _Note: When the `createReporter` function is called in production with an empty\n     * message set, this method will use the \"defaultTemplate\" option in this format: \"<defaultTemplate> (<code>)\"_\n     * @param code A direct reference to the unique code for the targeted message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     */\n    fail<U extends T[\"code\"]>(code: U, ...args: ReporterTokensArgs<T, U>): void;\n}\n\nexport interface RuntimeReporterOptions {\n    /**\n     * A hook to format the message text universally. By default, it\n     * outputs the message in the following format: \"<message> (<code>)\"\n     * @param message The resolved message text; the placeholders have been replaced by their token values\n     * @param code The unique code associated with the message\n     * @returns The final, fully formatted message\n     */\n    formatMessage?: (message: string, code: string) => string;\n\n    /**\n     * The default template to fallback on when a provided code does not\n     * have an associated message. Defaults to \"An error occurred\"\n     *\n     * _Note: This is only used when the `fail` method is called in production\n     * environments when the `createReporter` function is provided an empty message set._\n     */\n    defaultTemplate?: string;\n}\n\n/**\n * Resolves the message text via the message template and the associated tokens\n * @param template The template string for the reported message\n * @param tokens The token names and values for the instance\n * @returns The resolved message text; returns an empty string if the template is falsy\n */\nconst resolveTemplate = function resolveTemplate(\n    template: string,\n    tokens?: Record<string, RuntimeReporterToken>\n): string {\n    let message = template;\n\n    if (message) {\n        Object.entries(tokens || {}).forEach((entry) => {\n            const [token, value] = entry;\n            const replace = value instanceof Error ? value.message : String(value ?? \"\");\n            const sanitized = token.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n            message = message.replace(new RegExp(`\\\\{\\\\{\\\\s*${sanitized}\\\\s*\\\\}\\\\}`, \"g\"), replace);\n        });\n    }\n\n    return message;\n};\n\n/**\n * Creates a reporter object with various helpful runtime methods\n * @param messages The messages record organized by code and template\n * @param options Optional configuration options\n * @returns A runtime report object\n */\nexport function createReporter<T extends RuntimeReporterMessage>(\n    messages: RuntimeReporterMessages<T>,\n    options: RuntimeReporterOptions = {}\n): RuntimeReporter<T> {\n    const {\n        formatMessage = (message, code) => `${message} (${code})`,\n        defaultTemplate = \"An error occurred\",\n    } = options;\n    const messagesByCode = messages as Record<string, string>;\n\n    /**\n     * Retrieves the final message for a give code and its associated tokens\n     * @param code The unique code associated with the message\n     * @param args The remaining optional argument for the function; a record containing the placeholder token values\n     * @returns The fully resolve message or an empty string if there was no template\n     */\n    const getMessage = function getMessage(\n        code: string,\n        ...args: Array<Record<string, RuntimeReporterToken>>\n    ): string {\n        const template = messagesByCode[code] || defaultTemplate;\n        const tokens = args[0];\n        const text = resolveTemplate(template, tokens);\n        return formatMessage(text, code);\n    };\n\n    return {\n        message: (code, ...args) =>\n            getMessage(code, ...args) as MessageReturnType<T, typeof code & T[\"code\"]>,\n        error: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messagesByCode[code]) console.error(message);\n        },\n        warn: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messagesByCode[code]) console.warn(message);\n        },\n        log: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            if (messagesByCode[code]) console.log(message);\n        },\n        fail: (code, ...args) => {\n            const message = getMessage(code, ...args);\n            throw new Error(message);\n        },\n    };\n}\n"],"mappings":";AAoJA,IAAM,kBAAkB,SAASA,iBAC7B,UACA,QACM;AACN,MAAI,UAAU;AAEd,MAAI,SAAS;AACT,WAAO,QAAQ,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,UAAU;AAC5C,YAAM,CAAC,OAAO,KAAK,IAAI;AACvB,YAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,SAAS,EAAE;AAC3E,YAAM,YAAY,MAAM,QAAQ,uBAAuB,MAAM;AAC7D,gBAAU,QAAQ,QAAQ,IAAI,OAAO,aAAa,SAAS,cAAc,GAAG,GAAG,OAAO;AAAA,IAC1F,CAAC;AAAA,EACL;AAEA,SAAO;AACX;AAQO,SAAS,eACZ,UACA,UAAkC,CAAC,GACjB;AAClB,QAAM;AAAA,IACF,gBAAgB,CAAC,SAAS,SAAS,GAAG,OAAO,KAAK,IAAI;AAAA,IACtD,kBAAkB;AAAA,EACtB,IAAI;AACJ,QAAM,iBAAiB;AAQvB,QAAM,aAAa,SAASC,YACxB,SACG,MACG;AACN,UAAM,WAAW,eAAe,IAAI,KAAK;AACzC,UAAM,SAAS,KAAK,CAAC;AACrB,UAAM,OAAO,gBAAgB,UAAU,MAAM;AAC7C,WAAO,cAAc,MAAM,IAAI;AAAA,EACnC;AAEA,SAAO;AAAA,IACH,SAAS,CAAC,SAAS,SACf,WAAW,MAAM,GAAG,IAAI;AAAA,IAC5B,OAAO,CAAC,SAAS,SAAS;AACtB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,eAAe,IAAI,EAAG,SAAQ,MAAM,OAAO;AAAA,IACnD;AAAA,IACA,MAAM,CAAC,SAAS,SAAS;AACrB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,eAAe,IAAI,EAAG,SAAQ,KAAK,OAAO;AAAA,IAClD;AAAA,IACA,KAAK,CAAC,SAAS,SAAS;AACpB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,UAAI,eAAe,IAAI,EAAG,SAAQ,IAAI,OAAO;AAAA,IACjD;AAAA,IACA,MAAM,CAAC,SAAS,SAAS;AACrB,YAAM,UAAU,WAAW,MAAM,GAAG,IAAI;AACxC,YAAM,IAAI,MAAM,OAAO;AAAA,IAC3B;AAAA,EACJ;AACJ;","names":["resolveTemplate","getMessage"]}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "runtime-reporter",
-    "version": "0.2.0",
-    "description": "Runtime messaging that is convenient in development and secure in production",
+    "version": "0.4.0",
+    "description": "Structured runtime events for applications and frameworks. A composable foundation for logging, messaging, and runtime reporting.",
     "type": "module",
     "main": "./dist/index.cjs",
     "module": "./dist/index.js",