@samet-it/be-base-common 1.0.1

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2025 Samet Global
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Web: https://sametglobal.com
+Responsible: Mustafa Yelmer (mustafay@samet.com.tr)

package/README.md

@@ -0,0 +1,106 @@
+# Samet Digital : Base Common [Component]
+```
+▗▄▄▖  ▗▄▖  ▗▄▄▖▗▄▄▄▖     ▗▄▄▖ ▗▄▖ ▗▖  ▗▖▗▖  ▗▖ ▗▄▖ ▗▖  ▗▖
+▐▌ ▐▌▐▌ ▐▌▐▌   ▐▌       ▐▌   ▐▌ ▐▌▐▛▚▞▜▌▐▛▚▞▜▌▐▌ ▐▌▐▛▚▖▐▌
+▐▛▀▚▖▐▛▀▜▌ ▝▀▚▖▐▛▀▀▘    ▐▌   ▐▌ ▐▌▐▌  ▐▌▐▌  ▐▌▐▌ ▐▌▐▌ ▝▜▌
+▐▙▄▞▘▐▌ ▐▌▗▄▄▞▘▐▙▄▄▖    ▝▚▄▄▖▝▚▄▞▘▐▌  ▐▌▐▌  ▐▌▝▚▄▞▘▐▌  ▐▌
+```
+- `EN`: It's base component
+- `TR`: Nodejs projeleri için temel bileşen
+
+## Usage
+- `EN`: How to add into your project?
+- `TR`: Projene nasıl eklersin?
+
+```shell
+npm i @samet-it/be-base-common
+```
+
+## Environments
+>
+| Name        | Type | Default | Options                                         |
+|-------------|------|---------|-------------------------------------------------|
+| `NODE_ENV`  | enum | _local_ | [local, development, test, staging, production] |
+| `LOG_LEVEL` | enum | _debug_ | [debug, info, warn, error]                      |
+
+## Contents
+- [errorHandler](./src/error/error.handler.ts) : error handler
+- [generator](./src/generator/generator.ts) : mock data generator
+
+## Development
+> You can start to develop on it
+>
+### Step 1
+- `EN`: Go to your project folder
+- `TR`: Bilgisayarında proje klasörüne git
+```shell
+# Windows
+cd C:\\projects\samet-digital
+```
+```shell
+# Mac
+cd /Users/{user}/projects/samet-digital
+```
+
+### Step 2
+- `EN`: Clone the project
+- `TR`: Projeyi bilgisiyarına çek
+```shell
+git clone https://github.com/samet-digital/be-base-common.git -b development
+```
+
+## Dependencies
+- ~~Nothing~~
+
+## Commands
+```shell
+# Collects all dependencies
+npm i
+
+# Builds project dist (TS -> JS, src -> dist)
+npm run build
+
+# Publishes component on http://npmjs.com/
+npm run publish:public
+
+# Clears `dist` and `coverage` folders
+npm run clear
+
+# Clear `node_modules` folder
+npm run clear:nm
+
+# Validates lint for only errors @see (./eslint.config.mjs) for rules
+npm run lint
+
+# Validates lint with warnings
+npm run lint:verbose
+
+# Runs test cases
+npm run test
+
+# Exports coverage report, @see (./coverage/lcov-report/index.html)
+npm run coverage
+
+# Finds outdated/legacy dependencies
+npm outdated
+```
+
+## Standards
+```diff
++ language: TS 
++ lint: eslint
++ inspections: intelli-j code inspections
++ ddd: domain driven development
++ edd: exception driven development
+! tdd: test driven development
++ ldd: log driven development
++ ddd: document driven development
+```
+
+## History
+| Date       | Developer      | Info         | Ticket         |
+|------------|----------------|--------------|----------------|
+| 2025-04-27 | Mustafa Yelmer | _Created_    | ~~[none](./)~~ |
+| 2025-08-12 | Mustafa Yelmer | _Refactored_ | ~~[none](./)~~ |
+| 2025-08-14 | Mustafa Yelmer | _Documented_ | ~~[none](./)~~ |
+| 2026-01-08 | Mustafa Yelmer | _Documented_ | ~~[none](./)~~ |

package/dist/config/base-common.config.d.ts

@@ -0,0 +1,2 @@
+import type { BaseCommonConf } from "./index.types";
+export declare const baseCommonConfig: import("@leyyo/env").EnvScope<BaseCommonConf>;

package/dist/config/base-common.config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseCommonConfig = void 0;
+const env_1 = require("@leyyo/env");
+const common_1 = require("@leyyo/common");
+// noinspection JSUnusedGlobalSymbols
+exports.baseCommonConfig = env_1.envCore.scope('BaseCommon')
+    .field('NODE_ENV').literal(common_1.EnvironmentItems).required().def('development').end()
+    .field('LOG_LEVEL').literal(common_1.LogLevelItems).required().def('info').end();

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base-common.config';
+export * from './index.types';

package/dist/config/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base-common.config"), exports);
+__exportStar(require("./index.types"), exports);

package/dist/config/index.types.d.ts

@@ -0,0 +1,12 @@
+import type { EnvBase } from "@leyyo/env";
+import { Environment, LogLevel } from "@leyyo/common";
+export declare namespace NodeJS {
+    interface ProcessEnv extends BaseCommonConf {
+    }
+}
+export interface BaseCommonConf extends EnvBase {
+    readonly NODE_ENV: Environment;
+    readonly LOG_LEVEL: LogLevel;
+    readonly npm_package_name: string;
+    readonly npm_package_version: string;
+}

package/dist/config/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/error/base.exception.d.ts

@@ -0,0 +1,7 @@
+import { ErrorStackLine, ExceptionLike } from "../error";
+export declare class BaseException extends Error implements ExceptionLike {
+    status: number;
+    params: Record<string, unknown>;
+    stackTrace: Array<ErrorStackLine>;
+    constructor(message: string, params: Record<string, unknown>, status?: number);
+}

package/dist/error/base.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseException = void 0;
+class BaseException extends Error {
+    constructor(message, params, status) {
+        super(message);
+        this.params = params !== null && params !== void 0 ? params : {};
+        this.status = Number.isInteger(status) ? status : 499;
+    }
+}
+exports.BaseException = BaseException;

package/dist/error/error.handler.d.ts

@@ -0,0 +1,2 @@
+import { ErrorHandlerLike } from "./index.types";
+export declare const errorHandler: ErrorHandlerLike;

package/dist/error/error.handler.js

@@ -0,0 +1,217 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = void 0;
+const stackTraceParser = __importStar(require("stacktrace-parser"));
+const base_exception_1 = require("./base.exception");
+const KNOWN_GROUPS = {
+    '@samet-digital': 's',
+    '@leyyo': 'l',
+    '@nestjs': 'n',
+};
+const IGNORED_KEYS = ['constructor', 'prototype', 'message', 'stack', 'name'];
+class ErrorHandler {
+    item(value, set) {
+        var _a;
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        switch (typeof value) {
+            case "string":
+            case "boolean":
+            case "number":
+            case "bigint":
+                return value;
+            case "object": {
+                if (set.has(value)) {
+                    return `#ref: circular dependency: ${(_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.name}`;
+                }
+                set.add(value);
+                if (Array.isArray(value)) {
+                    return value
+                        .map(item => this.item(item, set));
+                }
+                else if (value instanceof Set) {
+                    return Array.from(value.values())
+                        .map(item => this.item(item, set));
+                }
+                else if (value instanceof Map) {
+                    const result = {};
+                    for (const [k, v] of value.entries()) {
+                        if (typeof k === 'symbol') {
+                            continue;
+                        }
+                        result[k] = this.item(v, set);
+                    }
+                    return result;
+                }
+                const result = {};
+                for (const [k, v] of Object.entries(value)) {
+                    if (typeof k === 'symbol') {
+                        continue;
+                    }
+                    result[k] = this.item(v, set);
+                }
+                return result;
+            }
+            case "function":
+                return `#ref: function: ${value === null || value === void 0 ? void 0 : value.name}`;
+            case "symbol":
+                return `#ref: symbol: ${value === null || value === void 0 ? void 0 : value.description}`;
+        }
+        return undefined;
+    }
+    checkParams(exception) {
+        const set = new WeakSet();
+        set.add(exception);
+        exception.params = this.item(exception.params, set);
+    }
+    export(exception) {
+        var _a;
+        const result = {};
+        this.checkParams(exception);
+        const all = Object.assign({}, exception);
+        if (all.params) {
+            if (typeof all.params['$name'] === 'string') {
+                result.name = all.params['$name'];
+                delete all.params['$name'];
+            }
+            else {
+                result.name = all.name;
+            }
+        }
+        if (all.name && result.name !== all.name && all.name !== 'BaseException') {
+            if (!all.params) {
+                all.params = {};
+            }
+            all.params['$name'] = all.name;
+        }
+        delete all.name;
+        result.message = (_a = all.message) !== null && _a !== void 0 ? _a : result.name;
+        delete all.message;
+        if (all.params !== undefined) {
+            if (Object.keys(all.params).length > 0) {
+                result.params = Object.assign({}, all.params);
+            }
+            delete all.params;
+        }
+        if (all.stackTrace !== undefined) {
+            result.stackTrace = [...all.stackTrace];
+            delete all.stackTrace;
+            delete all.stack;
+        }
+        if (all.stack !== undefined) {
+            delete all.stack;
+        }
+        return result;
+    }
+    cast(error, p1, p2) {
+        let fnc;
+        let status;
+        switch (typeof p1) {
+            case "function":
+                fnc = p1;
+                break;
+            case "number":
+                status = p1;
+                if (typeof p2 === 'function') {
+                    fnc = p2;
+                }
+                break;
+        }
+        if (!fnc) {
+            fnc = base_exception_1.BaseException;
+        }
+        const exc = new fnc(error.message, {}, status);
+        exc.params['$name'] = error.name;
+        let now = Date.now();
+        for (const [key, value] of Object.entries(error)) {
+            if (typeof key === 'symbol' || value === undefined || IGNORED_KEYS.includes(key)) {
+                continue;
+            }
+            if (exc.params[key] === undefined) {
+                exc.params[key] = value;
+            }
+            else {
+                now++;
+                exc.params[`$${key}__${now}`] = value;
+            }
+        }
+        return exc;
+    }
+    stack(source, causedBy) {
+        var _a;
+        source.stackTrace = [];
+        try {
+            const original = (_a = causedBy.stack) !== null && _a !== void 0 ? _a : source.stack;
+            if (original) {
+                const frames = stackTraceParser.parse(original);
+                if (Array.isArray(frames)) {
+                    frames.forEach(frame => {
+                        var _a, _b;
+                        if (['<unknown>', 'Object.<anonymous>'].includes(frame.methodName)) {
+                            frame.methodName = undefined;
+                        }
+                        if (frame.file) {
+                            if (frame.file.startsWith('node:')) {
+                                frame.file = `@` + frame.file.substring(5);
+                            }
+                            else {
+                                for (const [pck, short] of Object.entries(KNOWN_GROUPS)) {
+                                    const index = frame.file.indexOf(pck);
+                                    if (index >= 0) {
+                                        frame.file = `#${short}` + frame.file.substring(index);
+                                    }
+                                }
+                            }
+                            if (frame.file.endsWith('.js') || frame.file.endsWith('.ts')) {
+                                frame.file.substring(0, frame.file.length - 3);
+                            }
+                        }
+                        source.stackTrace.push({
+                            file: frame.file,
+                            method: frame.methodName,
+                            pos: `${(_a = frame.lineNumber) !== null && _a !== void 0 ? _a : ''}:${(_b = frame.column) !== null && _b !== void 0 ? _b : ''}`
+                        });
+                    });
+                }
+            }
+        }
+        catch (e) {
+            // none
+        }
+    }
+}
+exports.errorHandler = new ErrorHandler();

package/dist/error/index.d.ts

@@ -0,0 +1,8 @@
+export * from './base.exception';
+export * from './error.handler';
+export * from './index.types';
+export * from './initialization.exception';
+export * from './page-not-found.exception';
+export * from './record-duplicated.exception';
+export * from './record-not-found.exception';
+export * from './validation.exception';

package/dist/error/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base.exception"), exports);
+__exportStar(require("./error.handler"), exports);
+__exportStar(require("./index.types"), exports);
+__exportStar(require("./initialization.exception"), exports);
+__exportStar(require("./page-not-found.exception"), exports);
+__exportStar(require("./record-duplicated.exception"), exports);
+__exportStar(require("./record-not-found.exception"), exports);
+__exportStar(require("./validation.exception"), exports);

package/dist/error/index.types.d.ts

@@ -0,0 +1,31 @@
+import { ClassLike } from "../shared";
+/**
+ * Stack line
+ * */
+export interface ErrorStackLine {
+    file: string;
+    method?: string;
+    pos?: string;
+}
+/**
+ * Core exception
+ * */
+export interface ExceptionLike extends Error {
+    status: number;
+    params: Record<string, unknown>;
+    stackTrace: Array<ErrorStackLine>;
+}
+export interface ExceptionExported {
+    name: string;
+    message: string;
+    params?: Record<string, unknown>;
+    stackTrace?: Array<ErrorStackLine>;
+}
+export type ErrorItem<A, C = ExceptionLike> = A extends ClassLike<infer R> ? (R extends ExceptionLike ? C : never) : never;
+export interface ErrorHandlerLike {
+    checkParams(exception: ExceptionLike): void;
+    export(exception: ExceptionLike): ExceptionExported;
+    cast<F extends ClassLike<ExceptionLike>>(error: Error, fnc?: F): ErrorItem<F>;
+    cast<F extends ClassLike<ExceptionLike>>(error: Error, status: number, fnc?: F): ErrorItem<F>;
+    stack(source: ExceptionLike, causedBy?: Error): void;
+}

package/dist/error/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/error/initialization.exception.d.ts

@@ -0,0 +1,4 @@
+import { BaseException } from "./base.exception";
+export declare class InitializationException extends BaseException {
+    constructor(message: string);
+}

package/dist/error/initialization.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializationException = void 0;
+// noinspection JSUnusedGlobalSymbols
+const base_exception_1 = require("./base.exception");
+class InitializationException extends base_exception_1.BaseException {
+    constructor(message) {
+        super(message, {}, 500);
+    }
+}
+exports.InitializationException = InitializationException;

package/dist/error/page-not-found.exception.d.ts

@@ -0,0 +1,4 @@
+import { BaseException } from "./base.exception";
+export declare class PageNotFoundException extends BaseException {
+    constructor(path: string);
+}

package/dist/error/page-not-found.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageNotFoundException = void 0;
+const base_exception_1 = require("./base.exception");
+class PageNotFoundException extends base_exception_1.BaseException {
+    constructor(path) {
+        super(`Path: ${path} is not found`, { path }, 404);
+    }
+}
+exports.PageNotFoundException = PageNotFoundException;

package/dist/error/record-duplicated.exception.d.ts

@@ -0,0 +1,4 @@
+import { BaseException } from "./base.exception";
+export declare class RecordDuplicatedException extends BaseException {
+    constructor(domain: string, value: Record<string, string | number>, id: string);
+}

package/dist/error/record-duplicated.exception.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordDuplicatedException = void 0;
+const base_exception_1 = require("./base.exception");
+// noinspection JSUnusedGlobalSymbols
+class RecordDuplicatedException extends base_exception_1.BaseException {
+    constructor(domain, value, id) {
+        let valueJson;
+        try {
+            valueJson = JSON.stringify(value);
+        }
+        catch (_e) {
+            //
+        }
+        super(`${domain} is duplicated with values: ${valueJson}, existing:${id}`, { domain, id, value }, 409);
+    }
+}
+exports.RecordDuplicatedException = RecordDuplicatedException;

package/dist/error/record-not-found.exception.d.ts

@@ -0,0 +1,4 @@
+import { BaseException } from "./base.exception";
+export declare class RecordNotFoundException extends BaseException {
+    constructor(domain: string, key: string, value: string);
+}

package/dist/error/record-not-found.exception.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordNotFoundException = void 0;
+const base_exception_1 = require("./base.exception");
+// noinspection JSUnusedGlobalSymbols
+class RecordNotFoundException extends base_exception_1.BaseException {
+    constructor(domain, key, value) {
+        super(`Record could not be found`, {
+            domain, key, value
+        }, 404);
+    }
+}
+exports.RecordNotFoundException = RecordNotFoundException;

package/dist/error/validation.exception.d.ts

@@ -0,0 +1,4 @@
+import { BaseException } from "./base.exception";
+export declare class ValidationException extends BaseException {
+    constructor(domain: string, key: string, value?: unknown, params?: Record<string, unknown>);
+}

package/dist/error/validation.exception.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationException = void 0;
+const base_exception_1 = require("./base.exception");
+// noinspection JSUnusedGlobalSymbols
+class ValidationException extends base_exception_1.BaseException {
+    constructor(domain, key, value, params) {
+        try {
+            value = JSON.parse(JSON.stringify(value));
+        }
+        catch (e) {
+            value = undefined;
+        }
+        if (!params) {
+            params = { domain, key, value };
+        }
+        else {
+            params = Object.assign(Object.assign({}, params), { domain, key, value });
+        }
+        super(`${domain} -> ${key} is invalid`, params, 409);
+    }
+}
+exports.ValidationException = ValidationException;

package/dist/exit/exit-handler.impl.d.ts

@@ -0,0 +1,2 @@
+import { ExitHandler } from "./index.types";
+export declare const exitHandler: ExitHandler;

package/dist/exit/exit-handler.impl.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exitHandler = void 0;
+class ExitHandlerImpl {
+    register(fn) {
+        ['SIGINT', 'SIGTERM', 'SIGQUIT', 'SIGKILL'].forEach(event => {
+            process.on(event, () => {
+                fn(`${event} event received`);
+            });
+        });
+    }
+}
+exports.exitHandler = new ExitHandlerImpl();

package/dist/exit/index.d.ts

@@ -0,0 +1,2 @@
+export * from './exit-handler.impl';
+export * from './index.types';

package/dist/exit/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./exit-handler.impl"), exports);
+__exportStar(require("./index.types"), exports);

package/dist/exit/index.types.d.ts

@@ -0,0 +1,4 @@
+export interface ExitHandler {
+    register(fn: ExitHandlerFn): void;
+}
+export type ExitHandlerFn = (message: string) => void;