@golar-rstack/rspack 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oskar Lebuda
+
+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/README.md

@@ -0,0 +1,61 @@
+# @golar-rstack/rspack
+
+Run [golar](https://golar.dev) type checking and type-aware linting in a
+separate process as an Rspack plugin.
+
+Because golar is built on `typescript-go` and understands embedded languages,
+type errors inside `.vue`, `.svelte`, `.astro` and `.gts` files are reported at
+their real position in the source file.
+
+Using Rsbuild? Use [`@golar-rstack/rsbuild`](https://www.npmjs.com/package/@golar-rstack/rsbuild)
+instead.
+
+## Install
+
+```bash
+pnpm add -D @golar-rstack/rspack golar
+```
+
+## Usage
+
+Create `golar.config.ts` in your project root. golar discovers it relative to
+its working directory:
+
+```ts
+import { defineConfig } from 'golar/unstable'
+import '@golar/vue'
+
+export default defineConfig({})
+```
+
+```ts
+// rspack.config.ts
+import { GolarRspackPlugin } from '@golar-rstack/rspack'
+
+export default {
+  plugins: [new GolarRspackPlugin()],
+}
+```
+
+In watch mode the check runs asynchronously and is pushed to the dev server's
+error overlay. In a one-off build the compilation waits for golar, so type
+errors fail the build.
+
+## Options
+
+See the [repository README](https://github.com/OskarLebuda/golar-rstack-plugin#options)
+for the full list. Two worth knowing up front:
+
+- `lintSeverity` defaults to `'warning'`, because golar exits 0 when only lint
+  rules fire.
+- `cwd` defaults to the compiler `context` and is what selects the golar config,
+  since golar has no `--config` flag.
+
+## Requirements
+
+- Node.js >= 22.12
+- `golar` installed in the project
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,122 @@
+import type { Compiler } from '@rspack/core';
+import { GolarMode } from '@golar-rstack/core';
+import { GolarOptions } from '@golar-rstack/core';
+import { Issue } from '@golar-rstack/core';
+import { IssueFilter } from '@golar-rstack/core';
+import { IssueOrigin } from '@golar-rstack/core';
+import { IssueSeverity } from '@golar-rstack/core';
+
+/**
+ * An error shaped the way Rspack expects.
+ *
+ * Rspack only renders `loc` for errors carrying a real `NormalModule`, which
+ * this plugin has no way to supply, so the position is folded into `file`
+ * instead. This is the same workaround ts-checker-rspack-plugin uses.
+ */
+export declare class GolarIssueError extends Error {
+    readonly issue: Issue;
+    readonly hideStack = true;
+    file?: string;
+    /**
+     * @param message The formatted text Rspack will display.
+     * @param issue The issue this error was built from, kept so consumers can
+     * inspect the original diagnostic.
+     */
+    constructor(message: string, issue: Issue);
+}
+
+export { GolarMode }
+
+export { GolarOptions }
+
+/**
+ * Runs [golar](https://golar.dev), which type checks and lints TypeScript and
+ * embedded languages such as Vue, Svelte and Astro, in a separate process, and
+ * reports what it finds as Rspack errors and warnings.
+ */
+export declare class GolarRspackPlugin {
+    private readonly options;
+    /**
+     * @param options Plugin options. See the package README for the defaults.
+     */
+    constructor(options?: GolarRspackPluginOptions);
+    /**
+     * Registers the plugin on a compiler. Called by Rspack.
+     *
+     * @param compiler The compiler to attach to.
+     */
+    apply(compiler: Compiler): void;
+    /**
+     * Records the dev server's `done` tap so async results can be replayed into
+     * the browser overlay.
+     *
+     * Installed from `apply` so the interceptor is in place before the dev server
+     * registers its own tap.
+     *
+     * @param compiler The compiler being set up.
+     * @param state State to store the captured tap on.
+     */
+    private interceptDevServerTap;
+    /**
+     * Resolves options and installs the reporting hooks on the first run.
+     *
+     * This is deferred because the default for `async` depends on whether this is
+     * a build or a watch, which is not known when `apply` runs.
+     *
+     * @param compiler The compiler being set up.
+     * @param state State to mark as initialized.
+     */
+    private tapInitialization;
+    /**
+     * Starts a golar run for each compilation, superseding any run still going.
+     *
+     * Runs are chained rather than overlapped, because golar is a whole project
+     * check backed by a native process and concurrency would only contend for
+     * CPU.
+     *
+     * @param compiler The compiler being set up.
+     * @param state State holding the current run and its abort controller.
+     * @param logger Infrastructure logger used for debug output.
+     */
+    private tapCompilationToRunGolar;
+    /**
+     * Installs blocking reporting, where the compilation waits for golar and owns
+     * the issues it found.
+     *
+     * @param compiler The compiler being set up.
+     * @param state State holding the current run.
+     */
+    private tapAfterCompileToReport;
+    /**
+     * Installs async reporting, where the build is never held up.
+     *
+     * Issues are logged when they arrive and, if a dev server is listening, its
+     * `done` tap is replayed with the issues attached. That re-sends the stats
+     * over the HMR socket, which is what makes the browser overlay show them.
+     *
+     * @param compiler The compiler being set up.
+     * @param state State holding the current run and the captured dev server tap.
+     */
+    private tapDoneToReportAsync;
+    /**
+     * Aborts any run still going when the compiler shuts down.
+     *
+     * @param compiler The compiler being set up.
+     * @param state State holding the abort controller.
+     */
+    private tapCloseToAbort;
+}
+
+export declare interface GolarRspackPluginOptions extends GolarOptions {
+    devServer?: boolean;
+}
+
+export { Issue }
+
+export { IssueFilter }
+
+export { IssueOrigin }
+
+export { IssueSeverity }
+
+export { }

package/dist/index.js

@@ -0,0 +1,159 @@
+import node_path from "node:path";
+import node_process from "node:process";
+import { GolarAbortError, formatIssue, formatIssueSummary, resolveGolarOptions, runGolar } from "@golar-rstack/core";
+class GolarIssueError extends Error {
+    issue;
+    hideStack = true;
+    file;
+    constructor(message, issue){
+        super(message), this.issue = issue;
+        this.name = 'GolarIssueError';
+        if (issue.file) {
+            const relative = node_path.relative(node_process.cwd(), issue.file);
+            this.file = relative.startsWith('..') ? issue.file : relative;
+            if (issue.location) this.file += `:${issue.location.line}:${issue.location.column}`;
+        }
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+function prepareIssues(issues, options) {
+    const filtered = options.filter ? issues.filter((issue)=>options.filter(issue)) : issues;
+    if (options.failOnError) return filtered;
+    return filtered.map((issue)=>'error' === issue.severity ? {
+            ...issue,
+            severity: 'warning'
+        } : issue);
+}
+function pushIssues(compilation, issues, options) {
+    for (const issue of issues){
+        const error = new GolarIssueError(formatIssue(issue, {
+            cwd: options.cwd,
+            formatter: options.formatter
+        }), issue);
+        if ('warning' === issue.severity) compilation.warnings.push(error);
+        else compilation.errors.push(error);
+    }
+}
+function createPluginState() {
+    return {
+        initialized: false,
+        watching: false,
+        iteration: 0
+    };
+}
+const PLUGIN_NAME = 'GolarRspackPlugin';
+const DEV_SERVER_TAPS = [
+    'webpack-dev-server',
+    'rspack-dev-server',
+    'rsbuild-dev-server'
+];
+class GolarRspackPlugin {
+    options;
+    constructor(options = {}){
+        this.options = options;
+    }
+    apply(compiler) {
+        const state = createPluginState();
+        const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
+        this.interceptDevServerTap(compiler, state);
+        this.tapInitialization(compiler, state);
+        this.tapCompilationToRunGolar(compiler, state, logger);
+        this.tapCloseToAbort(compiler, state);
+    }
+    interceptDevServerTap(compiler, state) {
+        if (false === this.options.devServer) return;
+        compiler.hooks.done.intercept({
+            register: (tap)=>{
+                const candidate = tap;
+                if (DEV_SERVER_TAPS.includes(candidate.name) && 'sync' === candidate.type) state.devServerDoneTap = candidate;
+                return tap;
+            }
+        });
+    }
+    tapInitialization(compiler, state) {
+        const initialize = (watching)=>{
+            if (state.initialized) return;
+            state.initialized = true;
+            state.watching = watching;
+            state.options = resolveGolarOptions(this.options, {
+                cwd: compiler.context ?? process.cwd(),
+                watch: watching
+            });
+            if (state.options.async) this.tapDoneToReportAsync(compiler, state);
+            else this.tapAfterCompileToReport(compiler, state);
+        };
+        compiler.hooks.run.tap(PLUGIN_NAME, ()=>initialize(false));
+        compiler.hooks.watchRun.tap(PLUGIN_NAME, ()=>initialize(true));
+    }
+    tapCompilationToRunGolar(compiler, state, logger) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+            if (compilation.compiler !== compiler) return;
+            const options = state.options;
+            if (!options) return;
+            const iteration = ++state.iteration;
+            state.abortController?.abort();
+            const abortController = new AbortController();
+            state.abortController = abortController;
+            state.issuesPromise = (state.issuesPromise ?? Promise.resolve(void 0)).catch(()=>void 0).then(async ()=>{
+                if (abortController.signal.aborted) return;
+                logger.debug(`Running golar, iteration ${iteration}.`);
+                try {
+                    const result = await runGolar(options, abortController.signal);
+                    logger.debug(`golar iteration ${iteration} found ${result.issues.length} issue(s).`);
+                    return result.issues;
+                } catch (error) {
+                    if (error instanceof GolarAbortError) return void logger.debug(`golar iteration ${iteration} aborted.`);
+                    compilation.errors.push(error);
+                    return;
+                } finally{
+                    if (state.abortController === abortController) state.abortController = void 0;
+                }
+            });
+        });
+    }
+    tapAfterCompileToReport(compiler, state) {
+        compiler.hooks.afterCompile.tapPromise(PLUGIN_NAME, async (compilation)=>{
+            if (compilation.compiler !== compiler || !state.options) return;
+            const issues = await state.issuesPromise;
+            if (!issues) return;
+            pushIssues(compilation, prepareIssues(issues, state.options), state.options);
+        });
+    }
+    tapDoneToReportAsync(compiler, state) {
+        const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
+        compiler.hooks.done.tap(PLUGIN_NAME, (stats)=>{
+            if (stats.compilation.compiler !== compiler || !state.options) return;
+            const options = state.options;
+            const issuesPromise = state.issuesPromise;
+            (async ()=>{
+                let issues;
+                try {
+                    issues = await issuesPromise;
+                } catch  {
+                    return;
+                }
+                if (!issues || state.issuesPromise !== issuesPromise) return;
+                const prepared = prepareIssues(issues, options);
+                if (0 === prepared.length) return void logger.info('No golar issues found.');
+                logger.error(formatIssueSummary(prepared));
+                for (const issue of prepared)logger.error(formatIssue(issue, {
+                    cwd: options.cwd,
+                    formatter: options.formatter
+                }));
+                if (state.devServerDoneTap) {
+                    pushIssues(stats.compilation, prepared, options);
+                    state.devServerDoneTap.fn(stats);
+                }
+            })();
+        });
+    }
+    tapCloseToAbort(compiler, state) {
+        const abort = ()=>{
+            state.abortController?.abort();
+            state.abortController = void 0;
+        };
+        compiler.hooks.watchClose.tap(PLUGIN_NAME, abort);
+        compiler.hooks.shutdown?.tap(PLUGIN_NAME, abort);
+    }
+}
+export { GolarIssueError, GolarRspackPlugin };

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@golar-rstack/rspack",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Run golar type checking and linting in a separate process as an Rspack plugin",
+  "license": "MIT",
+  "author": "Oskar Lebuda",
+  "keywords": [
+    "golar",
+    "rspack",
+    "rspack-plugin",
+    "typecheck",
+    "typescript",
+    "vue",
+    "svelte",
+    "astro",
+    "rstack"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@golar-rstack/core": "0.1.0"
+  },
+  "peerDependencies": {
+    "@rspack/core": "^1.0.0 || ^2.0.0",
+    "golar": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@rspack/core": {
+      "optional": true
+    },
+    "golar": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.23.2",
+    "@rspack/core": "^2.1.5",
+    "@rstest/core": "^0.11.4",
+    "@types/node": "^24.13.3",
+    "typescript": "^6.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "test": "rstest run",
+    "check:publish": "publint && attw --pack ."
+  }
+}