@depup/fork-ts-checker-webpack-plugin 9.1.0-depup.0

package/lib/issue/issue.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateAndSortIssues = exports.isIssue = void 0;
+const issue_location_1 = require("./issue-location");
+const issue_severity_1 = require("./issue-severity");
+function isIssue(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        (0, issue_severity_1.isIssueSeverity)(value.severity) &&
+        !!value.code &&
+        !!value.message);
+}
+exports.isIssue = isIssue;
+function compareStrings(stringA, stringB) {
+    if (stringA === stringB) {
+        return 0;
+    }
+    if (stringA === undefined || stringA === null) {
+        return -1;
+    }
+    if (stringB === undefined || stringB === null) {
+        return 1;
+    }
+    return stringA.toString().localeCompare(stringB.toString());
+}
+function compareIssues(issueA, issueB) {
+    return ((0, issue_severity_1.compareIssueSeverities)(issueA.severity, issueB.severity) ||
+        compareStrings(issueA.file, issueB.file) ||
+        (0, issue_location_1.compareIssueLocations)(issueA.location, issueB.location) ||
+        compareStrings(issueA.code, issueB.code) ||
+        compareStrings(issueA.message, issueB.message) ||
+        0 /* EqualTo */);
+}
+function equalsIssues(issueA, issueB) {
+    return compareIssues(issueA, issueB) === 0;
+}
+function deduplicateAndSortIssues(issues) {
+    const sortedIssues = issues.filter(isIssue).sort(compareIssues);
+    return sortedIssues.filter((issue, index) => index === 0 || !equalsIssues(issue, sortedIssues[index - 1]));
+}
+exports.deduplicateAndSortIssues = deduplicateAndSortIssues;

package/lib/logger.d.ts

@@ -0,0 +1,5 @@
+interface Logger {
+    log: (message: string) => void;
+    error: (message: string) => void;
+}
+export { Logger };

package/lib/logger.js

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

package/lib/plugin-config.d.ts

@@ -0,0 +1,16 @@
+import type * as webpack from 'webpack';
+import type { FormatterConfig } from './formatter';
+import type { IssueConfig } from './issue/issue-config';
+import type { Logger } from './logger';
+import type { ForkTsCheckerWebpackPluginOptions } from './plugin-options';
+import type { TypeScriptWorkerConfig } from './typescript/type-script-worker-config';
+interface ForkTsCheckerWebpackPluginConfig {
+    async: boolean;
+    typescript: TypeScriptWorkerConfig;
+    issue: IssueConfig;
+    formatter: FormatterConfig;
+    logger: Logger;
+    devServer: boolean;
+}
+declare function createPluginConfig(compiler: webpack.Compiler, options?: ForkTsCheckerWebpackPluginOptions): ForkTsCheckerWebpackPluginConfig;
+export { ForkTsCheckerWebpackPluginConfig, createPluginConfig };

package/lib/plugin-config.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPluginConfig = void 0;
+const formatter_1 = require("./formatter");
+const infrastructure_logger_1 = require("./infrastructure-logger");
+const issue_config_1 = require("./issue/issue-config");
+const type_script_worker_config_1 = require("./typescript/type-script-worker-config");
+function createPluginConfig(compiler, options = {}) {
+    return {
+        async: options.async === undefined ? compiler.options.mode === 'development' : options.async,
+        typescript: (0, type_script_worker_config_1.createTypeScriptWorkerConfig)(compiler, options.typescript),
+        issue: (0, issue_config_1.createIssueConfig)(compiler, options.issue),
+        formatter: (0, formatter_1.createFormatterConfig)(options.formatter),
+        logger: options.logger === 'webpack-infrastructure'
+            ? (() => {
+                const { info, error } = (0, infrastructure_logger_1.getInfrastructureLogger)(compiler);
+                return {
+                    log: info,
+                    error,
+                };
+            })()
+            : options.logger || console,
+        devServer: options.devServer !== false,
+    };
+}
+exports.createPluginConfig = createPluginConfig;

package/lib/plugin-hooks.d.ts

@@ -0,0 +1,20 @@
+import { SyncHook, SyncWaterfallHook, AsyncSeriesWaterfallHook } from 'tapable';
+import type * as webpack from 'webpack';
+import type { FilesChange } from './files-change';
+import type { Issue } from './issue';
+declare function createPluginHooks(): {
+    start: AsyncSeriesWaterfallHook<[FilesChange, webpack.Compilation], import("tapable").UnsetAdditionalOptions>;
+    waiting: SyncHook<[webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
+    canceled: SyncHook<[webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
+    error: SyncHook<[unknown, webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
+    issues: SyncWaterfallHook<[Issue[], webpack.Compilation | undefined], void>;
+};
+type ForkTsCheckerWebpackPluginHooks = ReturnType<typeof createPluginHooks>;
+declare function getPluginHooks(compiler: webpack.Compiler | webpack.MultiCompiler): {
+    start: AsyncSeriesWaterfallHook<[FilesChange, webpack.Compilation], import("tapable").UnsetAdditionalOptions>;
+    waiting: SyncHook<[webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
+    canceled: SyncHook<[webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
+    error: SyncHook<[unknown, webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
+    issues: SyncWaterfallHook<[Issue[], webpack.Compilation | undefined], void>;
+};
+export { getPluginHooks, ForkTsCheckerWebpackPluginHooks };

package/lib/plugin-hooks.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluginHooks = void 0;
+const tapable_1 = require("tapable");
+const compilerHookMap = new WeakMap();
+function createPluginHooks() {
+    return {
+        start: new tapable_1.AsyncSeriesWaterfallHook([
+            'change',
+            'compilation',
+        ]),
+        waiting: new tapable_1.SyncHook(['compilation']),
+        canceled: new tapable_1.SyncHook(['compilation']),
+        error: new tapable_1.SyncHook(['error', 'compilation']),
+        issues: new tapable_1.SyncWaterfallHook([
+            'issues',
+            'compilation',
+        ]),
+    };
+}
+function forwardPluginHooks(source, target) {
+    source.start.tapPromise('ForkTsCheckerWebpackPlugin', target.start.promise);
+    source.waiting.tap('ForkTsCheckerWebpackPlugin', target.waiting.call);
+    source.canceled.tap('ForkTsCheckerWebpackPlugin', target.canceled.call);
+    source.error.tap('ForkTsCheckerWebpackPlugin', target.error.call);
+    source.issues.tap('ForkTsCheckerWebpackPlugin', target.issues.call);
+}
+function getPluginHooks(compiler) {
+    let hooks = compilerHookMap.get(compiler);
+    if (hooks === undefined) {
+        hooks = createPluginHooks();
+        compilerHookMap.set(compiler, hooks);
+        // proxy hooks for multi-compiler
+        if ('compilers' in compiler) {
+            compiler.compilers.forEach((childCompiler) => {
+                const childHooks = getPluginHooks(childCompiler);
+                if (hooks) {
+                    forwardPluginHooks(childHooks, hooks);
+                }
+            });
+        }
+    }
+    return hooks;
+}
+exports.getPluginHooks = getPluginHooks;

package/lib/plugin-options.d.ts

@@ -0,0 +1,13 @@
+import type { FormatterOptions } from './formatter';
+import type { IssueOptions } from './issue/issue-options';
+import type { Logger } from './logger';
+import type { TypeScriptWorkerOptions } from './typescript/type-script-worker-options';
+interface ForkTsCheckerWebpackPluginOptions {
+    async?: boolean;
+    typescript?: TypeScriptWorkerOptions;
+    formatter?: FormatterOptions;
+    issue?: IssueOptions;
+    logger?: Logger | 'webpack-infrastructure';
+    devServer?: boolean;
+}
+export { ForkTsCheckerWebpackPluginOptions };

package/lib/plugin-options.js

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

package/lib/plugin-options.json

@@ -0,0 +1,197 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "async": {
+            "type": "boolean",
+            "description": "When true, plugin will not block compilation to finish issues checking"
+        },
+        "typescript": {
+            "$ref": "#/definitions/TypeScriptOptions"
+        },
+        "formatter": {
+            "$ref": "#/definitions/FormatterOptions"
+        },
+        "issue": {
+            "$ref": "#/definitions/IssueOptions"
+        },
+        "logger": {
+            "$ref": "#/definitions/Logger"
+        },
+        "devServer": {
+            "type": "boolean",
+            "description": "Enable reporting to Webpack Dev Server."
+        }
+    },
+    "additionalProperties": false,
+    "definitions": {
+        "Formatter": {
+            "instanceof": "Function"
+        },
+        "ComplexFormatterPreferences": {
+            "type": "object",
+            "properties": {
+                "type": {
+                    "$ref": "#/definitions/FormatterType"
+                },
+                "pathType": {
+                    "$ref": "#/definitions/FormatterPathType"
+                },
+                "options": {
+                    "type": "object",
+                    "additionalProperties": true
+                }
+            },
+            "required": ["type"]
+        },
+        "FormatterType": {
+            "type": "string",
+            "enum": ["basic", "codeframe"]
+        },
+        "FormatterPathType": {
+            "type": "string",
+            "enum": ["relative", "absolute"]
+        },
+        "IssueMatch": {
+            "type": "object",
+            "properties": {
+                "severity": {
+                    "type": "string",
+                    "enum": ["error", "warning"]
+                },
+                "code": {
+                    "type": "string"
+                },
+                "file": {
+                    "type": "string"
+                }
+            }
+        },
+        "IssuePredicate": {
+            "instanceof": "Function"
+        },
+        "IssuePredicateOption": {
+            "oneOf": [
+                {
+                    "$ref": "#/definitions/IssuePredicate"
+                },
+                {
+                    "$ref": "#/definitions/IssueMatch"
+                },
+                {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            {
+                                "$ref": "#/definitions/IssuePredicate"
+                            },
+                            {
+                                "$ref": "#/definitions/IssueMatch"
+                            }
+                        ]
+                    }
+                }
+            ]
+        },
+        "Logger": {
+            "oneOf": [
+                {
+                    "type": "object",
+                    "properties": {
+                        "error": {
+                            "instanceof": "Function"
+                        },
+                        "log": {
+                            "instanceof": "Function"
+                        }
+                    }
+                },
+                {
+                    "type": "string",
+                    "enum": ["webpack-infrastructure"]
+                }
+            ]
+        },
+        "TypeScriptOptions": {
+            "type": "object",
+            "properties": {
+                "memoryLimit": {
+                    "type": "number",
+                    "description": "Memory limit for TypeScript reporter process."
+                },
+                "configFile": {
+                    "type": "string",
+                    "description": "Path to tsconfig.json. By default plugin uses context or process.cwd() to localize tsconfig.json file."
+                },
+                "context": {
+                    "type": "string",
+                    "description": "The base path for finding files specified in the tsconfig.json. Same as context option from the ts-loader."
+                },
+                "build": {
+                    "type": "boolean",
+                    "description": "The equivalent of the `--build` flag from the `tsc`."
+                },
+                "mode": {
+                    "type": "string",
+                    "enum": ["readonly", "write-tsbuildinfo", "write-dts", "write-references"],
+                    "description": "`readonly` keeps all emitted files in memory, `write-tsbuildinfo` which writes only .tsbuildinfo files, `write-dts` writes .tsbuildinfo and type definition files, and `write-references` which writes both .tsbuildinfo and referenced projects output"
+                },
+                "compilerOptions": {
+                    "type": "object",
+                    "description": "Custom compilerOptions to be passed to the TypeScript compiler.",
+                    "additionalProperties": true
+                },
+                "diagnosticOptions": {
+                    "type": "object",
+                    "description": "Types of diagnostics to be reported.",
+                    "properties": {
+                        "syntactic": {
+                            "type": "boolean"
+                        },
+                        "semantic": {
+                            "type": "boolean"
+                        },
+                        "declaration": {
+                            "type": "boolean"
+                        },
+                        "global": {
+                            "type": "boolean"
+                        }
+                    }
+                },
+                "profile": {
+                    "type": "boolean",
+                    "description": "Measures and prints timings related to the TypeScript performance."
+                },
+                "typescriptPath": {
+                    "type": "string",
+                    "description": "If supplied this is a custom path where TypeScript can be found."
+                }
+            }
+        },
+        "FormatterOptions": {
+            "oneOf": [
+                {
+                    "$ref": "#/definitions/FormatterType"
+                },
+                {
+                    "$ref": "#/definitions/ComplexFormatterPreferences"
+                },
+                {
+                    "$ref": "#/definitions/Formatter"
+                }
+            ]
+        },
+        "IssueOptions": {
+            "type": "object",
+            "properties": {
+                "include": {
+                    "$ref": "#/definitions/IssuePredicateOption"
+                },
+                "exclude": {
+                    "$ref": "#/definitions/IssuePredicateOption"
+                }
+            }
+        }
+    }
+}

package/lib/plugin-pools.d.ts

@@ -0,0 +1,4 @@
+import type { Pool } from './utils/async/pool';
+declare const issuesPool: Pool;
+declare const dependenciesPool: Pool;
+export { issuesPool, dependenciesPool };

package/lib/plugin-pools.js

@@ -0,0 +1,32 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependenciesPool = exports.issuesPool = void 0;
+const os = __importStar(require("os"));
+const pool_1 = require("./utils/async/pool");
+const issuesPool = (0, pool_1.createPool)(Math.max(1, os.cpus().length));
+exports.issuesPool = issuesPool;
+const dependenciesPool = (0, pool_1.createPool)(Math.max(1, os.cpus().length));
+exports.dependenciesPool = dependenciesPool;

package/lib/plugin-state.d.ts

@@ -0,0 +1,18 @@
+import type { AbortController } from 'node-abort-controller';
+import type { FullTap } from 'tapable';
+import type { FilesChange } from './files-change';
+import type { FilesMatch } from './files-match';
+import type { Issue } from './issue';
+interface ForkTsCheckerWebpackPluginState {
+    issuesPromise: Promise<Issue[] | undefined>;
+    dependenciesPromise: Promise<FilesMatch | undefined>;
+    abortController: AbortController | undefined;
+    aggregatedFilesChange: FilesChange | undefined;
+    lastDependencies: FilesMatch | undefined;
+    watching: boolean;
+    initialized: boolean;
+    iteration: number;
+    webpackDevServerDoneTap: FullTap | undefined;
+}
+declare function createPluginState(): ForkTsCheckerWebpackPluginState;
+export { ForkTsCheckerWebpackPluginState, createPluginState };

package/lib/plugin-state.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPluginState = void 0;
+function createPluginState() {
+    return {
+        issuesPromise: Promise.resolve(undefined),
+        dependenciesPromise: Promise.resolve(undefined),
+        abortController: undefined,
+        aggregatedFilesChange: undefined,
+        lastDependencies: undefined,
+        watching: false,
+        initialized: false,
+        iteration: 0,
+        webpackDevServerDoneTap: undefined,
+    };
+}
+exports.createPluginState = createPluginState;

package/lib/plugin.d.ts

@@ -0,0 +1,28 @@
+import type * as webpack from 'webpack';
+import type { ForkTsCheckerWebpackPluginOptions } from './plugin-options';
+declare class ForkTsCheckerWebpackPlugin {
+    /**
+     * Current version of the plugin
+     */
+    static readonly version: string;
+    /**
+     * Default pools for the plugin concurrency limit
+     */
+    static readonly issuesPool: import("./utils/async/pool").Pool;
+    static readonly dependenciesPool: import("./utils/async/pool").Pool;
+    /**
+     * @deprecated Use ForkTsCheckerWebpackPlugin.issuesPool instead
+     */
+    static readonly pool: import("./utils/async/pool").Pool;
+    private readonly options;
+    constructor(options?: ForkTsCheckerWebpackPluginOptions);
+    static getCompilerHooks(compiler: webpack.Compiler): {
+        start: import("tapable").AsyncSeriesWaterfallHook<[import("./files-change").FilesChange, webpack.Compilation], import("tapable").UnsetAdditionalOptions>;
+        waiting: import("tapable").SyncHook<[webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
+        canceled: import("tapable").SyncHook<[webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
+        error: import("tapable").SyncHook<[unknown, webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
+        issues: import("tapable").SyncWaterfallHook<[import("./issue/issue").Issue[], webpack.Compilation | undefined], void>;
+    };
+    apply(compiler: webpack.Compiler): void;
+}
+export { ForkTsCheckerWebpackPlugin };

package/lib/plugin.js

@@ -0,0 +1,86 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForkTsCheckerWebpackPlugin = void 0;
+const path = __importStar(require("path"));
+const cosmiconfig_1 = require("cosmiconfig");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const schema_utils_1 = require("schema-utils");
+const tap_after_compile_to_add_dependencies_1 = require("./hooks/tap-after-compile-to-add-dependencies");
+const tap_after_environment_to_patch_watching_1 = require("./hooks/tap-after-environment-to-patch-watching");
+const tap_error_to_log_message_1 = require("./hooks/tap-error-to-log-message");
+const tap_start_to_run_workers_1 = require("./hooks/tap-start-to-run-workers");
+const tap_stop_to_terminate_workers_1 = require("./hooks/tap-stop-to-terminate-workers");
+const plugin_config_1 = require("./plugin-config");
+const plugin_hooks_1 = require("./plugin-hooks");
+const plugin_options_json_1 = __importDefault(require("./plugin-options.json"));
+const plugin_pools_1 = require("./plugin-pools");
+const plugin_state_1 = require("./plugin-state");
+const rpc_1 = require("./rpc");
+const type_script_support_1 = require("./typescript/type-script-support");
+class ForkTsCheckerWebpackPlugin {
+    constructor(options = {}) {
+        const explorerSync = (0, cosmiconfig_1.cosmiconfigSync)('fork-ts-checker');
+        const { config: externalOptions } = explorerSync.search() || {};
+        // first validate options directly passed to the constructor
+        const config = { name: 'ForkTsCheckerWebpackPlugin' };
+        (0, schema_utils_1.validate)(plugin_options_json_1.default, options, config);
+        this.options = (0, deepmerge_1.default)(externalOptions || {}, options || {});
+        // then validate merged options
+        (0, schema_utils_1.validate)(plugin_options_json_1.default, this.options, config);
+    }
+    static getCompilerHooks(compiler) {
+        return (0, plugin_hooks_1.getPluginHooks)(compiler);
+    }
+    apply(compiler) {
+        const config = (0, plugin_config_1.createPluginConfig)(compiler, this.options);
+        const state = (0, plugin_state_1.createPluginState)();
+        (0, type_script_support_1.assertTypeScriptSupport)(config.typescript);
+        const getIssuesWorker = (0, rpc_1.createRpcWorker)(path.resolve(__dirname, './typescript/worker/get-issues-worker.js'), config.typescript, config.typescript.memoryLimit);
+        const getDependenciesWorker = (0, rpc_1.createRpcWorker)(path.resolve(__dirname, './typescript/worker/get-dependencies-worker.js'), config.typescript);
+        (0, tap_after_environment_to_patch_watching_1.tapAfterEnvironmentToPatchWatching)(compiler, state);
+        (0, tap_start_to_run_workers_1.tapStartToRunWorkers)(compiler, getIssuesWorker, getDependenciesWorker, config, state);
+        (0, tap_after_compile_to_add_dependencies_1.tapAfterCompileToAddDependencies)(compiler, config, state);
+        (0, tap_stop_to_terminate_workers_1.tapStopToTerminateWorkers)(compiler, getIssuesWorker, getDependenciesWorker, state);
+        (0, tap_error_to_log_message_1.tapErrorToLogMessage)(compiler, config);
+    }
+}
+exports.ForkTsCheckerWebpackPlugin = ForkTsCheckerWebpackPlugin;
+/**
+ * Current version of the plugin
+ */
+ForkTsCheckerWebpackPlugin.version = '9.1.0'; // will be replaced by the @semantic-release/exec
+/**
+ * Default pools for the plugin concurrency limit
+ */
+ForkTsCheckerWebpackPlugin.issuesPool = plugin_pools_1.issuesPool;
+ForkTsCheckerWebpackPlugin.dependenciesPool = plugin_pools_1.dependenciesPool;
+/**
+ * @deprecated Use ForkTsCheckerWebpackPlugin.issuesPool instead
+ */
+ForkTsCheckerWebpackPlugin.pool = plugin_pools_1.issuesPool;

package/lib/rpc/expose-rpc.d.ts

@@ -0,0 +1 @@
+export declare function exposeRpc(fn: (...args: any[]) => any): void;

package/lib/rpc/expose-rpc.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exposeRpc = void 0;
+const process_1 = __importDefault(require("process"));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function exposeRpc(fn) {
+    const sendMessage = (message) => new Promise((resolve, reject) => {
+        if (!process_1.default.send) {
+            reject(new Error(`Process ${process_1.default.pid} doesn't have IPC channels`));
+        }
+        else if (!process_1.default.connected) {
+            reject(new Error(`Process ${process_1.default.pid} doesn't have open IPC channels`));
+        }
+        else {
+            process_1.default.send(message, undefined, undefined, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(undefined);
+                }
+            });
+        }
+    });
+    const handleMessage = (message) => __awaiter(this, void 0, void 0, function* () {
+        if (message.type === 'call') {
+            if (!process_1.default.send) {
+                // process disconnected - skip
+                return;
+            }
+            let value;
+            let error;
+            try {
+                value = yield fn(...message.args);
+            }
+            catch (fnError) {
+                error = fnError;
+            }
+            try {
+                if (error) {
+                    yield sendMessage({
+                        type: 'reject',
+                        id: message.id,
+                        error,
+                    });
+                }
+                else {
+                    yield sendMessage({
+                        type: 'resolve',
+                        id: message.id,
+                        value,
+                    });
+                }
+            }
+            catch (sendError) {
+                // we can't send things back to the parent process - let's use stdout to communicate error
+                if (error) {
+                    console.error(error);
+                }
+                console.error(sendError);
+            }
+        }
+    });
+    process_1.default.on('message', handleMessage);
+}
+exports.exposeRpc = exposeRpc;

package/lib/rpc/index.d.ts

@@ -0,0 +1,5 @@
+export { exposeRpc } from './expose-rpc';
+export { wrapRpc } from './wrap-rpc';
+export { createRpcWorker, getRpcWorkerData, RpcWorker } from './rpc-worker';
+export { RpcExitError } from './rpc-error';
+export { RpcRemoteMethod } from './types';