revojs 0.1.18 → 0.1.20

package/dist/vite/index.js

@@ -0,0 +1,435 @@
+import { CLIENT, SERVER, SERVER_CONTEXT, Scope, createApp, invoke } from "../app-C4yy27ko.js";
+import { useKit } from "../kit-Bzr1NqHb.js";
+import { basename, dirname, isAbsolute, join, posix, relative, win32 } from "path";
+import { isRunnableDevEnvironment } from "vite";
+import { once } from "events";
+import { Readable, Stream } from "stream";
+import { existsSync, readFileSync } from "fs";
+import { globSync } from "tinyglobby";
+import { rm } from "fs/promises";
+
+//#region src/vite/node/index.ts
+function splitSetCookieString(cookiesString) {
+	if (Array.isArray(cookiesString)) return cookiesString.flatMap((c) => splitSetCookieString(c));
+	if (typeof cookiesString !== "string") return [];
+	const cookiesStrings = [];
+	let pos = 0;
+	let start;
+	let ch;
+	let lastComma;
+	let nextStart;
+	let cookiesSeparatorFound;
+	const skipWhitespace = () => {
+		while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) pos += 1;
+		return pos < cookiesString.length;
+	};
+	const notSpecialChar = () => {
+		ch = cookiesString.charAt(pos);
+		return ch !== "=" && ch !== ";" && ch !== ",";
+	};
+	while (pos < cookiesString.length) {
+		start = pos;
+		cookiesSeparatorFound = false;
+		while (skipWhitespace()) {
+			ch = cookiesString.charAt(pos);
+			if (ch === ",") {
+				lastComma = pos;
+				pos += 1;
+				skipWhitespace();
+				nextStart = pos;
+				while (pos < cookiesString.length && notSpecialChar()) pos += 1;
+				if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+					cookiesSeparatorFound = true;
+					pos = nextStart;
+					cookiesStrings.push(cookiesString.slice(start, lastComma));
+					start = pos;
+				} else pos = lastComma + 1;
+			} else pos += 1;
+		}
+		if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.slice(start));
+	}
+	return cookiesStrings;
+}
+function createReadableStreamFromReadable(source) {
+	let pump = new StreamPump(source);
+	return new ReadableStream(pump, pump);
+}
+var StreamPump = class {
+	highWaterMark;
+	accumalatedSize;
+	stream;
+	controller;
+	constructor(stream) {
+		this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
+		this.accumalatedSize = 0;
+		this.stream = stream;
+		this.enqueue = this.enqueue.bind(this);
+		this.error = this.error.bind(this);
+		this.close = this.close.bind(this);
+	}
+	size(chunk) {
+		return chunk?.byteLength || 0;
+	}
+	start(controller) {
+		this.controller = controller;
+		this.stream.on("data", this.enqueue);
+		this.stream.once("error", this.error);
+		this.stream.once("end", this.close);
+		this.stream.once("close", this.close);
+	}
+	pull() {
+		this.resume();
+	}
+	cancel(reason) {
+		if (this.stream.destroy) this.stream.destroy(reason);
+		this.stream.off("data", this.enqueue);
+		this.stream.off("error", this.error);
+		this.stream.off("end", this.close);
+		this.stream.off("close", this.close);
+	}
+	enqueue(chunk) {
+		if (this.controller) try {
+			let bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+			let available = (this.controller.desiredSize || 0) - bytes.byteLength;
+			this.controller.enqueue(bytes);
+			if (available <= 0) this.pause();
+		} catch (error) {
+			this.controller.error(/* @__PURE__ */ new Error("Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"));
+			this.cancel();
+		}
+	}
+	pause() {
+		if (this.stream.pause) this.stream.pause();
+	}
+	resume() {
+		if (this.stream.readable && this.stream.resume) this.stream.resume();
+	}
+	close() {
+		if (this.controller) {
+			this.controller.close();
+			delete this.controller;
+		}
+	}
+	error(error) {
+		if (this.controller) {
+			this.controller.error(error);
+			delete this.controller;
+		}
+	}
+};
+function fromNodeHeaders(nodeHeaders) {
+	let headers = new Headers();
+	for (let [key, values] of Object.entries(nodeHeaders)) if (values) if (Array.isArray(values)) for (let value of values) headers.append(key, value);
+	else headers.set(key, values);
+	return headers;
+}
+function fromNodeRequest(nodeReq, nodeRes) {
+	let origin = nodeReq.headers.origin && "null" !== nodeReq.headers.origin ? nodeReq.headers.origin : `http://${nodeReq.headers.host}`;
+	let url = new URL(nodeReq.url ?? "", origin);
+	let controller = new AbortController();
+	let init = {
+		method: nodeReq.method,
+		headers: fromNodeHeaders(nodeReq.headers),
+		signal: controller.signal
+	};
+	if (nodeReq.method !== "GET" && nodeReq.method !== "HEAD") {
+		init.body = createReadableStreamFromReadable(nodeReq);
+		init.duplex = "half";
+	}
+	nodeRes.on("finish", () => controller = null);
+	nodeRes.on("close", () => controller?.abort());
+	return new Request(url.href, init);
+}
+async function toNodeRequest(res, nodeRes) {
+	nodeRes.statusCode = res.status;
+	nodeRes.statusMessage = res.statusText;
+	let cookiesStrings = [];
+	for (let [name$1, value] of res.headers) if (name$1 === "set-cookie") cookiesStrings.push(...splitSetCookieString(value));
+	else nodeRes.setHeader(name$1, value);
+	if (cookiesStrings.length) nodeRes.setHeader("set-cookie", cookiesStrings);
+	if (res.body) {
+		let responseBody = res.body;
+		let readable = Readable.from(responseBody);
+		readable.pipe(nodeRes);
+		await once(readable, "end");
+	} else nodeRes.end();
+}
+
+//#endregion
+//#region src/vite/plugins/client.ts
+const SUFFIX = "?client";
+function client() {
+	let server;
+	let bundle;
+	return {
+		name: "client",
+		sharedDuringBuild: true,
+		configureServer(devServer) {
+			server = devServer;
+		},
+		writeBundle(_, clientBundle) {
+			if (this.environment.name === CLIENT) bundle = clientBundle;
+		},
+		load(key) {
+			if (key.endsWith(SUFFIX)) {
+				const path = key.substring(0, key.length - 7);
+				if (bundle) for (const name$1 in bundle) {
+					const file = bundle[name$1];
+					if (file && file.type === "asset" && file.fileName === basename(path)) return file.source.toString();
+				}
+				return readFileSync(path, "utf-8");
+			}
+			return null;
+		},
+		async transform(code, key) {
+			if (key.endsWith(SUFFIX)) {
+				code = server ? await server.transformIndexHtml(key, code) : code;
+				return { code: `export default \`${code}\`` };
+			}
+			return null;
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/plugins/css.ts
+function css() {
+	let devServer;
+	const styles = new Array();
+	return {
+		name: "css",
+		apply: "serve",
+		configureServer(server) {
+			devServer = server;
+		},
+		transform(_, source) {
+			if (source.match(/\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/)) {
+				if (!styles.includes(source) && !source.includes("?") && !source.includes(".node_modules") && !source.includes("@vite")) styles.push(relative(devServer.config.root, source));
+			}
+		},
+		transformIndexHtml() {
+			return [...styles.map((path) => ({
+				tag: "link",
+				injectTo: "head",
+				attrs: {
+					rel: "stylesheet",
+					href: "/" + path,
+					"data-preload": true
+				}
+			})), {
+				tag: "script",
+				injectTo: "head",
+				attrs: { type: "module" },
+				children: `
+                        const observer = new MutationObserver(() => {
+                            if (document.querySelector('style[data-vite-dev-id]')) {
+                                document.querySelectorAll('[data-preload]').forEach((node) => node.remove());
+
+                                observer.disconnect();
+                            }
+                        });
+
+                        observer.observe(document.head, { childList: true });
+                    `
+			}];
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/plugins/entry.ts
+function entry() {
+	let entryName;
+	let entryPath;
+	return {
+		name: "entry",
+		enforce: "pre",
+		sharedDuringBuild: true,
+		resolveId: {
+			filter: { id: /\.html$/ },
+			handler(source, importer, options) {
+				if (this.environment.name === CLIENT) {
+					if (importer && entryPath) {
+						const path = join(dirname(importer), source);
+						if (existsSync(path)) return path;
+					}
+					if (options.isEntry) {
+						entryName = basename(source);
+						entryPath = source;
+						return entryName;
+					}
+				}
+			}
+		},
+		load: {
+			filter: { id: /\.html$/ },
+			handler(source) {
+				if (entryName && entryPath && source === entryName) return readFileSync(entryPath, {
+					encoding: "utf-8",
+					flag: "r"
+				});
+				return null;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/plugins/virtuals.ts
+function virtuals(virtuals$1) {
+	const cache = /* @__PURE__ */ new Set();
+	return {
+		name: "virtuals",
+		enforce: "pre",
+		sharedDuringBuild: true,
+		resolveId(key, importer) {
+			if (cache.has(key)) return key;
+			if (key.startsWith("#")) {
+				const path = "/" + key.slice(1);
+				cache.add(path);
+				return path;
+			}
+			return null;
+		},
+		load(key) {
+			const virtual = virtuals$1["#" + key.slice(1)];
+			if (typeof virtual === "string") return readFileSync(virtual, {
+				encoding: "utf-8",
+				flag: "r"
+			});
+			var code = virtual?.(this.environment.name);
+			if (code) return code;
+			return null;
+		}
+	};
+}
+
+//#endregion
+//#region package.json
+var name = "revojs";
+var version = "0.1.20";
+
+//#endregion
+//#region src/vite/index.ts
+function revojs(config) {
+	const app = createApp(config);
+	return [
+		{
+			name,
+			version,
+			sharedDuringBuild: true,
+			async config() {
+				const { toPath, addVirtual } = useKit(app, process.cwd());
+				for (const module of app.config.modules) await module.setup?.(app);
+				if (app.config.client) addVirtual("client", () => `import client from "${app.config.client}?client"; export default client`);
+				if (app.config.server) addVirtual("server", () => `import { createServer } from "revojs"; export default await createServer()`);
+				for (const name$1 in app.config.sources) {
+					const source = app.config.sources[name$1];
+					if (source) addVirtual(name$1, () => {
+						const entries = {};
+						for (let path of source.entries) {
+							path = isAbsolute(path) ? path : toPath(path);
+							for (const asset of globSync(source.match, { cwd: path })) entries[asset] = join(path, asset).split(win32.sep).join(posix.sep);
+						}
+						const content = Object.values(entries).reduce((content$1, path, index) => content$1 + `import $${index} from "${source.resolve?.(path) ?? path}" \n`, "");
+						const result = Object.keys(entries).map((name$2, index) => {
+							if (entries[name$2]) return `"${name$2}": $${index}`;
+						});
+						return `${content} export default {${result}}`;
+					});
+				}
+				return {
+					appType: "custom",
+					optimizeDeps: { exclude: ["revojs"] },
+					resolve: { alias: app.alias },
+					build: {
+						emptyOutDir: false,
+						assetsInlineLimit: 4096 * 4,
+						rollupOptions: { external: app.config.build.externals }
+					},
+					builder: {
+						sharedConfigBuild: true,
+						async buildApp(builder) {
+							await rm("./dist", {
+								recursive: true,
+								force: true
+							});
+							for (const key in builder.environments) {
+								const environment = builder.environments[key];
+								if (environment) await builder.build(environment);
+							}
+						}
+					},
+					environments: {
+						...app.config.client && { [CLIENT]: {
+							consumer: "client",
+							resolve: { noExternal: true },
+							build: {
+								rollupOptions: { input: { index: app.config.client } },
+								outDir: "./dist/public",
+								copyPublicDir: true
+							},
+							define: {
+								"import.meta.server": false,
+								"import.meta.client": true
+							}
+						} },
+						...app.config.server && { [SERVER]: {
+							consumer: "server",
+							resolve: {
+								noExternal: true,
+								conditions: ["import"],
+								externalConditions: ["import"]
+							},
+							build: {
+								rollupOptions: { input: { index: app.config.server } },
+								outDir: "./dist",
+								copyPublicDir: false
+							},
+							define: {
+								"import.meta.server": true,
+								"import.meta.client": false
+							}
+						} }
+					}
+				};
+			},
+			configResolved(config$1) {
+				if (app.config.client === void 0) delete config$1.environments[CLIENT];
+				if (app.config.server === void 0) delete config$1.environments[SERVER];
+			},
+			async configureServer(devServer) {
+				const target = devServer.environments[SERVER];
+				if (isRunnableDevEnvironment(target)) return () => {
+					devServer.middlewares.use(async (request, response, next) => {
+						const server = await target.runner.import("#virtual/server").then((module) => module.default);
+						if (server) {
+							request.url = request.originalUrl;
+							const scope = new Scope();
+							try {
+								scope.setContext(SERVER_CONTEXT, {
+									states: {},
+									request: fromNodeRequest(request, response),
+									response: { headers: new Headers() },
+									variables: process.env
+								});
+								var result = await invoke(scope, app.config.development.middlewares.concat({ fetch: server.fetch }));
+								if (result) await toNodeRequest(result, response);
+							} finally {
+								scope.stop();
+							}
+						}
+						next();
+					});
+				};
+			}
+		},
+		virtuals(app.virtuals),
+		client(),
+		entry(),
+		css()
+	];
+}
+
+//#endregion
+export { revojs };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "revojs",
-    "version": "0.1.18",
+    "version": "0.1.20",
     "type": "module",
     "repository": "coverbase/revojs",
     "license": "MIT",
@@ -9,6 +9,14 @@
             "types": "./dist/index.d.ts",
             "import": "./dist/index.js"
         },
+        "./kit": {
+            "types": "./dist/kit/index.d.ts",
+            "import": "./dist/kit/index.js"
+        },
+        "./vite": {
+            "types": "./dist/vite/index.d.ts",
+            "import": "./dist/vite/index.js"
+        },
         "./types": {
             "types": "./src/types/index.d.ts"
         }
@@ -24,8 +32,13 @@
         "build": "tsdown",
         "watch": "tsdown -w"
     },
+    "dependencies": {
+        "tinyglobby": "^0.2.15",
+        "vite": "^7.1.10"
+    },
     "devDependencies": {
         "@revojs/tsconfig": "*",
+        "@types/node": "^24.7.2",
         "tsdown": "^0.15.1"
     }
 }

package/src/types/index.d.ts

@@ -12,12 +12,6 @@ declare module "#virtual/server" {
     export default server;
 }
 
-declare module "#virtual/assets" {
-    const assets: Record<string, string>;
-
-    export default assets;
-}
-
 declare module "#virtual/routes" {
     import type { Route } from "revojs";
 
@@ -26,14 +20,6 @@ declare module "#virtual/routes" {
     export default routes;
 }
 
-declare module "#virtual/exceptions" {
-    import type { Exception } from "revojs";
-
-    const exceptions: Record<string, Exception>;
-
-    export default exceptions;
-}
-
 interface ImportMeta {
     readonly server: boolean;
     readonly client: boolean;