@magelight/vite-plugin 0.28.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Severause
+
+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,22 @@
+# @magelight/vite-plugin
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { magelight } from '@magelight/vite-plugin';
+
+export default defineConfig({
+  plugins: [react(), magelight({ entries: { config: 'index.html', hud: 'hud.html' } })],
+});
+```
+
+`vite build` then writes `views/config/index.html` and `views/hud/index.html`, each with only the
+assets that page reaches, ready to be named from `manifest.json` (`"path": "views/config/index.html"`).
+
+What it sets for you: `base: './'` (file:// loading), es2022 output (Ultralight 1.4's WebKit
+615; es2019 was the 1.3-era rule), no `crossorigin` on module tags (a null origin refuses CORS
+loads → blank page), no modulepreload polyfill, per-entry pruning (the rule SeverActions'
+`build-ui.ps1` enforced by hand).
+
+Options: `entries`, `viewsDir` (`views`), `single` (`index`), `outDir` (`dist`), `keepDist`.

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from 'vite';
+export interface MagelightPluginOptions {
+    /**
+     * Entry pages, view name → html file (relative to the project root).
+     * Each becomes its own pruned folder `<viewsDir>/<name>/index.html` holding
+     * only the assets that entry reaches. Omit for a single-entry project
+     * (Vite's own `index.html` → `<viewsDir>/<single>`, default `index`).
+     */
+    entries?: Record<string, string>;
+    /** where the per-view folders go, relative to the project root (default `views`) */
+    viewsDir?: string;
+    /** name for the single-entry case (default `index`) */
+    single?: string;
+    /** Vite's intermediate outDir (default `dist`) — pruned copies are made from it */
+    outDir?: string;
+    /** leave `dist` in place after the views are written (default false) */
+    keepDist?: boolean;
+}
+/**
+ * What every Magelight page needs from Vite, learned on SeverActions:
+ *  - `base: './'` — pages load from file:///, absolute asset URLs break
+ *  - `crossorigin` stripped from module tags — a null origin refuses CORS-mode loads (blank page)
+ *  - es2022 output — Ultralight 1.4 (WebKit 615) evaluates it; es2019 was the 1.3-era rule
+ *  - multi-entry builds emit ONE dist; each view folder must carry only its own closure
+ *    (SeverActions' build-ui.ps1 did this by hand; here it is the plugin's job)
+ */
+export declare function magelight(opts?: MagelightPluginOptions): Plugin;
+export default magelight;

package/dist/index.js

@@ -0,0 +1,153 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * What every Magelight page needs from Vite, learned on SeverActions:
+ *  - `base: './'` — pages load from file:///, absolute asset URLs break
+ *  - `crossorigin` stripped from module tags — a null origin refuses CORS-mode loads (blank page)
+ *  - es2022 output — Ultralight 1.4 (WebKit 615) evaluates it; es2019 was the 1.3-era rule
+ *  - multi-entry builds emit ONE dist; each view folder must carry only its own closure
+ *    (SeverActions' build-ui.ps1 did this by hand; here it is the plugin's job)
+ */
+export function magelight(opts = {}) {
+    var _a, _b;
+    const viewsDir = (_a = opts.viewsDir) !== null && _a !== void 0 ? _a : 'views';
+    const outDir = (_b = opts.outDir) !== null && _b !== void 0 ? _b : 'dist';
+    let root = process.cwd();
+    // chunk fileName → the files it needs (imports + css + assets), filled in generateBundle
+    const closure = new Map();
+    const entryFile = new Map(); // view name → html fileName in the bundle
+    return {
+        name: 'magelight',
+        config() {
+            const input = {};
+            if (opts.entries)
+                for (const [k, v] of Object.entries(opts.entries))
+                    input[k] = path.resolve(root, v);
+            return {
+                base: './',
+                build: {
+                    outDir,
+                    assetsDir: 'assets',
+                    target: 'es2022',
+                    sourcemap: false,
+                    chunkSizeWarningLimit: 4000,
+                    modulePreload: { polyfill: false },
+                    rollupOptions: opts.entries ? { input, output: { manualChunks: undefined } } : { output: { manualChunks: undefined } },
+                },
+            };
+        },
+        configResolved(cfg) {
+            root = cfg.root;
+        },
+        transformIndexHtml(html) {
+            return html.replace(/\scrossorigin(="[^"]*")?/g, '');
+        },
+        generateBundle(_, bundle) {
+            var _a, _b;
+            // Chunks and assets are here; the HTML entries are emitted by Vite's
+            // own html plugin AFTER this hook, so they are discovered on disk in
+            // closeBundle instead.
+            for (const [file, out] of Object.entries(bundle)) {
+                if (out.type !== 'chunk')
+                    continue;
+                const deps = new Set();
+                for (const i of out.imports)
+                    deps.add(i);
+                for (const i of out.dynamicImports)
+                    deps.add(i);
+                const meta = out.viteMetadata;
+                (_a = meta === null || meta === void 0 ? void 0 : meta.importedCss) === null || _a === void 0 ? void 0 : _a.forEach((c) => deps.add(c));
+                (_b = meta === null || meta === void 0 ? void 0 : meta.importedAssets) === null || _b === void 0 ? void 0 : _b.forEach((a) => deps.add(a));
+                closure.set(file, deps);
+            }
+        },
+        closeBundle() {
+            var _a, _b;
+            const dist = path.resolve(root, outDir);
+            const views = path.resolve(root, viewsDir);
+            if (!fs.existsSync(dist))
+                return;
+            // Entry html files as Vite wrote them (relative to dist), mapped to view names.
+            const htmls = fs.readdirSync(dist, { recursive: true })
+                .filter((f) => f.endsWith('.html'))
+                .map((f) => f.split(path.sep).join('/'));
+            const norm = (s) => s.split(path.sep).join('/').replace(/^\.\//, '');
+            for (const html of htmls) {
+                let name;
+                if (opts.entries) {
+                    const exact = Object.entries(opts.entries).filter(([, v]) => norm(v) === html);
+                    if (exact.length) {
+                        name = exact[0][0];
+                    }
+                    else {
+                        // Vite flattens some inputs — fall back to the file name, but only
+                        // when ONE entry carries it: pages/a/index.html + pages/b/index.html
+                        // must not both claim the first match.
+                        const byBase = Object.entries(opts.entries).filter(([, v]) => path.posix.basename(norm(v)) === path.posix.basename(html));
+                        if (byBase.length === 1)
+                            name = byBase[0][0];
+                        else if (byBase.length > 1)
+                            console.warn(`[magelight] ${html}: ambiguous — entries ${byBase.map(([k]) => k).join(', ')} share a file name; skipped`);
+                    }
+                }
+                else {
+                    if (htmls.length > 1 && html !== 'index.html') {
+                        console.warn(`[magelight] ${html}: single-entry mode emits one view ('${(_a = opts.single) !== null && _a !== void 0 ? _a : 'index'}'); extra html skipped — use 'entries' for a multi-view project`);
+                        continue;
+                    }
+                    name = (_b = opts.single) !== null && _b !== void 0 ? _b : 'index';
+                }
+                if (name)
+                    entryFile.set(name, html);
+            }
+            let total = 0;
+            for (const [name, htmlFile] of entryFile) {
+                const src = fs.readFileSync(path.join(dist, htmlFile), 'utf8');
+                const htmlDir = path.posix.dirname(htmlFile);
+                const roots = new Set();
+                for (const m of src.matchAll(/(?:src|href)="\.\/([^"]+)"/g))
+                    roots.add(path.posix.normalize(path.posix.join(htmlDir, m[1])));
+                const needed = new Set();
+                const walk = (f) => {
+                    var _a;
+                    if (needed.has(f))
+                        return;
+                    needed.add(f);
+                    (_a = closure.get(f)) === null || _a === void 0 ? void 0 : _a.forEach(walk);
+                };
+                roots.forEach(walk);
+                const dst = path.join(views, name);
+                fs.rmSync(dst, { recursive: true, force: true });
+                fs.mkdirSync(dst, { recursive: true });
+                fs.writeFileSync(path.join(dst, 'index.html'), src.replace(/(src|href)="\.\/([^"]+)"/g, (_m, a, rel) => `${a}="./${path.posix.relative('', path.posix.normalize(path.posix.join(htmlDir, rel)))}"`));
+                for (const f of needed) {
+                    const from = path.join(dist, f);
+                    if (!fs.existsSync(from))
+                        continue;
+                    const to = path.join(dst, f);
+                    fs.mkdirSync(path.dirname(to), { recursive: true });
+                    fs.copyFileSync(from, to);
+                    total++;
+                }
+                // public/ files (copied verbatim by Vite) are not in the graph — carry them all.
+                const pub = path.resolve(root, 'public');
+                if (fs.existsSync(pub)) {
+                    for (const f of fs.readdirSync(pub, { recursive: true })) {
+                        const from = path.join(pub, f);
+                        if (fs.statSync(from).isFile()) {
+                            const to = path.join(dst, f);
+                            fs.mkdirSync(path.dirname(to), { recursive: true });
+                            fs.copyFileSync(from, to);
+                        }
+                    }
+                }
+                console.log(`[magelight] view '${name}' -> ${path.relative(root, dst)} (${needed.size + 1} files)`);
+            }
+            if (!opts.keepDist)
+                fs.rmSync(dist, { recursive: true, force: true });
+            if (!total)
+                console.warn('[magelight] no entries were written — check `entries` names match the html files');
+        },
+    };
+}
+export default magelight;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@magelight/vite-plugin",
+  "version": "0.28.6",
+  "description": "Vite plugin for Magelight UI pages: file:// safe output, per-entry pruned view folders, crossorigin strip.",
+  "license": "MIT",
+  "repository": { "type": "git", "url": "git+https://github.com/Severause/MagelightUI.git", "directory": "packages/vite-plugin" },
+  "publishConfig": { "access": "public" },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" }
+  },
+  "files": ["dist", "README.md"],
+  "engines": { "node": ">=20" },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "npm run build"
+  },
+  "peerDependencies": {
+    "vite": ">=5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "~5.9.3",
+    "vite": "^7.3.1"
+  }
+}