@vidavidorra/bunyan-pretty-stream 2.0.10 → 3.0.1

package/dist/src/bunyan-pretty-stream.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { Options } from './options';
 import { Transform, TransformCallback } from 'stream';
+import { Options } from './options';
 declare class PrettyStream extends Transform {
     private _formatter;
     constructor(options?: Options);

package/dist/src/bunyan-pretty-stream.js

@@ -4,20 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrettyStream = void 0;
-const options_1 = require("./options");
 const stream_1 = require("stream");
 const bunyan_record_1 = require("./bunyan-record");
 const formatter_1 = require("./formatter");
 const is_1 = __importDefault(require("@sindresorhus/is"));
-const helpers_1 = require("./helpers");
 class PrettyStream extends stream_1.Transform {
     constructor(options = {}) {
         super({ objectMode: true });
-        const validation = options_1.schema.validate(options);
-        if (!helpers_1.joi.isValid(validation, validation.value)) {
-            throw validation.error;
-        }
-        this._formatter = new formatter_1.Formatter(validation.value);
+        this._formatter = new formatter_1.Formatter(options);
     }
     _transform(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types

package/dist/src/formatter/extras.d.ts

@@ -0,0 +1,34 @@
+import { ParsedOptions } from '../options';
+declare class Extras {
+    readonly options: {
+        readonly keyValueSeparator: "=";
+        readonly separator: ", ";
+        readonly start: "(";
+        readonly end: ")";
+    };
+    private readonly _maxLength;
+    private _extras;
+    private _length;
+    constructor(maxLength: ParsedOptions['extras']['maxLength']);
+    get length(): number;
+    get extras(): string[];
+    /**
+     * Parse a key-value pair and add to the extras if it is a valid extra.
+     *
+     * @param key
+     * @param value
+     * @returns `true` if the key-value was valid and is added, false otherwise.
+     */
+    parseAndAdd(key: string, value: unknown): boolean;
+    format(): string;
+    formatExtra(key: string, value: unknown): {
+        formatted: string;
+        key: string;
+        value: string;
+    };
+    private lengthAfterAdding;
+    private add;
+    private stringify;
+    private containsWhitespace;
+}
+export { Extras };

package/dist/src/formatter/extras.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Extras = void 0;
+class Extras {
+    constructor(maxLength) {
+        this.options = {
+            keyValueSeparator: '=',
+            separator: ', ',
+            start: '(',
+            end: ')',
+        };
+        this._maxLength = maxLength;
+        this._length = 0;
+        this._extras = [];
+    }
+    get length() {
+        return this._length;
+    }
+    get extras() {
+        return this._extras;
+    }
+    /**
+     * Parse a key-value pair and add to the extras if it is a valid extra.
+     *
+     * @param key
+     * @param value
+     * @returns `true` if the key-value was valid and is added, false otherwise.
+     */
+    parseAndAdd(key, value) {
+        if (typeof value === 'object' || typeof value === 'function') {
+            return false;
+        }
+        const extra = this.formatExtra(key, value);
+        if (extra.key.length > this._maxLength.key ||
+            extra.value.length > this._maxLength.value ||
+            this.lengthAfterAdding(extra.formatted) > this._maxLength.total) {
+            return false;
+        }
+        this.add(extra.formatted);
+        return true;
+    }
+    format() {
+        if (this._extras.length === 0) {
+            return '';
+        }
+        return [
+            this.options.start,
+            this._extras.join(this.options.separator),
+            this.options.end,
+        ].join('');
+    }
+    formatExtra(key, value) {
+        const stringifiedKey = this.stringify(key);
+        const stringifiedValue = this.stringify(value);
+        const formatted = [
+            stringifiedKey,
+            this.options.keyValueSeparator,
+            stringifiedValue,
+        ].join('');
+        return {
+            formatted,
+            key: stringifiedKey,
+            value: stringifiedValue,
+        };
+    }
+    lengthAfterAdding(formattedExtra) {
+        let length = this._length + formattedExtra.length;
+        if (this._length === 0) {
+            length += this.options.start.length + this.options.end.length;
+        }
+        else if (this._extras.length >= 1) {
+            length += this.options.separator.length;
+        }
+        return length;
+    }
+    add(formattedExtra) {
+        this._extras.push(formattedExtra);
+        this._length = this.lengthAfterAdding(formattedExtra);
+    }
+    stringify(value) {
+        if (typeof value === 'string' &&
+            value.length > 0 &&
+            !this.containsWhitespace(value) &&
+            !value.includes(this.options.keyValueSeparator)) {
+            return value;
+        }
+        return JSON.stringify(value);
+    }
+    containsWhitespace(value) {
+        return /\s/.test(value);
+    }
+}
+exports.Extras = Extras;

package/dist/src/{formatter.d.ts → formatter/formatter.d.ts}

@@ -1,19 +1,21 @@
-import { BunyanRecord } from './bunyan-record';
-import { MergedOptions } from './options';
+import { BunyanRecord } from '../bunyan-record';
+import { Options } from '../options';
+import { Extras } from './extras';
 import moment from 'moment';
 interface ParsedRecord extends Pick<BunyanRecord, 'level' | 'name' | 'hostname' | 'pid'> {
     version: BunyanRecord['v'];
     time: moment.Moment;
     message: BunyanRecord['msg'];
     source: BunyanRecord['src'];
-    extras: Record<string, any>;
-    details: Record<string, any>;
+    extras: Extras;
+    details: Record<string, unknown>;
 }
 declare class Formatter {
     private readonly _options;
     private readonly _regex;
+    private readonly _internalOptions;
     private readonly _levels;
-    constructor(options: MergedOptions);
+    constructor(options: Options);
     parse(record: BunyanRecord): ParsedRecord;
     format(record: BunyanRecord): string;
     formatTime(time: ParsedRecord['time']): string;
@@ -25,7 +27,6 @@ declare class Formatter {
     formatMessage(message: ParsedRecord['message']): string;
     formatExtras(extras: ParsedRecord['extras']): string;
     formatDetails(message: ParsedRecord['message'], details: ParsedRecord['details']): string;
-    isExtra(value: unknown): boolean;
     isSingleLine(string: string): boolean;
     containsWhitespace(string: string): boolean;
     indent(input: string, leading?: boolean): string;

package/dist/src/{formatter.js → formatter/formatter.js}

@@ -4,7 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Formatter = void 0;
-const bunyan_record_1 = require("./bunyan-record");
+const bunyan_record_1 = require("../bunyan-record");
+const options_1 = require("../options");
+const extras_1 = require("./extras");
 const bunyan_1 = __importDefault(require("bunyan"));
 const chalk_1 = __importDefault(require("chalk"));
 const is_1 = __importDefault(require("@sindresorhus/is"));
@@ -29,8 +31,15 @@ class Formatter {
             newLine: /\r\n|\r|\n/,
             whitespace: /\s/,
         };
-        options.basePath = path_1.default.normalize(options.basePath);
-        this._options = options;
+        this._internalOptions = {
+            timeFormat: {
+                short: 'HH:mm:ss.SSS',
+                long: 'YYYY-MM-DD[T]HH:mm:ss.SSS',
+            },
+        };
+        const parsedOptions = options_1.schema.parse(options);
+        parsedOptions.basePath = path_1.default.normalize(parsedOptions.basePath);
+        this._options = parsedOptions;
         this._levels = {
             [bunyan_1.default.levelFromName.trace]: chalk_1.default.gray('TRACE'),
             [bunyan_1.default.levelFromName.debug]: chalk_1.default.blue('DEBUG'),
@@ -50,7 +59,7 @@ class Formatter {
             time: (0, moment_1.default)(record.time),
             message: record.msg,
             source: record.src,
-            extras: {},
+            extras: new extras_1.Extras(this._options.extras.maxLength),
             details: sanitise(record),
         };
         Object.keys(parsed.details).forEach((key) => {
@@ -58,26 +67,20 @@ class Formatter {
                 delete parsed.details[key];
             }
         });
-        if (!this._options.enable.extras) {
+        if (!this._options.show.extras) {
             return parsed;
         }
-        const extras = parsed.details[this._options.extrasKey];
-        if (this._options.extrasKey !== '' && is_1.default.nonEmptyObject(extras)) {
-            Object.entries(parsed.details[this._options.extrasKey]).forEach(([key, value]) => {
-                if (this.isExtra(value)) {
-                    parsed.extras[key] = value;
-                    delete parsed.details[this._options.extrasKey][key];
-                }
-            });
-        }
-        else if (this._options.extrasKey === '') {
-            Object.entries(parsed.details).forEach(([key, value]) => {
-                if (this.isExtra(value)) {
-                    parsed.extras[key] = value;
-                    delete parsed.details[key];
-                }
-            });
+        const leftOvers = is_1.default.undefined(this._options.extras.key)
+            ? parsed.details
+            : parsed.details[this._options.extras.key];
+        if (!is_1.default.nonEmptyObject(leftOvers)) {
+            return parsed;
         }
+        Object.entries(leftOvers).forEach(([key, value]) => {
+            if (parsed.extras.parseAndAdd(key, value)) {
+                delete leftOvers[key];
+            }
+        });
         return parsed;
     }
     format(record) {
@@ -97,15 +100,15 @@ class Formatter {
         ].join('');
     }
     formatTime(time) {
-        if (!this._options.enable.time) {
+        if (!this._options.show.time) {
             return '';
         }
         let format = this._options.time.format;
         if (this._options.time.type === 'short') {
-            format = this._options.time.formats.short;
+            format = this._internalOptions.timeFormat.short;
         }
         else if (this._options.time.type === 'long') {
-            format = this._options.time.formats.long;
+            format = this._internalOptions.timeFormat.long;
         }
         if (!this._options.time.local) {
             time.utc();
@@ -114,34 +117,34 @@ class Formatter {
         return `[${time.format(format)}]`;
     }
     formatLevel(level) {
-        const prefix = this._options.enable.time ? ' ' : '';
+        const prefix = this._options.show.time ? ' ' : '';
         return `${prefix}${this._levels[level]}`;
     }
     formatName(name) {
-        if (!this._options.enable.name) {
+        if (!this._options.show.name) {
             return '';
         }
         return ` ${name}`;
     }
     formatPid(pid) {
-        if (!this._options.enable.pid) {
+        if (!this._options.show.pid) {
             return '';
         }
-        const prefix = this._options.enable.name ? '/' : ' ';
+        const prefix = this._options.show.name ? '/' : ' ';
         return `${prefix}${pid}`;
     }
     formatHostname(hostname) {
-        if (!this._options.enable.hostname) {
+        if (!this._options.show.hostname) {
             return '';
         }
         return [
             ' ',
-            this._options.enable.name || this._options.enable.pid ? 'on ' : '',
+            this._options.show.name || this._options.show.pid ? 'on ' : '',
             hostname,
         ].join('');
     }
     formatSource(source) {
-        if (!this._options.enable.source || is_1.default.undefined(source)) {
+        if (!this._options.show.source || is_1.default.undefined(source)) {
             return '';
         }
         const file = path_1.default.relative(this._options.basePath, source.file);
@@ -159,19 +162,8 @@ class Formatter {
         return chalk_1.default.blue(` ${message}`);
     }
     formatExtras(extras) {
-        const entries = Object.entries(extras);
-        if (entries.length === 0) {
-            return '';
-        }
-        const formattedExtras = entries.map(([key, value]) => {
-            if (is_1.default.string(value) &&
-                !this.containsWhitespace(value) &&
-                value.length > 0) {
-                return `${key}=${value}`;
-            }
-            return `${key}=${JSON.stringify(value)}`;
-        });
-        return chalk_1.default.red(` (${formattedExtras.join(', ')})`);
+        const formattedExtras = extras.format();
+        return formattedExtras.length === 0 ? '' : chalk_1.default.red(` ${formattedExtras}`);
     }
     formatDetails(message, details) {
         const formatted = [];
@@ -179,7 +171,7 @@ class Formatter {
             formatted.push(chalk_1.default.blue(this.indent(message, true)));
         }
         formatted.push(...Object.entries(details).map(([key, value]) => chalk_1.default.cyan(this.indent(`${key}: ${(0, json_stringify_pretty_compact_1.default)(value, {
-            indent: this._options.jsonIndent,
+            indent: this._options.indent.json,
             maxLength: 80,
         })}`, true))));
         const separator = [
@@ -190,14 +182,6 @@ class Formatter {
         const suffix = formatted.length > 0 ? this._options.newLineCharacter : '';
         return `${formatted.join(separator)}${suffix}`;
     }
-    isExtra(value) {
-        let stringifiedValue = JSON.stringify(value, undefined, 2);
-        if (is_1.default.string(value)) {
-            stringifiedValue = value;
-        }
-        return (this.isSingleLine(stringifiedValue) &&
-            stringifiedValue.length <= this._options.extrasMaxValueLength);
-    }
     isSingleLine(string) {
         return !this._regex.newLine.test(string);
     }
@@ -205,7 +189,7 @@ class Formatter {
         return this._regex.whitespace.test(string);
     }
     indent(input, leading = false) {
-        const indentation = ' '.repeat(this._options.indent);
+        const indentation = ' '.repeat(this._options.indent.details);
         const prefix = leading ? indentation : '';
         const formatted = input
             .split(this._regex.newLine)

package/dist/src/formatter/index.d.ts

@@ -0,0 +1,2 @@
+import { Formatter } from './formatter';
+export { Formatter };

package/dist/src/formatter/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formatter = void 0;
+const formatter_1 = require("./formatter");
+Object.defineProperty(exports, "Formatter", { enumerable: true, get: function () { return formatter_1.Formatter; } });

package/dist/src/options.d.ts

@@ -1,47 +1,151 @@
-interface Options {
-    enable?: {
-        time?: boolean;
-        name?: boolean;
-        hostname?: boolean;
-        pid?: boolean;
-        source?: boolean;
-        extras?: boolean;
-    };
-    extrasKey?: string;
-    indent?: number;
-    jsonIndent?: number;
-    basePath?: string;
-    newLineCharacter?: '\r' | '\n' | '\r\n';
-    time?: {
-        type?: 'short' | 'long' | 'format';
+import { z } from 'zod';
+declare const schema: z.ZodObject<{
+    show: z.ZodDefault<z.ZodObject<{
+        time: z.ZodDefault<z.ZodBoolean>;
+        name: z.ZodDefault<z.ZodBoolean>;
+        hostname: z.ZodDefault<z.ZodBoolean>;
+        pid: z.ZodDefault<z.ZodBoolean>;
+        source: z.ZodDefault<z.ZodBoolean>;
+        extras: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        source: boolean;
+        name: boolean;
+        time: boolean;
+        hostname: boolean;
+        pid: boolean;
+        extras: boolean;
+    }, {
+        source?: boolean | undefined;
+        name?: boolean | undefined;
+        time?: boolean | undefined;
+        hostname?: boolean | undefined;
+        pid?: boolean | undefined;
+        extras?: boolean | undefined;
+    }>>;
+    extras: z.ZodDefault<z.ZodObject<{
+        key: z.ZodOptional<z.ZodString>;
+        maxLength: z.ZodDefault<z.ZodObject<{
+            key: z.ZodDefault<z.ZodNumber>;
+            value: z.ZodDefault<z.ZodNumber>;
+            total: z.ZodDefault<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            key: number;
+            total: number;
+            value: number;
+        }, {
+            key?: number | undefined;
+            total?: number | undefined;
+            value?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        key?: string | undefined;
+        maxLength: {
+            key: number;
+            total: number;
+            value: number;
+        };
+    }, {
+        key?: string | undefined;
+        maxLength?: {
+            key?: number | undefined;
+            total?: number | undefined;
+            value?: number | undefined;
+        } | undefined;
+    }>>;
+    indent: z.ZodDefault<z.ZodObject<{
+        details: z.ZodDefault<z.ZodNumber>;
+        json: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        details: number;
+        json: number;
+    }, {
+        details?: number | undefined;
+        json?: number | undefined;
+    }>>;
+    basePath: z.ZodDefault<z.ZodString>;
+    newLineCharacter: z.ZodDefault<z.ZodEnum<["\r", "\n", "\r\n"]>>;
+    time: z.ZodDefault<z.ZodObject<{
+        type: z.ZodDefault<z.ZodEnum<["short", "long", "format"]>>;
         /**
          * Display local time instead of UTC.
          */
-        local?: boolean;
+        local: z.ZodDefault<z.ZodBoolean>;
         /**
          * Time format as specified by the `Moment.js` [format options](
          * https://momentjs.com/docs/#/displaying/format/).
          *
          * @note The time zone, `Z` or `ZZ`, should be omitted as `Z` is
          * automatically to the format if the time is UTC.
-         * @note The `Z` display suffix for UTC times is automatically added to the
-         * format and should be omitted.
+         * @note The `Z` display suffix for UTC times is automatically added to
+         * the format and should be omitted.
          */
-        format?: string;
+        format: z.ZodDefault<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        type: "long" | "short" | "format";
+        format: string;
+        local: boolean;
+    }, {
+        type?: "long" | "short" | "format" | undefined;
+        format?: string | undefined;
+        local?: boolean | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    show: {
+        source: boolean;
+        name: boolean;
+        time: boolean;
+        hostname: boolean;
+        pid: boolean;
+        extras: boolean;
     };
-}
-interface InternalOptions {
-    extrasMaxValueLength: number;
     time: {
-        formats: {
-            short: string;
-            long: string;
+        type: "long" | "short" | "format";
+        format: string;
+        local: boolean;
+    };
+    extras: {
+        key?: string | undefined;
+        maxLength: {
+            key: number;
+            total: number;
+            value: number;
         };
     };
-}
-declare type DeepRequired<T> = {
-    [P in keyof T]-?: DeepRequired<T[P]>;
-};
-declare type MergedOptions = DeepRequired<Options & InternalOptions>;
-declare const schema: import("joi").ObjectSchema<any>;
-export { Options, InternalOptions, MergedOptions, schema };
+    indent: {
+        details: number;
+        json: number;
+    };
+    basePath: string;
+    newLineCharacter: "\r" | "\n" | "\r\n";
+}, {
+    show?: {
+        source?: boolean | undefined;
+        name?: boolean | undefined;
+        time?: boolean | undefined;
+        hostname?: boolean | undefined;
+        pid?: boolean | undefined;
+        extras?: boolean | undefined;
+    } | undefined;
+    time?: {
+        type?: "long" | "short" | "format" | undefined;
+        format?: string | undefined;
+        local?: boolean | undefined;
+    } | undefined;
+    extras?: {
+        key?: string | undefined;
+        maxLength?: {
+            key?: number | undefined;
+            total?: number | undefined;
+            value?: number | undefined;
+        } | undefined;
+    } | undefined;
+    indent?: {
+        details?: number | undefined;
+        json?: number | undefined;
+    } | undefined;
+    basePath?: string | undefined;
+    newLineCharacter?: "\r" | "\n" | "\r\n" | undefined;
+}>;
+declare type Options = z.input<typeof schema>;
+declare type ParsedOptions = z.infer<typeof schema>;
+export { Options, ParsedOptions, schema };

package/dist/src/options.js

@@ -2,42 +2,67 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 const bunyan_record_1 = require("./bunyan-record");
-const helpers_1 = require("./helpers");
-const schema = helpers_1.joi.object().keys({
-    enable: helpers_1.joi
-        .object()
-        .keys({
-        time: helpers_1.joi.boolean().default(true),
-        name: helpers_1.joi.boolean().default(false),
-        hostname: helpers_1.joi.boolean().default(false),
-        pid: helpers_1.joi.boolean().default(false),
-        source: helpers_1.joi.boolean().default(false),
-        extras: helpers_1.joi.boolean().default(true),
+const zod_1 = require("zod");
+const schema = zod_1.z
+    .object({
+    show: zod_1.z
+        .object({
+        time: zod_1.z.boolean().default(true),
+        name: zod_1.z.boolean().default(false),
+        hostname: zod_1.z.boolean().default(false),
+        pid: zod_1.z.boolean().default(false),
+        source: zod_1.z.boolean().default(false),
+        extras: zod_1.z.boolean().default(true),
     })
-        .default(),
-    extrasKey: helpers_1.joi
-        .string()
-        .disallow(...(0, bunyan_record_1.coreFields)(), '')
-        .default(''),
-    indent: helpers_1.joi.number().integer().min(0).default(4),
-    jsonIndent: helpers_1.joi.number().integer().min(0).default(2),
-    basePath: helpers_1.joi.string().default('/'),
-    newLineCharacter: helpers_1.joi.string().valid('\r', '\n', '\r\n').default('\n'),
-    extrasMaxValueLength: helpers_1.joi.number().integer().positive().default(50),
-    time: helpers_1.joi
-        .object()
-        .keys({
-        local: helpers_1.joi.boolean().default(false),
-        type: helpers_1.joi.string().valid('short', 'long', 'format').default('long'),
-        format: helpers_1.joi.string().default('YYYY-MM-DD[T]HH:mm:ss.SSS'),
-        formats: helpers_1.joi
-            .object()
-            .keys({
-            short: helpers_1.joi.string().default('HH:mm:ss.SSS'),
-            long: helpers_1.joi.string().default('YYYY-MM-DD[T]HH:mm:ss.SSS'),
+        .strict()
+        .default({}),
+    extras: zod_1.z
+        .object({
+        key: zod_1.z
+            .string()
+            .min(1)
+            .regex(new RegExp(`^((?!(${(0, bunyan_record_1.coreFields)().join('|')})).)*$`))
+            .optional(),
+        maxLength: zod_1.z
+            .object({
+            key: zod_1.z.number().int().positive().default(20),
+            value: zod_1.z.number().int().positive().default(50),
+            total: zod_1.z.number().int().positive().default(500),
         })
-            .default(),
+            .strict()
+            .default({}),
     })
-        .default(),
-});
+        .strict()
+        .default({}),
+    indent: zod_1.z
+        .object({
+        details: zod_1.z.number().int().nonnegative().default(4),
+        json: zod_1.z.number().int().nonnegative().default(2),
+    })
+        .strict()
+        .default({}),
+    basePath: zod_1.z.string().min(1).default('/'),
+    newLineCharacter: zod_1.z.enum(['\r', '\n', '\r\n']).default('\n'),
+    time: zod_1.z
+        .object({
+        type: zod_1.z.enum(['short', 'long', 'format']).default('long'),
+        /**
+         * Display local time instead of UTC.
+         */
+        local: zod_1.z.boolean().default(false),
+        /**
+         * Time format as specified by the `Moment.js` [format options](
+         * https://momentjs.com/docs/#/displaying/format/).
+         *
+         * @note The time zone, `Z` or `ZZ`, should be omitted as `Z` is
+         * automatically to the format if the time is UTC.
+         * @note The `Z` display suffix for UTC times is automatically added to
+         * the format and should be omitted.
+         */
+        format: zod_1.z.string().min(1).default('YYYY-MM-DD[T]HH:mm:ss.SSS'),
+    })
+        .strict()
+        .default({}),
+})
+    .strict();
 exports.schema = schema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidavidorra/bunyan-pretty-stream",
-  "version": "2.0.10",
+  "version": "3.0.1",
   "description": "Highly configurable Bunyan stream with pretty output.",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -11,9 +11,7 @@
     "dist/src/**/!(*.test).{js,d.ts}"
   ],
   "scripts": {
-    "_postinstall": "husky install .github/husky",
-    "prepublishOnly": "pinst --disable",
-    "postpublish": "pinst --enable",
+    "prepare": "husky install .github/husky",
     "lint": "run-p format:check lint-es",
     "lint:fix": "run-s format lint-es:fix",
     "lint-es": "eslint --ext .ts,.tsx,.js,.jsx,.json .",
@@ -53,46 +51,45 @@
     "node": ">=14.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "16.1.0",
-    "@jest/globals": "27.4.6",
+    "@commitlint/cli": "16.2.3",
+    "@jest/globals": "27.5.1",
     "@semantic-release/changelog": "6.0.1",
     "@semantic-release/exec": "6.0.3",
     "@semantic-release/git": "10.0.1",
     "@types/bunyan": "1.8.8",
     "@types/clone": "2.1.1",
-    "@types/node": "16.11.21",
-    "@typescript-eslint/eslint-plugin": "5.8.0",
-    "@typescript-eslint/parser": "5.8.0",
-    "@vidavidorra/commitlint-config": "3.2.3",
+    "@types/node": "16.11.26",
+    "@typescript-eslint/eslint-plugin": "5.17.0",
+    "@typescript-eslint/parser": "5.17.0",
+    "@vidavidorra/commitlint-config": "3.2.5",
     "bunyan": "*",
     "bunyan-1.x": "npm:bunyan@1.8.15",
     "bunyan-2.x": "npm:bunyan@2.0.5",
     "clone": "2.1.2",
     "dot-prop": "6.0.1",
-    "eslint": "8.5.0",
-    "eslint-config-prettier": "8.3.0",
-    "eslint-plugin-jest": "25.3.0",
+    "eslint": "8.12.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-plugin-jest": "26.1.3",
     "eslint-plugin-json": "3.1.0",
     "eslint-plugin-prettier": "4.0.0",
     "husky": "7.0.4",
-    "jest": "27.4.7",
-    "lint-staged": "12.3.1",
+    "jest": "27.5.1",
+    "lint-staged": "12.3.7",
     "npm-run-all": "4.1.5",
-    "pinst": "2.1.6",
-    "prettier": "2.5.1",
+    "prettier": "2.6.2",
     "semantic-release": "19.0.2",
     "strip-ansi": "6.0.1",
-    "ts-jest": "27.1.3",
-    "typescript": "4.5.5"
+    "ts-jest": "27.1.4",
+    "typescript": "4.6.3"
   },
   "peerDependencies": {
     "bunyan": "1.8.15"
   },
   "dependencies": {
-    "@sindresorhus/is": "4.4.0",
+    "@sindresorhus/is": "4.6.0",
     "chalk": "4.1.2",
-    "joi": "17.4.2",
     "json-stringify-pretty-compact": "3.0.0",
-    "moment": "2.29.1"
+    "moment": "2.29.1",
+    "zod": "3.14.4"
   }
 }

package/dist/src/helpers/index.d.ts

@@ -1,2 +0,0 @@
-import { Joi, joi } from './joi';
-export { Joi, joi };

package/dist/src/helpers/index.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.joi = exports.Joi = void 0;
-const joi_1 = require("./joi");
-Object.defineProperty(exports, "Joi", { enumerable: true, get: function () { return joi_1.Joi; } });
-Object.defineProperty(exports, "joi", { enumerable: true, get: function () { return joi_1.joi; } });

package/dist/src/helpers/joi.d.ts

@@ -1,6 +0,0 @@
-import BaseJoi from 'joi';
-interface Joi extends BaseJoi.Root {
-    isValid<T>(validation: BaseJoi.ValidationResult, value: unknown): value is T;
-}
-declare const joi: Joi;
-export { joi, BaseJoi as Joi };

package/dist/src/helpers/joi.js

@@ -1,13 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Joi = exports.joi = void 0;
-const joi_1 = __importDefault(require("joi"));
-exports.Joi = joi_1.default;
-function isValid(validation, value) {
-    return validation.error === undefined;
-}
-const joi = { ...joi_1.default, isValid };
-exports.joi = joi;