revojs 0.0.87 → 0.1.0

package/dist/vite/index.d.ts

@@ -0,0 +1,53 @@
+import { Plugin } from "vite";
+
+//#region src/shared/index.d.ts
+
+type Mergeable<T> = { [P in keyof T]?: Mergeable<T[P]> };
+declare class StopEvent extends Event {
+  constructor();
+}
+declare global {
+  interface ElementEventMap {
+    stop: StopEvent;
+  }
+}
+//#endregion
+//#region src/app/index.d.ts
+type Environment = typeof CLIENT | typeof SERVER;
+type Virtual = (environment: Environment) => undefined | string | Promise<string>;
+interface Config {
+  modules: Array<Module>;
+  client?: string;
+  server?: string;
+  sources: Record<string, Source>;
+}
+interface Module {
+  config?: Mergeable<Config>;
+  setup?: (app: App) => void | Promise<void>;
+}
+interface Source {
+  match: string;
+  entries: Array<string>;
+  suffix?: string;
+}
+interface App {
+  config: Config;
+  virtuals: Record<string, Virtual>;
+  alias: Record<string, string>;
+}
+declare const SERVER = "ssr";
+declare const CLIENT = "client";
+//#endregion
+//#region src/vite/index.d.ts
+declare function useKit(app: App, source: string | URL): {
+  source: string;
+  toPath: (...paths: Array<string>) => string;
+  addVirtual: (name: string, virtual: Virtual) => void;
+  addAlias: (name: string, path: string) => void;
+};
+declare function addRoutes(app: App, path: string): void;
+declare function addAssets(app: App, path: string): void;
+declare function addMiddlewares(app: App, path: string): void;
+declare function revojs(config?: Mergeable<Config>): Array<Plugin>;
+//#endregion
+export { addAssets, addMiddlewares, addRoutes, revojs, useKit };

package/dist/vite/index.js

@@ -0,0 +1,460 @@
+import { basename, dirname, isAbsolute, join, posix, win32 } from "path";
+import { globSync } from "tinyglobby";
+import { fileURLToPath } from "url";
+import { isRunnableDevEnvironment } from "vite";
+import { once } from "node:events";
+import { Readable, Stream } from "node:stream";
+import { existsSync, readFileSync } from "fs";
+
+//#region package.json
+var name = "revojs";
+var version = "0.1.0";
+
+//#endregion
+//#region src/server/index.ts
+const ROUTER_CONTEXT = defineContext("ROUTER_CONTEXT");
+const SERVER_CONTEXT = defineContext("SERVER_CONTEXT");
+
+//#endregion
+//#region src/shared/index.ts
+var StopEvent = class extends Event {
+	constructor() {
+		super("stop");
+	}
+};
+var Scope = class extends EventTarget {
+	parentScope;
+	context;
+	constructor(parentScope) {
+		super();
+		this.parentScope = parentScope;
+		this.parentScope?.onStop(() => this.stop());
+		this.context = {};
+	}
+	getContext(input) {
+		let scope = this;
+		while (scope) {
+			if (scope.context[input]) return scope.context[input];
+			scope = scope.parentScope;
+		}
+		return {};
+	}
+	setContext(input, value) {
+		this.context[input] = value;
+	}
+	onStop(input) {
+		this.addEventListener("stop", input, { once: true });
+	}
+	stop() {
+		return this.dispatchEvent(new StopEvent());
+	}
+};
+function defineContext(name$1) {
+	return name$1;
+}
+function mergeObjects(base, input) {
+	if (input === null || input === void 0) return mergeObjects(base, {});
+	const object = structuredClone(input);
+	for (const key in base) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = base[key];
+		if (value === null || value === void 0) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (typeof value === "object" && typeof object[key] === "object") object[key] = mergeObjects(value, object[key]);
+		else object[key] = value;
+	}
+	return object;
+}
+
+//#endregion
+//#region src/app/index.ts
+function createApp(inputConfig) {
+	let config = mergeObjects(inputConfig, {
+		modules: [],
+		sources: {
+			assets: {
+				match: "**/*",
+				entries: ["./public"],
+				suffix: "?raw"
+			},
+			routes: {
+				match: "**/*.{js,ts}",
+				entries: ["./routes"]
+			},
+			middlewares: {
+				match: "**/*.{js,ts}",
+				entries: ["./middlewares"]
+			}
+		}
+	});
+	for (const module of config.modules) config = mergeObjects(config, module.config);
+	return {
+		config,
+		virtuals: {},
+		alias: {}
+	};
+}
+const SERVER = "ssr";
+const CLIENT = "client";
+
+//#endregion
+//#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;
+	return {
+		name: "client",
+		sharedDuringBuild: true,
+		configureServer(devServer) {
+			server = devServer;
+		},
+		load(key) {
+			if (key.endsWith(SUFFIX)) {
+				const path = key.substring(0, key.length - 7);
+				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/entry.ts
+function entry() {
+	let entryName;
+	let entryPath;
+	return {
+		name: "entry",
+		enforce: "pre",
+		sharedDuringBuild: true,
+		resolveId(source, importer, options) {
+			if (source === "vite/modulepreload-polyfill") return null;
+			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;
+				}
+			}
+			return null;
+		},
+		load(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 src/vite/index.ts
+function useKit(app, source) {
+	source = source.toString();
+	if (source.startsWith("file://")) source = dirname(fileURLToPath(source));
+	return {
+		source,
+		toPath: (...paths) => {
+			return join(source, ...paths).split(win32.sep).join(posix.sep);
+		},
+		addVirtual: (name$1, virtual) => {
+			app.virtuals["#virtual/" + name$1] = virtual;
+		},
+		addAlias: (name$1, path) => {
+			app.alias["#alias/" + name$1] = join(source, path).split(win32.sep).join(posix.sep);
+		}
+	};
+}
+function addRoutes(app, path) {
+	app.config.sources.routes?.entries.push(path);
+}
+function addAssets(app, path) {
+	app.config.sources.assets?.entries.push(path);
+}
+function addMiddlewares(app, path) {
+	app.config.sources.middlewares?.entries.push(path);
+}
+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);
+						}
+						return `export default {${Object.keys(entries).map((name$2) => `"${name$2}": await import("${entries[name$2] + (source.suffix ?? "")}").then(module => module.default)`)}}`;
+					});
+				}
+				return {
+					appType: "custom",
+					resolve: { alias: app.alias },
+					environments: {
+						...app.config.client && { [CLIENT]: {
+							consumer: "client",
+							resolve: { noExternal: true },
+							build: {
+								rollupOptions: { input: { index: app.config.client } },
+								outDir: "./dist/client",
+								copyPublicDir: true,
+								emptyOutDir: 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/server",
+								copyPublicDir: false,
+								emptyOutDir: true
+							},
+							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();
+							scope.setContext(SERVER_CONTEXT, {
+								request: fromNodeRequest(request, response),
+								response: { headers: new Headers() },
+								variables: process.env
+							});
+							await toNodeRequest(await server.fetch(scope), response).finally(() => scope.stop());
+						}
+						next();
+					});
+				};
+			}
+		},
+		virtuals(app.virtuals),
+		client(),
+		entry()
+	];
+}
+
+//#endregion
+export { addAssets, addMiddlewares, addRoutes, revojs, useKit };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "revojs",
-    "version": "0.0.87",
+    "version": "0.1.0",
     "type": "module",
     "repository": "coverbase/revojs",
     "license": "MIT",
@@ -9,9 +9,9 @@
             "types": "./dist/index.d.ts",
             "import": "./dist/index.js"
         },
-        "./jsx-runtime": {
-            "types": "./dist/jsx/index.d.ts",
-            "import": "./dist/jsx/index.js"
+        "./vite": {
+            "types": "./dist/vite/index.d.ts",
+            "import": "./dist/vite/index.js"
         },
         "./types": {
             "types": "./src/types/index.d.ts"
@@ -25,15 +25,16 @@
         "src/types"
     ],
     "scripts": {
-        "build": "rolldown -c rolldown.config.ts && tsc",
-        "watch": "rolldown -w -c rolldown.config.ts && tsc --watch"
+        "build": "tsdown",
+        "watch": "tsdown -w"
     },
-    "optionalDependencies": {
-        "@rolldown/binding-linux-x64-gnu": "*"
+    "dependencies": {
+        "tinyglobby": "^0.2.14",
+        "vite": "^7.1.3"
     },
     "devDependencies": {
-        "@revojs/rolldown": "*",
         "@revojs/tsconfig": "*",
-        "rolldown": "^1.0.0-beta.19"
+        "@types/node": "^24.3.0",
+        "tsdown": "^0.15.1"
     }
 }

package/src/types/index.d.ts

@@ -1,31 +1,35 @@
-declare module "#virtual/runtime" {
-    import type { Runtime } from "revojs";
+declare module "#virtual/client" {
+    const client: string;
 
-    export const runtime: Runtime;
+    export default client;
 }
 
-declare module "#virtual/client" {
-    import type { Slot } from "revojs";
+declare module "#virtual/server" {
+    import type { Server } from "revojs";
+
+    const server: Server;
+
+    export default server;
+}
+
+declare module "#virtual/assets" {
+    const assets: Record<string, string>;
 
-    export const client: Slot;
+    export default assets;
 }
 
 declare module "#virtual/routes" {
-    import type { Route, Slot } from "revojs";
+    import type { Route } from "revojs";
 
-    const routes: Record<string, Route | Slot>;
+    const routes: Record<string, Route>;
 
     export default routes;
 }
 
-declare module "#virtual/locales" {
-    const locales: Record<string, Record<string, string>>;
+declare module "#virtual/middlewares" {
+    import type { Middleware } from "revojs";
 
-    export default locales;
-}
+    const middlewares: Record<string, Middleware>;
 
-declare module "#virtual/assets" {
-    const assets: Record<string, string>;
-
-    export default assets;
+    export default middlewares;
 }

package/dist/app/index.d.ts

@@ -1,36 +0,0 @@
-import type { Middleware } from "../runtime";
-export type Mergeable<T> = {
-    [P in keyof T]?: Mergeable<T[P]>;
-};
-export type Environment = typeof CLIENT | typeof SERVER;
-export type Virtual = (environment: Environment) => void | string;
-export type ClientEntry = "index.html" | (string & {});
-export type ServerEntry = "@revojs/bun/runtime" | "@revojs/cloudflare/runtime" | (string & {});
-export type Module = {
-    setup: (app: App) => void | Promise<void>;
-};
-export type ClientConfig = {
-    entry: ClientEntry;
-    externals: Array<string>;
-};
-export type ServerConfig = {
-    entry: ServerEntry;
-    externals: Array<string>;
-};
-export type DevelopmentConfig = {
-    middleware: Array<Middleware>;
-};
-export type Config = {
-    modules: Array<Module>;
-    client: ClientConfig;
-    server: ServerConfig;
-    dev: DevelopmentConfig;
-};
-export type App = {
-    config: Config;
-    virtuals: Record<string, Virtual>;
-};
-export declare function mergeObjects<TBase, TInput>(base: TBase, input: TInput): TBase & TInput;
-export declare function createApp(config?: Mergeable<Config>): App;
-export declare const SERVER = "ssr";
-export declare const CLIENT = "client";