zero-com 0.0.2 → 0.0.3

package/index.js

@@ -0,0 +1,123 @@
+"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"));
+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 ZERO_COM_CLIENT_SEND = 'ZERO_COM_CLIENT_SEND';
+        const ZERO_COM_SERVER_REGISTRY = 'ZERO_COM_SERVER_REGISTRY';
+        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 method = formatMethodName(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
+                            const newFunctionBody = `return window.${ZERO_COM_CLIENT_SEND}({method: '${method}', params: [${funcParams}]})`;
+                            func.setBodyText(newFunctionBody);
+                            generatedFunctions.push(func.getText());
+                            console.log('client:', method);
+                        }
+                    });
+                    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 method = formatMethodName(funcName, path_1.default.relative(compiler.context, absolutePath), lineNumber);
+                            chunks.push(`global.${ZERO_COM_SERVER_REGISTRY}['${method}'] = ${funcName}`);
+                            console.log('server:', method);
+                        }
+                    });
+                    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));
+                        }
+                    }
+                }
+            });
+        });
+    }
+}
+exports.ZeroComWebpackPlugin = ZeroComWebpackPlugin;
+const formatMethodName = (funcName, path, line) => {
+    return `${funcName}@${path}:${line}`;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-com",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "main": "index.js",
   "scripts": {
     "build": "npx tsc"