@boperators/plugin-tsc 0.1.0

package/README.md

@@ -0,0 +1,86 @@
+# @boperators/plugin-tsc
+
+A [ts-patch](https://github.com/package/ts-patch) plugin that runs [boperators](https://www.npmjs.com/package/boperators) transformations during `tsc` compilation.
+
+This plugin operates as a **Program Transformer** — it transforms your operator expressions before TypeScript type-checks the code, so the compiler sees valid function calls rather than unsupported operator usage on class types.
+
+## Installation
+
+```sh
+npm install -D boperators ts-patch @boperators/plugin-tsc
+```
+
+## Configuration
+
+Add the plugin to your `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [
+      {
+        "transform": "@boperators/plugin-tsc",
+        "transformProgram": true
+      }
+    ]
+  }
+}
+```
+
+### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `transform` | `string` | — | Must be `"@boperators/plugin-tsc"` |
+| `transformProgram` | `boolean` | — | Must be `true` |
+| `errorOnWarning` | `boolean` | `false` | Treat conflicting overload warnings as errors |
+
+## Usage
+
+Compile with `tspc` (ts-patch's compiler wrapper) instead of `tsc`:
+
+```sh
+npx tspc
+```
+
+Alternatively, patch your local TypeScript installation so `tsc` itself runs plugins:
+
+```sh
+npx ts-patch install
+npx tsc
+```
+
+To make the patch persist across installs, add a `prepare` script:
+
+```json
+{
+  "scripts": {
+    "prepare": "ts-patch install -s"
+  }
+}
+```
+
+## How It Works
+
+The plugin runs as a ts-patch Program Transformer, which executes during `ts.createProgram()` — before type-checking:
+
+1. Creates a [ts-morph](https://ts-morph.com) Project from your tsconfig
+2. Scans all source files for operator overload definitions
+3. Transforms expressions in project files (e.g. `v1 + v2` becomes `Vector3["+"][0](v1, v2)`)
+4. Returns a new TypeScript Program with the transformed source text
+
+TypeScript then type-checks and emits the transformed code, which contains only valid function calls.
+
+If transformation fails for any reason, the plugin logs the error and falls back to the original program (where operator expressions will surface as normal TypeScript type errors).
+
+## Comparison with Other Approaches
+
+| Approach | When it runs | Use case |
+|----------|-------------|----------|
+| **`@boperators/cli`** | Before compilation | Batch transform to disk, then compile normally |
+| **`@boperators/plugin-tsc`** | During compilation | Seamless `tsc` integration, no intermediate files |
+| **`@boperators/plugin-bun`** | At runtime | Bun-only, transforms on module load |
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_path_1 = __importDefault(require("node:path"));
+const boperators_1 = require("boperators");
+function normalizePath(p) {
+    return p.replace(/\\/g, "/");
+}
+const transformer = (program, host, config, extras) => {
+    const tsInstance = extras.ts;
+    const compilerOptions = program.getCompilerOptions();
+    const configFilePath = compilerOptions
+        .configFilePath;
+    const bopConfig = (0, boperators_1.loadConfig)({
+        searchDir: configFilePath ? node_path_1.default.dirname(configFilePath) : undefined,
+        overrides: { errorOnWarning: config.errorOnWarning },
+    });
+    if (!configFilePath) {
+        bopConfig.logger.warn("No tsconfig path found; skipping transformation.");
+        return program;
+    }
+    try {
+        // 1. Create ts-morph project from the same tsconfig
+        const tsMorphProject = new boperators_1.Project({
+            tsConfigFilePath: configFilePath,
+        });
+        const errorManager = new boperators_1.ErrorManager(bopConfig);
+        const overloadStore = new boperators_1.OverloadStore(tsMorphProject, errorManager, bopConfig.logger);
+        const overloadInjector = new boperators_1.OverloadInjector(tsMorphProject, overloadStore, bopConfig.logger);
+        // 2. Parse ALL files for overload definitions (including dependencies)
+        const allFiles = tsMorphProject.getSourceFiles();
+        for (const file of allFiles) {
+            overloadStore.addOverloadsFromFile(file);
+        }
+        errorManager.throwIfErrorsElseLogWarnings();
+        // 3. Filter to project files only (same logic as CLI)
+        const projectDir = `${normalizePath(node_path_1.default.dirname(configFilePath))}/`;
+        const projectFiles = allFiles.filter((file) => {
+            const filePath = file.getFilePath();
+            if (filePath.endsWith(".d.ts"))
+                return false;
+            if (filePath.includes("/node_modules/"))
+                return false;
+            return filePath.startsWith(projectDir);
+        });
+        // 4. Transform project files and collect results
+        const transformedTexts = new Map();
+        for (const file of projectFiles) {
+            const originalText = file.getFullText();
+            const result = overloadInjector.overloadFile(file);
+            if (result.text !== originalText) {
+                transformedTexts.set(file.getFilePath(), result.text);
+            }
+        }
+        errorManager.throwIfErrorsElseLogWarnings();
+        // 5. Short-circuit if nothing changed
+        if (transformedTexts.size === 0) {
+            return program;
+        }
+        // 6. Create proxy CompilerHost that returns transformed source files
+        const originalHost = host !== null && host !== void 0 ? host : tsInstance.createCompilerHost(compilerOptions);
+        const originalGetSourceFile = originalHost.getSourceFile.bind(originalHost);
+        const proxyHost = Object.assign(Object.assign({}, originalHost), { getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
+                const normalized = normalizePath(fileName);
+                const transformedText = transformedTexts.get(normalized);
+                if (transformedText !== undefined) {
+                    return tsInstance.createSourceFile(fileName, transformedText, languageVersionOrOptions);
+                }
+                return originalGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+            } });
+        // 7. Create and return new program with transformed files
+        return tsInstance.createProgram(program.getRootFileNames(), compilerOptions, proxyHost);
+    }
+    catch (error) {
+        bopConfig.logger.error(`Transformation failed: ${error}`);
+        return program;
+    }
+};
+module.exports = transformer;

package/license.txt

@@ -0,0 +1,8 @@
+Copyright 2025 Dief Bell
+
+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.
+

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "@boperators/plugin-tsc",
+	"version": "0.1.0",
+	"license": "MIT",
+	"description": "ts-patch plugin for boperators - transforms operator overloads during tsc compilation.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/DiefBell/boperators",
+		"directory": "plugins/tsc"
+	},
+	"homepage": "https://github.com/DiefBell/boperators/tree/main/plugins/tsc",
+	"type": "commonjs",
+	"main": "./dist/index.js",
+	"keywords": [
+		"boperators",
+		"typescript",
+		"operator",
+		"overload",
+		"operator-overloading",
+		"ts-patch",
+		"tsc",
+		"transform"
+	],
+	"scripts": {
+		"build": "tsc",
+		"watch": "tsc -w",
+		"prepublish": "bun run build"
+	},
+	"files": [
+		"package.json",
+		"README.md",
+		"license.txt",
+		"dist"
+	],
+	"peerDependencies": {
+		"boperators": "0.1.0",
+		"typescript": ">=5.0.0 <5.10.0"
+	}
+}