zero-com 0.0.4 → 0.0.5

package/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execServerFn = exports.serverFn = void 0;
+const serverFn = (sfn) => {
+    const clonedSfn = (...rest) => sfn(null, ...rest);
+    clonedSfn.serverFn = sfn;
+    return clonedSfn;
+};
+exports.serverFn = serverFn;
+const execServerFn = (sfn, ctx, args) => {
+    if (sfn.serverFn) {
+        return sfn.serverFn.call(null, ctx, ...args);
+    }
+    else {
+        return sfn.call(null, ...args);
+    }
+};
+exports.execServerFn = execServerFn;

package/lib/index.ts

@@ -0,0 +1,19 @@
+
+declare global {
+  var ZERO_COM_SERVER_REGISTRY: { [funcId: string]: (...args: any[]) => any }
+  var ZERO_COM_CLIENT_SEND: (...args: any[]) => Promise<any>
+}
+
+export const serverFn = <Ctx, Rest extends any[], R>(sfn: (ctx: Ctx, ...rest: Rest) => R) => {
+  const clonedSfn = (...rest: Rest): R => sfn(null as Ctx, ...rest)
+  clonedSfn.serverFn = sfn
+  return clonedSfn
+}
+
+export const execServerFn = (sfn: ReturnType<typeof serverFn>, ctx: any, args: any[]): ReturnType<typeof sfn> => {
+  if (sfn.serverFn) {
+    return sfn.serverFn.call(null, ctx, ...args)
+  } else {
+    return sfn.call(null, ...args)
+  }
+}

package/lib/rollup.js

@@ -0,0 +1,154 @@
+"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.zeroComRollupPlugin = zeroComRollupPlugin;
+const fs_1 = __importDefault(require("fs"));
+const minimatch_1 = require("minimatch");
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+const typescript_1 = __importDefault(require("typescript"));
+const common_1 = require("./common");
+function zeroComRollupPlugin(options) {
+    const { development = true, patterns } = options;
+    const compilationId = String(Math.floor(Math.random() * 1000000));
+    const clientPattern = patterns.client;
+    const serverPattern = patterns.server;
+    const replacements = [
+        { target: common_1.ZERO_COM_CLIENT_SEND, replacement: `__ZERO_COM_CLIENT_SEND_${compilationId}` },
+        { target: common_1.ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${compilationId}` }
+    ];
+    return {
+        name: 'zero-com-rollup-plugin',
+        resolveId(source, importer, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!importer)
+                    return null;
+                const resolveResult = yield this.resolve(source, importer, Object.assign(Object.assign({}, options), { skipSelf: true }));
+                if (!resolveResult)
+                    return null;
+                const absolutePath = resolveResult.id;
+                const isServerFile = (0, minimatch_1.minimatch)(absolutePath, path_1.default.join(process.cwd(), serverPattern));
+                if (!isServerFile)
+                    return null;
+                const requestedFromClient = (0, minimatch_1.minimatch)(importer, path_1.default.join(process.cwd(), clientPattern));
+                const tsPath = absolutePath + '.ts';
+                const jsPath = absolutePath + '.js';
+                const mjsPath = absolutePath + '.mjs';
+                let resolvedPath = '';
+                if (fs_1.default.existsSync(tsPath)) {
+                    resolvedPath = tsPath;
+                }
+                else if (fs_1.default.existsSync(jsPath)) {
+                    resolvedPath = jsPath;
+                }
+                else if (fs_1.default.existsSync(mjsPath)) {
+                    resolvedPath = mjsPath;
+                }
+                else {
+                    return null;
+                }
+                return {
+                    id: resolvedPath,
+                    meta: {
+                        isClient: requestedFromClient,
+                    }
+                };
+            });
+        },
+        load(id) {
+            var _a;
+            const meta = (_a = this.getModuleInfo(id)) === null || _a === void 0 ? void 0 : _a.meta;
+            if (meta === undefined || meta.isClient === undefined)
+                return null;
+            const originalContent = fs_1.default.readFileSync(id, 'utf8');
+            const project = new ts_morph_1.Project({
+                compilerOptions: {
+                    target: typescript_1.default.ScriptTarget.ES2017,
+                    module: typescript_1.default.ModuleKind.ESNext,
+                },
+            });
+            const sourceFile = project.createSourceFile(id, originalContent, { overwrite: true });
+            if (meta.isClient) {
+                sourceFile.getFunctions().forEach(func => {
+                    if (func.isExported() && func.isAsync()) {
+                        const funcName = String(func.getName());
+                        const lineNumber = func.getStartLineNumber();
+                        const funcParams = func.getParameters().map(p => p.getName()).join(', ');
+                        const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(process.cwd(), id), lineNumber);
+                        const newFunctionBody = `return window.${common_1.ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`;
+                        func.setBodyText(newFunctionBody);
+                    }
+                });
+                sourceFile.getVariableDeclarations().forEach(decl => {
+                    const initializer = decl.getInitializer();
+                    if (initializer && initializer instanceof ts_morph_1.ArrowFunction) {
+                        if (decl.isExported() && initializer.isAsync()) {
+                            const funcName = decl.getName();
+                            const lineNumber = decl.getStartLineNumber();
+                            const funcParams = initializer.getParameters().map(p => p.getName()).join(', ');
+                            const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(process.cwd(), id), lineNumber);
+                            const newFunctionBody = `return window.${common_1.ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`;
+                            initializer.setBodyText(newFunctionBody);
+                        }
+                    }
+                });
+            }
+            else {
+                const chunks = [];
+                sourceFile.getFunctions().forEach(func => {
+                    if (func.isExported() && func.isAsync()) {
+                        const funcName = String(func.getName());
+                        const lineNumber = func.getStartLineNumber();
+                        const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(process.cwd(), id), lineNumber);
+                        chunks.push(`global.${common_1.ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`);
+                    }
+                });
+                sourceFile.getVariableDeclarations().forEach(decl => {
+                    const initializer = decl.getInitializer();
+                    if (initializer && initializer instanceof ts_morph_1.ArrowFunction) {
+                        if (decl.isExported() && initializer.isAsync()) {
+                            const funcName = decl.getName();
+                            const lineNumber = decl.getStartLineNumber();
+                            const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(process.cwd(), id), lineNumber);
+                            chunks.push(`global.${common_1.ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`);
+                        }
+                    }
+                });
+                if (chunks.length > 0) {
+                    const textToAdd = `\nif (!global.${common_1.ZERO_COM_SERVER_REGISTRY}) global.${common_1.ZERO_COM_SERVER_REGISTRY} = Object.create(null); ${chunks.join(',')}`;
+                    sourceFile.insertText(sourceFile.getEnd(), textToAdd);
+                }
+            }
+            const result = project.emitToMemory();
+            const newContent = result.getFiles()[0].text;
+            return newContent;
+        },
+        renderChunk(code, chunk, options) {
+            if (development)
+                return null;
+            let modified = false;
+            let newCode = code;
+            replacements.forEach(({ target, replacement }) => {
+                if (newCode.includes(target)) {
+                    newCode = newCode.replaceAll(target, replacement);
+                    modified = true;
+                }
+            });
+            if (modified) {
+                return { code: newCode, map: null };
+            }
+            return null;
+        }
+    };
+}

package/lib/rollup.ts

@@ -0,0 +1,155 @@
+import fs from 'fs'
+import { minimatch } from 'minimatch'
+import path from 'path'
+import { ArrowFunction, Project } from 'ts-morph'
+import ts from 'typescript'
+import {
+  Plugin,
+  PluginContext,
+  ResolveIdResult,
+  LoadResult,
+  NormalizedOutputOptions,
+  RenderedChunk
+} from 'rollup'
+import { Options, ZERO_COM_CLIENT_SEND, ZERO_COM_SERVER_REGISTRY, formatFuncIdName } from './common'
+
+export function zeroComRollupPlugin(options: Options): Plugin {
+  const { development = true, patterns } = options
+  const compilationId = String(Math.floor(Math.random() * 1000000))
+  const clientPattern = patterns.client
+  const serverPattern = patterns.server
+
+  const replacements = [
+    { target: ZERO_COM_CLIENT_SEND, replacement: `__ZERO_COM_CLIENT_SEND_${compilationId}` },
+    { target: ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${compilationId}` }
+  ]
+
+  return {
+    name: 'zero-com-rollup-plugin',
+
+    async resolveId(this: PluginContext, source: string, importer: string | undefined, options: { isEntry: boolean }): Promise<ResolveIdResult> {
+      if (!importer) return null
+
+      const resolveResult = await this.resolve(source, importer, { ...options, skipSelf: true })
+      if (!resolveResult) return null
+
+      const absolutePath = resolveResult.id
+      const isServerFile = minimatch(absolutePath, path.join(process.cwd(), serverPattern))
+      if (!isServerFile) return null
+
+      const requestedFromClient = minimatch(importer, path.join(process.cwd(), clientPattern))
+
+      const tsPath = absolutePath + '.ts'
+      const jsPath = absolutePath + '.js'
+      const mjsPath = absolutePath + '.mjs'
+      let resolvedPath = ''
+
+      if (fs.existsSync(tsPath)) {
+        resolvedPath = tsPath
+      } else if (fs.existsSync(jsPath)) {
+        resolvedPath = jsPath
+      } else if (fs.existsSync(mjsPath)) {
+        resolvedPath = mjsPath
+      } else {
+        return null
+      }
+
+      return {
+        id: resolvedPath,
+        meta: {
+          isClient: requestedFromClient,
+        }
+      }
+    },
+
+    load(this: PluginContext, id: string): LoadResult {
+      const meta = this.getModuleInfo(id)?.meta
+      if (meta === undefined || meta.isClient === undefined) return null
+
+      const originalContent = fs.readFileSync(id, 'utf8')
+      const project = new Project({
+        compilerOptions: {
+          target: ts.ScriptTarget.ES2017,
+          module: ts.ModuleKind.ESNext,
+        },
+      })
+
+      const sourceFile = project.createSourceFile(id, originalContent, { overwrite: true })
+
+      if (meta.isClient) {
+        sourceFile.getFunctions().forEach(func => {
+          if (func.isExported() && func.isAsync()) {
+            const funcName = String(func.getName())
+            const lineNumber = func.getStartLineNumber()
+            const funcParams = func.getParameters().map(p => p.getName()).join(', ')
+            const funcId = formatFuncIdName(funcName, path.relative(process.cwd(), id), lineNumber)
+            const newFunctionBody = `return window.${ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`
+            func.setBodyText(newFunctionBody)
+          }
+        })
+        sourceFile.getVariableDeclarations().forEach(decl => {
+          const initializer = decl.getInitializer()
+          if (initializer && initializer instanceof ArrowFunction) {
+            if (decl.isExported() && initializer.isAsync()) {
+              const funcName = decl.getName()
+              const lineNumber = decl.getStartLineNumber()
+              const funcParams = initializer.getParameters().map(p => p.getName()).join(', ')
+              const funcId = formatFuncIdName(funcName, path.relative(process.cwd(), id), lineNumber)
+              const newFunctionBody = `return window.${ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`
+              initializer.setBodyText(newFunctionBody)
+            }
+          }
+        })
+      } else {
+        const chunks: string[] = []
+        sourceFile.getFunctions().forEach(func => {
+          if (func.isExported() && func.isAsync()) {
+            const funcName = String(func.getName())
+            const lineNumber = func.getStartLineNumber()
+            const funcId = formatFuncIdName(funcName, path.relative(process.cwd(), id), lineNumber)
+            chunks.push(`global.${ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`)
+          }
+        })
+        sourceFile.getVariableDeclarations().forEach(decl => {
+          const initializer = decl.getInitializer()
+          if (initializer && initializer instanceof ArrowFunction) {
+            if (decl.isExported() && initializer.isAsync()) {
+              const funcName = decl.getName()
+              const lineNumber = decl.getStartLineNumber()
+              const funcId = formatFuncIdName(funcName, path.relative(process.cwd(), id), lineNumber)
+              chunks.push(`global.${ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`)
+            }
+          }
+        })
+
+        if (chunks.length > 0) {
+          const textToAdd = `\nif (!global.${ZERO_COM_SERVER_REGISTRY}) global.${ZERO_COM_SERVER_REGISTRY} = Object.create(null); ${chunks.join(',')}`
+          sourceFile.insertText(sourceFile.getEnd(), textToAdd);
+        }
+      }
+
+      const result = project.emitToMemory()
+      const newContent = result.getFiles()[0].text
+      return newContent
+    },
+
+    renderChunk(this: PluginContext, code: string, chunk: RenderedChunk, options: NormalizedOutputOptions) {
+      if (development) return null
+
+      let modified = false
+      let newCode = code
+      replacements.forEach(({ target, replacement }) => {
+        if (newCode.includes(target)) {
+          newCode = newCode.replaceAll(target, replacement)
+          modified = true
+        }
+      })
+
+      if (modified) {
+        return { code: newCode, map: null }
+      }
+
+      return null
+    }
+  }
+}

package/lib/webpack.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZeroComWebpackPlugin = void 0;
+const fs_1 = __importDefault(require("fs"));
+const minimatch_1 = require("minimatch");
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+const typescript_1 = __importDefault(require("typescript"));
+const common_1 = require("./common");
+class ZeroComWebpackPlugin {
+    constructor(options) {
+        this.options = Object.assign(Object.assign({ development: true }, options), { patterns: Object.assign({}, options.patterns) });
+        this.compilationId = String(Math.floor(Math.random() * 1000000));
+        this.clientPattern = this.options.patterns.client;
+        this.serverPattern = this.options.patterns.server;
+    }
+    apply(compiler) {
+        const pluginName = ZeroComWebpackPlugin.name;
+        const { webpack } = compiler;
+        const { RawSource } = webpack.sources;
+        compiler.hooks.normalModuleFactory.tap(pluginName, (nmf) => {
+            nmf.hooks.beforeResolve.tap(pluginName, (resolveData) => {
+                const absolutePath = path_1.default.resolve(resolveData.context, resolveData.request);
+                const isServerFile = (0, minimatch_1.minimatch)(absolutePath, path_1.default.join(compiler.context, this.serverPattern));
+                if (!isServerFile)
+                    return;
+                const requestedFromClient = (0, minimatch_1.minimatch)(resolveData.contextInfo.issuer, path_1.default.join(compiler.context, this.clientPattern));
+                const tsPath = absolutePath + '.ts';
+                const jsPath = absolutePath + '.js';
+                const mjsPath = absolutePath + '.mjs';
+                let resolvedPath = '';
+                if (fs_1.default.existsSync(tsPath)) {
+                    resolvedPath = tsPath;
+                }
+                else if (fs_1.default.existsSync(jsPath)) {
+                    resolvedPath = jsPath;
+                }
+                else if (fs_1.default.existsSync(mjsPath)) {
+                    resolvedPath = mjsPath;
+                }
+                else {
+                    throw new Error('Unable to resolve: ' + absolutePath);
+                }
+                const originalContent = fs_1.default.readFileSync(resolvedPath, 'utf8');
+                const project = new ts_morph_1.Project({
+                    compilerOptions: {
+                        target: typescript_1.default.ScriptTarget.ES2017,
+                        module: typescript_1.default.ModuleKind.ESNext,
+                    },
+                });
+                const sourceFile = project.createSourceFile(absolutePath, originalContent, { overwrite: true });
+                let newModuleContent = '';
+                if (requestedFromClient) {
+                    const generatedFunctions = [];
+                    sourceFile.getFunctions().forEach(func => {
+                        if (func.isExported() && func.isAsync()) {
+                            const funcName = String(func.getName());
+                            const lineNumber = func.getStartLineNumber();
+                            const funcParams = func.getParameters().map(p => p.getName()).join(', ');
+                            const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
+                            const newFunctionBody = `return window.${common_1.ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`;
+                            func.setBodyText(newFunctionBody);
+                            generatedFunctions.push(func.getText());
+                            console.log('client:', funcId);
+                        }
+                    });
+                    sourceFile.getVariableDeclarations().forEach(decl => {
+                        const initializer = decl.getInitializer();
+                        if (initializer && initializer instanceof ts_morph_1.ArrowFunction) {
+                            if (decl.isExported() && initializer.isAsync()) {
+                                const funcName = decl.getName();
+                                const lineNumber = decl.getStartLineNumber();
+                                const funcParams = initializer.getParameters().map(p => p.getName()).join(', ');
+                                const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
+                                const newFunctionBody = `return window.${common_1.ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`;
+                                initializer.setBodyText(newFunctionBody);
+                                generatedFunctions.push(decl.getVariableStatementOrThrow().getText());
+                                console.log('client:', funcId);
+                            }
+                        }
+                    });
+                    newModuleContent = generatedFunctions.join('\n\n');
+                }
+                else {
+                    const chunks = [];
+                    sourceFile.getFunctions().forEach(func => {
+                        if (func.isExported() && func.isAsync()) {
+                            const funcName = String(func.getName());
+                            const lineNumber = func.getStartLineNumber();
+                            const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
+                            chunks.push(`global.${common_1.ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`);
+                            console.log('server:', funcId);
+                        }
+                    });
+                    sourceFile.getVariableDeclarations().forEach(decl => {
+                        const initializer = decl.getInitializer();
+                        if (initializer && initializer instanceof ts_morph_1.ArrowFunction) {
+                            if (decl.isExported() && initializer.isAsync()) {
+                                const funcName = decl.getName();
+                                const lineNumber = decl.getStartLineNumber();
+                                const funcId = (0, common_1.formatFuncIdName)(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
+                                chunks.push(`global.${common_1.ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`);
+                                console.log('server:', funcId);
+                            }
+                        }
+                    });
+                    newModuleContent = `${originalContent} if (!global.${common_1.ZERO_COM_SERVER_REGISTRY}) global.${common_1.ZERO_COM_SERVER_REGISTRY} = Object.create(null); ${chunks.join(',')}`;
+                }
+                project.createSourceFile(absolutePath + '.ts', newModuleContent, { overwrite: true });
+                const result = project.emitToMemory();
+                const newContent = result.getFiles()[0].text;
+                const inlineLoader = `data:text/javascript,${encodeURIComponent(newContent)}`;
+                resolveData.request = inlineLoader;
+            });
+        });
+        if (this.options.development)
+            return;
+        const replacements = [
+            { target: common_1.ZERO_COM_CLIENT_SEND, replacement: `__ZERO_COM_CLIENT_SEND_${this.compilationId}` },
+            { target: common_1.ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${this.compilationId}` }
+        ];
+        compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
+            compilation.hooks.processAssets.tap({ name: pluginName, stage: webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE }, (assets) => {
+                for (const assetName in assets) {
+                    if (assetName.endsWith('.js')) {
+                        let assetSource = String(assets[assetName].source());
+                        let modified = false;
+                        replacements.forEach(({ target, replacement }) => {
+                            if (assetSource.includes(target)) {
+                                assetSource = assetSource.replaceAll(target, replacement);
+                                modified = true;
+                            }
+                        });
+                        if (modified) {
+                            compilation.updateAsset(assetName, new RawSource(assetSource));
+                        }
+                    }
+                }
+            });
+        });
+    }
+}
+exports.ZeroComWebpackPlugin = ZeroComWebpackPlugin;

package/lib/webpack.ts

@@ -0,0 +1,167 @@
+import fs from 'fs'
+import { minimatch } from 'minimatch'
+import path from 'path'
+import { ArrowFunction, Project } from 'ts-morph'
+import ts from 'typescript'
+import { Compiler } from 'webpack'
+import { Options, ZERO_COM_CLIENT_SEND, ZERO_COM_SERVER_REGISTRY, formatFuncIdName } from './common'
+
+export type Message = {
+  funcId: string,
+  params: any[],
+  [key: string]: any
+}
+
+export class ZeroComWebpackPlugin {
+  private options: Options
+  private compilationId: string
+  private clientPattern: string
+  private serverPattern: string
+
+  constructor(options: Options) {
+    this.options = {
+      development: true,
+      ...options,
+      patterns: {
+        ...options.patterns
+      }
+    }
+    this.compilationId = String(Math.floor(Math.random() * 1000000))
+    this.clientPattern = this.options.patterns.client
+    this.serverPattern = this.options.patterns.server
+  }
+
+  apply(compiler: Compiler) {
+    const pluginName = ZeroComWebpackPlugin.name
+    const { webpack } = compiler
+    const { RawSource } = webpack.sources
+
+    compiler.hooks.normalModuleFactory.tap(pluginName, (nmf) => {
+      nmf.hooks.beforeResolve.tap(pluginName, (resolveData) => {
+        const absolutePath = path.resolve(resolveData.context, resolveData.request)
+        const isServerFile = minimatch(absolutePath, path.join(compiler.context, this.serverPattern))
+        if (!isServerFile) return
+
+        const requestedFromClient = minimatch(resolveData.contextInfo.issuer, path.join(compiler.context, this.clientPattern))
+
+        const tsPath = absolutePath + '.ts'
+        const jsPath = absolutePath + '.js'
+        const mjsPath = absolutePath + '.mjs'
+        let resolvedPath = ''
+
+        if (fs.existsSync(tsPath)) {
+          resolvedPath = tsPath
+        } else if (fs.existsSync(jsPath)) {
+          resolvedPath = jsPath
+        } else if (fs.existsSync(mjsPath)) {
+          resolvedPath = mjsPath
+        } else {
+          throw new Error('Unable to resolve: ' + absolutePath)
+        }
+
+        const originalContent = fs.readFileSync(resolvedPath, 'utf8')
+
+        const project = new Project({
+          compilerOptions: {
+            target: ts.ScriptTarget.ES2017,
+            module: ts.ModuleKind.ESNext,
+          },
+        })
+
+        const sourceFile = project.createSourceFile(absolutePath, originalContent, { overwrite: true })
+        let newModuleContent = ''
+
+        if (requestedFromClient) {
+          const generatedFunctions: string[] = []
+          sourceFile.getFunctions().forEach(func => {
+            if (func.isExported() && func.isAsync()) {
+              const funcName = String(func.getName())
+              const lineNumber = func.getStartLineNumber()
+              const funcParams = func.getParameters().map(p => p.getName()).join(', ')
+              const funcId = formatFuncIdName(funcName, path.relative(compiler.context, absolutePath), lineNumber)
+              const newFunctionBody = `return window.${ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`
+              func.setBodyText(newFunctionBody)
+              generatedFunctions.push(func.getText())
+              console.log('client:', funcId)
+            }
+          })
+          sourceFile.getVariableDeclarations().forEach(decl => {
+            const initializer = decl.getInitializer()
+            if (initializer && initializer instanceof ArrowFunction) {
+              if (decl.isExported() && initializer.isAsync()) {
+                const funcName = decl.getName()
+                const lineNumber = decl.getStartLineNumber()
+                const funcParams = initializer.getParameters().map(p => p.getName()).join(', ')
+                const funcId = formatFuncIdName(funcName, path.relative(compiler.context, absolutePath), lineNumber)
+                const newFunctionBody = `return window.${ZERO_COM_CLIENT_SEND}({funcId: '${funcId}', params: [${funcParams}]})`
+                initializer.setBodyText(newFunctionBody)
+                generatedFunctions.push(decl.getVariableStatementOrThrow().getText())
+                console.log('client:', funcId)
+              }
+            }
+          })
+          newModuleContent = generatedFunctions.join('\n\n')
+        } else {
+          const chunks: string[] = []
+          sourceFile.getFunctions().forEach(func => {
+            if (func.isExported() && func.isAsync()) {
+              const funcName = String(func.getName())
+              const lineNumber = func.getStartLineNumber()
+              const funcId = formatFuncIdName(funcName, path.relative(compiler.context, absolutePath), lineNumber)
+              chunks.push(`global.${ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`)
+              console.log('server:', funcId)
+            }
+          })
+          sourceFile.getVariableDeclarations().forEach(decl => {
+            const initializer = decl.getInitializer()
+            if (initializer && initializer instanceof ArrowFunction) {
+              if (decl.isExported() && initializer.isAsync()) {
+                const funcName = decl.getName()
+                const lineNumber = decl.getStartLineNumber()
+                const funcId = formatFuncIdName(funcName, path.relative(compiler.context, absolutePath), lineNumber)
+                chunks.push(`global.${ZERO_COM_SERVER_REGISTRY}['${funcId}'] = ${funcName}`)
+                console.log('server:', funcId)
+              }
+            }
+          })
+          newModuleContent = `${originalContent} if (!global.${ZERO_COM_SERVER_REGISTRY}) global.${ZERO_COM_SERVER_REGISTRY} = Object.create(null); ${chunks.join(',')}`
+        }
+
+        project.createSourceFile(absolutePath + '.ts', newModuleContent, { overwrite: true })
+        const result = project.emitToMemory()
+        const newContent = result.getFiles()[0].text
+        const inlineLoader = `data:text/javascript,${encodeURIComponent(newContent)}`
+        resolveData.request = inlineLoader
+      })
+    })
+
+    if (this.options.development) return
+
+    const replacements = [
+      { target: ZERO_COM_CLIENT_SEND, replacement: `__ZERO_COM_CLIENT_SEND_${this.compilationId}` },
+      { target: ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${this.compilationId}` }
+    ]
+
+    compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
+      compilation.hooks.processAssets.tap({ name: pluginName, stage: webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE }, (assets) => {
+        for (const assetName in assets) {
+          if (assetName.endsWith('.js')) {
+            let assetSource = String(assets[assetName].source())
+            let modified = false
+            replacements.forEach(({ target, replacement }) => {
+              if (assetSource.includes(target)) {
+                assetSource = assetSource.replaceAll(target, replacement)
+                modified = true
+              }
+            })
+            if (modified) {
+              compilation.updateAsset(assetName, new RawSource(assetSource))
+            }
+          }
+        }
+
+      })
+    })
+
+  }
+}