revojs 0.0.1

package/dist/app/index.d.ts

@@ -0,0 +1,32 @@
+import type { Template } from "../html";
+export type NestedPartial<T> = Partial<{
+    [K in keyof T]: T[K] extends object ? NestedPartial<T[K]> : T[K];
+}>;
+export type AssetConfig = {
+    path: string;
+    suffix?: string;
+    import?: string;
+};
+export type RouteConfig = {
+    path: string;
+};
+export type ServerEntry = "revojs/presets/node" | "revojs/presets/deno" | "revojs/presets/bun" | "revojs/presets/cloudflare" | (string & {});
+export type ClientConfig = {
+    entry: string;
+};
+export type ServerConfig = {
+    entry: ServerEntry;
+};
+export type Config = {
+    assets: Array<AssetConfig>;
+    routes: Array<RouteConfig>;
+    client: ClientConfig;
+    server: ServerConfig;
+    markdown: Record<string, Template>;
+};
+export type App = {
+    config: Config;
+    virtuals: Record<string, () => string>;
+};
+export declare const getAssets: <T>(regex: RegExp) => Promise<Record<string, () => Promise<T>>>;
+export declare const createApp: (config?: NestedPartial<Config>) => App;

package/dist/event/index.d.ts

@@ -0,0 +1,19 @@
+import type { StatusCode } from "../http";
+export type Context = {
+    inputs: Record<string, string>;
+};
+export type Set = {
+    status?: StatusCode;
+    message?: string;
+    headers: Headers;
+};
+export type Event<T = Context> = {
+    request: Request;
+    response: Set;
+    context: T;
+};
+export declare const createEvent: <T = Context>(request: Request, context: T) => Event<T>;
+export declare const sendText: <T = Context>(event: Event<T>, text?: string) => Response;
+export declare const sendHtml: <T = Context>(event: Event<T>, text: string) => Response;
+export declare const sendJson: <TValue, T = Context>(event: Event<T>, value: TValue) => Response;
+export declare const setHeader: <T>(event: Event<T>, name: string, value: string) => void;

package/dist/html/index.d.ts

@@ -0,0 +1,75 @@
+import { type State } from "../signals";
+export type TypeOf<T> = {
+    (): T;
+};
+export type Infer<T> = T extends TypeOf<infer U> ? U : unknown;
+export type Slot = void | string | number | boolean | undefined | object | Function | Template;
+export type Template = {
+    tag: string;
+    attributes: Record<string, Slot>;
+    children: Array<Slot>;
+};
+export type EventInput<T extends Events> = {
+    [K in keyof T]?: (event: Infer<T[K]["type"]>) => void;
+};
+export type AttributeInput<T extends Attributes> = {
+    [K in keyof T]?: Infer<T[K]["type"]>;
+};
+export type Input<TEvents extends Events, TAttributes extends Attributes> = EventInput<TEvents> & AttributeInput<TAttributes>;
+export type EventOutput<T extends Events> = {
+    [K in keyof T]?: (event: Infer<T[K]["type"]>) => void;
+};
+export type AttributeOutput<T extends Attributes> = {
+    [K in keyof T]: T[K]["default"] extends undefined ? Infer<T[K]["type"]> | undefined : Infer<T[K]["type"]>;
+};
+export type EventOptions<T> = {
+    type: T;
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+};
+export type AttributeOptions<T> = {
+    type: T;
+    default?: Infer<T>;
+};
+export type Events = Record<string, EventOptions<Slot>>;
+export type Attributes = Record<string, AttributeOptions<Slot>>;
+export interface ComponentOptions<TEvents extends Events, TAttributes extends Attributes> {
+    name: string;
+    events?: TEvents;
+    attributes?: TAttributes;
+    shadowRoot?: false | ShadowRootInit;
+    setup: (component: Component<TEvents, TAttributes>) => Slot | Promise<Slot>;
+}
+export interface Component<TEvents extends Events, TAttributes extends Attributes> {
+    readonly events: EventOutput<TEvents>;
+    readonly attributes: State<AttributeOutput<TAttributes>>;
+    readonly shadowRoot: false | ShadowRootInit;
+    setup: () => Slot | Promise<Slot>;
+}
+export interface ComponentConstructor<TEvents extends Events, TAttributes extends Attributes> {
+    $name: string;
+    $events: TEvents;
+    $attributes: TAttributes;
+    new (input?: Input<TEvents, TAttributes>): Component<TEvents, TAttributes>;
+}
+export interface CustomElement<TEvents extends Events, TAttributes extends Attributes> extends HTMLElement {
+    readonly component: Component<TEvents, TAttributes>;
+}
+export interface CustomElementConstructor<TEvents extends Events, TAttributes extends Attributes> {
+    new (): CustomElement<TEvents, TAttributes>;
+}
+export declare const createElement: <TEvents extends Events, TAttributes extends Attributes>(input: string | ComponentConstructor<TEvents, TAttributes>, attributes?: AttributeInput<TAttributes>, ...children: Array<Slot>) => Slot;
+export declare const toString: (slot: Slot) => string;
+export declare const slotToString: (slot: Slot) => Promise<string>;
+export declare const slotToNode: (slot: Slot) => Promise<Node>;
+export declare const defineComponent: <TEvents extends Events = {}, TAttributes extends Attributes = {}>(options: ComponentOptions<TEvents, TAttributes>) => ComponentConstructor<TEvents, TAttributes>;
+export declare const toCustomElement: <TEvents extends Events = {}, TAttributes extends Attributes = {}>(component: ComponentConstructor<TEvents, TAttributes>) => CustomElementConstructor<TEvents, TAttributes>;
+export declare const registerComponent: <TEvents extends Events = {}, TAttributes extends Attributes = {}>(component: ComponentConstructor<TEvents, TAttributes>) => ComponentConstructor<TEvents, TAttributes>;
+export declare const isClient: () => boolean;
+export declare const isServer: () => boolean;
+export declare const addStyles: (...styles: Array<CSSStyleSheet>) => void;
+export declare const getGlobalStyles: () => CSSStyleSheet[];
+export declare let globalStyles: Array<CSSStyleSheet>;
+export declare let activeElement: CustomElement<Events, Attributes> | undefined;
+export declare const components: Map<string, ComponentConstructor<Events, Attributes>>;

package/dist/http/index.d.ts

@@ -0,0 +1,5 @@
+export type HttpMethod = "GET" | "HEAD" | "PATCH" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "TRACE";
+export type Encoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex";
+export type StatusCode = 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 444 | 450 | 451 | 497 | 498 | 499 | 500 | 501 | 502 | 503 | 504 | 506 | 507 | 508 | 509 | 510 | 511 | 521 | 522 | 523 | 525 | 530 | 599;
+export type MimeType = "text/css" | "text/javascript" | "text/plain";
+export declare const getMimeType: (file: string) => MimeType;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./app";
+export * from "./event";
+export * from "./html";
+export * from "./http";
+export * from "./markdown";
+export * from "./radix";
+export * from "./router";
+export * from "./runtime";
+export * from "./signals";

package/dist/index.js

@@ -0,0 +1,502 @@
+import defu, { defu as defu$1 } from "defu";
+import { h } from "revojs/jsx-runtime";
+
+//#region src/app/index.ts
+const getAssets = async (regex) => {
+	const assets = await import("#virtual/assets").then((module) => module.assets);
+	return Object.entries(assets).reduce((assets$1, [name, value]) => {
+		if (regex.test(name)) assets$1[name] = value;
+		return assets$1;
+	}, {});
+};
+const createApp = (config) => {
+	return {
+		config: defu$1(config, {
+			assets: [{ path: "./assets" }],
+			routes: [{ path: "./routes" }],
+			client: { entry: "./index.html" },
+			server: { entry: "revojs/presets/node" },
+			markdown: {}
+		}),
+		virtuals: {}
+	};
+};
+
+//#endregion
+//#region src/event/index.ts
+const createEvent = (request, context) => {
+	return {
+		request,
+		response: { headers: new Headers() },
+		context
+	};
+};
+const sendText = (event, text) => {
+	return new Response(text, event.response);
+};
+const sendHtml = (event, text) => {
+	setHeader(event, "Content-Type", "text/html");
+	return new Response(text, event.response);
+};
+const sendJson = (event, value) => {
+	return new Response(JSON.stringify(value), event.response);
+};
+const setHeader = (event, name, value) => {
+	event.response.headers.set(name, value);
+};
+
+//#endregion
+//#region src/signals/index.ts
+var Handler = class Handler {
+	get = (target, path) => {
+		if (runningCompute) {
+			const effects = targets.get(target) ?? new Map();
+			const set = effects.get(path) ?? new Set();
+			effects.set(path, set.add(runningCompute));
+			targets.set(target, effects);
+			runningCompute.previous?.cleanUps.push((compute) => set.delete(compute));
+		}
+		const value = Reflect.get(target, path);
+		if (value instanceof Object) return new Proxy(value, new Handler());
+		return value;
+	};
+	set = (target, path, value) => {
+		const result = Reflect.set(target, path, value);
+		for (const effect of targets.get(target)?.get(path) ?? []) {
+			while (effect.cleanUps.length) effect.cleanUps.pop()?.(effect);
+			effect.invoke();
+		}
+		return result;
+	};
+};
+const createState = (value) => {
+	return new Proxy({ value }, new Handler());
+};
+const createCompute = (invoke) => {
+	return runCompute({
+		invoke,
+		cleanUps: []
+	});
+};
+const runCompute = (compute) => {
+	compute.previous = runningCompute;
+	runningCompute = compute;
+	try {
+		return compute.invoke();
+	} finally {
+		runningCompute = compute.previous;
+	}
+};
+const fromValue = (value) => {
+	if (value) {
+		if (value instanceof Function) return fromValue(value());
+		if (value instanceof Object) return value.value;
+	}
+	return value;
+};
+const onCleanUp = (cleanUp) => {
+	runningCompute?.cleanUps.push(cleanUp);
+};
+const targets = new WeakMap();
+let runningCompute;
+
+//#endregion
+//#region src/html/index.ts
+const createElement = (input, attributes, ...children) => {
+	return {
+		tag: typeof input === "function" ? input.$name : input,
+		attributes: attributes ?? {},
+		children
+	};
+};
+const toString = (slot) => {
+	switch (typeof slot) {
+		case "string":
+		case "number":
+		case "bigint":
+		case "boolean":
+		case "symbol": return slot.toString();
+		case "object": return JSON.stringify(slot);
+		case "function": return toString(slot());
+		default: return "";
+	}
+};
+const slotToString = async (slot) => {
+	if (Array.isArray(slot)) return await Promise.all(slot.map(slotToString)).then((chunks) => chunks.join(" "));
+	if (typeof slot === "number" || typeof slot === "bigint" || typeof slot === "boolean" || typeof slot === "string" || typeof slot === "symbol") return toString(slot);
+	if (typeof slot === "function") return await slotToString(await slot());
+	if (typeof slot === "object") {
+		if ("tag" in slot && "attributes" in slot && "children" in slot) {
+			const Constructor = components.get(slot.tag);
+			const prefix = [slot.tag, ...Object.entries(slot.attributes ?? {}).map(([name, value]) => {
+				if (!name.startsWith("on")) return `${name}="${toString(value)}"`;
+			})].filter(Boolean).join(" ");
+			const children = await slotToString(slot.children);
+			if (Constructor) {
+				const component = new Constructor(slot.attributes);
+				const template = await slotToString(await component.setup());
+				if (component.shadowRoot) return `<${prefix}> <template shadowRootMode="${component.shadowRoot.mode}"> ${template} </template> ${children} </${slot.tag}>`;
+				return `<${prefix}> ${template} ${children} </${slot.tag}>`;
+			}
+			return `<${prefix}> ${children} </${slot.tag}>`;
+		}
+		return toString(slot);
+	}
+	return "";
+};
+const slotToNode = async (slot) => {
+	if (Array.isArray(slot)) {
+		const fragment = document.createDocumentFragment();
+		fragment.replaceChildren(...await Promise.all(slot.map(slotToNode)));
+		return fragment;
+	}
+	if (typeof slot === "number" || typeof slot === "bigint" || typeof slot === "boolean" || typeof slot === "string" || typeof slot === "symbol") return document.createTextNode(slot.toString());
+	if (typeof slot === "function") {
+		let oldNode;
+		return await createCompute(async () => {
+			const node = await slotToNode(await slot());
+			oldNode?.parentNode?.replaceChild(node, oldNode);
+			oldNode = node;
+			return node;
+		});
+	}
+	if (typeof slot === "object") {
+		if ("tag" in slot && "attributes" in slot && "children" in slot) {
+			const node = document.createElement(slot.tag);
+			for (const key in slot.attributes) {
+				const value = slot.attributes[key];
+				if (value) if (key.startsWith("on")) {
+					const event = key.substring(2).toLowerCase();
+					node.addEventListener(event, value);
+					onCleanUp(() => node.removeEventListener(event, value));
+				} else node.setAttribute(key, toString(value));
+			}
+			node.replaceChildren(await slotToNode(slot.children));
+			return node;
+		}
+	}
+	return document.createComment("");
+};
+const defineComponent = (options) => {
+	return registerComponent(class {
+		static $name = options.name;
+		static $events = options.events ?? {};
+		static $attributes = options.attributes ?? {};
+		events;
+		attributes;
+		shadowRoot;
+		constructor(input) {
+			this.events = Object.keys(options.events ?? {}).reduce((output, name) => {
+				Reflect.set(output, name, input?.[name], output);
+				return output;
+			}, {});
+			this.attributes = Object.entries(options.attributes ?? {}).reduce((output, [name, attribute]) => {
+				Reflect.set(output.value, name, input?.[name] ?? attribute.default, output.value);
+				return output;
+			}, createState({}));
+			this.shadowRoot = options.shadowRoot ?? { mode: "open" };
+		}
+		setup = () => options.setup(this);
+	});
+};
+const toCustomElement = (component) => {
+	return class extends HTMLElement {
+		component;
+		constructor() {
+			super();
+			this.component = new component();
+		}
+		async connectedCallback() {
+			let previous = activeElement;
+			activeElement = this;
+			try {
+				const shadow = this.component.shadowRoot ? this.attachShadow(this.component.shadowRoot) : this;
+				for (const [name, event] of Object.entries(component.$events)) Reflect.set(this.component.events, name, (value) => {
+					this.dispatchEvent(new CustomEvent(name.substring(2).toLowerCase(), {
+						...event,
+						detail: value
+					}));
+				}, this.component.events);
+				shadow.replaceChildren(await slotToNode(await this.component.setup()));
+			} finally {
+				activeElement = previous;
+			}
+		}
+		attributeChangedCallback(name, _, value) {
+			const attribute = component.$attributes?.[name];
+			if (attribute) {
+				let convertedValue;
+				if (value) switch (attribute.type) {
+					case String:
+						convertedValue = value;
+						break;
+					case Number:
+						convertedValue = Number(value);
+						break;
+					case Boolean:
+						convertedValue = Boolean(value);
+						break;
+					case Object:
+						convertedValue = JSON.parse(value);
+						break;
+				}
+				Reflect.set(this.component.attributes.value, name, convertedValue ?? attribute.default, this.component.attributes.value);
+			}
+		}
+		static get observedAttributes() {
+			return Object.keys(component.$attributes ?? {});
+		}
+	};
+};
+const registerComponent = (component) => {
+	components.set(component.$name, component);
+	if (isClient()) customElements.define(component.$name, toCustomElement(component));
+	return component;
+};
+const isClient = () => {
+	return typeof window !== "undefined";
+};
+const isServer = () => {
+	return typeof window === "undefined";
+};
+const addStyles = (...styles) => {
+	activeElement?.shadowRoot?.adoptedStyleSheets.push(...styles);
+};
+const getGlobalStyles = () => {
+	return Array.from(isServer() ? [] : document.styleSheets).map((style) => {
+		const sheet = new CSSStyleSheet();
+		const css = Array.from(style.cssRules).map((rule) => rule.cssText).join(" ");
+		sheet.replaceSync(css);
+		return sheet;
+	});
+};
+let globalStyles;
+let activeElement;
+const components = new Map();
+
+//#endregion
+//#region src/http/index.ts
+const mimeTypes = {
+	css: "text/css",
+	js: "text/javascript",
+	txt: "text/plain"
+};
+const getMimeType = (file) => {
+	const extension = /\.([a-zA-Z0-9]+?)$/.exec(file)?.at(1);
+	return mimeTypes[extension ?? ""] ?? "text/plain";
+};
+
+//#endregion
+//#region src/markdown/index.ts
+const charWhile = (buffer, start, ...chars) => {
+	let depth = 0;
+	let current = buffer.at(start + depth);
+	while (current && chars.includes(current)) {
+		depth += 1;
+		current = buffer.at(start + depth);
+	}
+	return depth;
+};
+const charUntil = (buffer, start, ...chars) => {
+	let depth = 0;
+	let current = buffer.at(start + depth);
+	while (current && !chars.includes(current)) {
+		depth += 1;
+		current = buffer.at(start + depth);
+	}
+	return depth;
+};
+const inlineText = (buffer, options) => {
+	const nodes = new Array();
+	let index = 0;
+	while (index < buffer.length) {
+		const char = buffer.charAt(index);
+		const text = charUntil(buffer, index, "*", "_", "\n");
+		if (text > 0) {
+			nodes.push(buffer.slice(index, index + text));
+			index += text;
+			continue;
+		}
+		if (char === "*" || char === "_") {
+			const start = charWhile(buffer, index, char);
+			const between = charUntil(buffer, index + start, char);
+			const end = charWhile(buffer, index + start + between, char);
+			const min = Math.min(start, end, 2);
+			const leading = start - min;
+			const trailing = end - min;
+			const slice = buffer.slice(index + leading + min, index + start + between + end - trailing - min);
+			if (slice.length > 0) {
+				const inline = inlineText(char.repeat(leading) + slice + char.repeat(trailing), options);
+				const tag = min === 2 ? "strong" : "em";
+				nodes.push(defu(options?.[tag], {
+					tag,
+					attributes: {},
+					children: inline
+				}));
+			}
+			index += start + between + end;
+			continue;
+		}
+		if (char === "\n") {
+			nodes.push(defu(options?.["br"], {
+				tag: "br",
+				attributes: {},
+				children: []
+			}));
+			index += 1;
+			continue;
+		}
+	}
+	return nodes;
+};
+const markdownToSlot = (input, options) => {
+	const nodes = new Array();
+	const buffer = input.replace(/[\r]+/g, "").trim();
+	let index = 0;
+	while (index < buffer.length) {
+		const start = index;
+		let lines = charWhile(buffer, index, "\n");
+		while (lines < 2 && index < buffer.length) {
+			index += lines + charUntil(buffer, index + lines, "\n");
+			lines = charWhile(buffer, index, "\n");
+		}
+		const block = buffer.slice(start, index);
+		if (block.startsWith("#")) {
+			const depth = charWhile(block, 0, "#");
+			const tag = "h" + depth;
+			nodes.push(defu(options?.[tag], {
+				tag,
+				attributes: {},
+				children: inlineText(block.slice(depth))
+			}));
+		} else nodes.push(defu(options?.["p"], {
+			tag: "p",
+			attributes: {},
+			children: inlineText(block)
+		}));
+		index += lines;
+	}
+	return nodes;
+};
+
+//#endregion
+//#region src/radix/index.ts
+var Radix = class Radix {
+	value;
+	input;
+	children;
+	constructor(input) {
+		this.input = input;
+		this.children = new Map();
+	}
+	insert = (path, value) => {
+		let node = this;
+		for (let segment of path.split("/")) {
+			let input;
+			if (segment.startsWith(":")) {
+				input = segment.substring(1);
+				segment = ":";
+			}
+			let childNode = node.children.get(segment);
+			if (childNode === undefined) {
+				childNode = new Radix(input);
+				node.children.set(segment, childNode);
+			}
+			node = childNode;
+		}
+		node.value = value;
+		return this;
+	};
+	match = (path) => {
+		let node = this;
+		const match = { inputs: {} };
+		for (const segment of path.split("/")) {
+			node = node?.children.get(segment) ?? node?.children.get(":");
+			if (node?.input) match.inputs[node.input] = segment;
+		}
+		match.value = node?.value;
+		return match;
+	};
+};
+
+//#endregion
+//#region src/runtime/index.ts
+const defineRoute = (route) => {
+	return route;
+};
+const defineSocket = (socket) => {
+	return socket;
+};
+const toPath = (value) => {
+	return value.replace(/\/index/, "").replace(/\.(js|ts|jsx|tsx)$/, "").replaceAll(/\[(.*)\]/g, (_, name) => ":" + name).padStart(1, "/");
+};
+const createRuntime = async () => {
+	const radix = new Radix();
+	const assets = await import("#virtual/assets").then((module) => module.assets);
+	for (const path in assets) radix.insert("GET" + path, defineRoute({ fetch: async (event) => {
+		setHeader(event, "Content-Type", getMimeType(path));
+		return sendText(event, await assets[path]());
+	} }));
+	const routes = await import("#virtual/routes").then((module) => module.routes);
+	for (const path in routes) radix.insert("GET" + toPath(path), defineRoute({ fetch: async (event) => {
+		const route = await routes[path]();
+		if (route) {
+			if ("message" in route) return sendText(event, "WebSocket");
+			if ("$name" in route) {
+				const slot = await import("#virtual/client").then((module) => module.index);
+				return sendHtml(event, await slotToString(slot));
+			}
+			return route.fetch(event);
+		}
+	} }));
+	return { fetch: async (request, context) => {
+		const url = new URL(request.url);
+		const { value: route, inputs } = radix.match(request.method + url.pathname);
+		activeEvent = createEvent(request, {
+			...context,
+			inputs
+		});
+		try {
+			return await route?.fetch(activeEvent) ?? sendText(activeEvent, "Not found");
+		} finally {
+			activeEvent = undefined;
+		}
+	} };
+};
+let activeEvent;
+
+//#endregion
+//#region src/router/index.tsx
+const Outlet = defineComponent({
+	name: "x-outlet",
+	setup: async () => {
+		const radix = new Radix();
+		const routes = await import("#virtual/routes").then((module) => module.routes);
+		for (const path in routes) radix.insert("GET" + toPath(path), routes[path]);
+		const url = createState(new URL(activeEvent ? activeEvent.request.url : window.location.href));
+		if (isClient()) {
+			const controller = new AbortController();
+			window.addEventListener("popstate", () => url.value = new URL(window.location.href), { signal: controller.signal });
+			onCleanUp(() => controller.abort());
+		}
+		return async () => {
+			const { value, inputs } = radix.match("GET" + url.value.pathname);
+			const Page = await value?.();
+			if (Page) return h(Page, inputs);
+		};
+	}
+});
+const navigate = (url) => {
+	if (isClient()) {
+		const state = window.history.state;
+		window.history.pushState(state, "", url);
+		window.dispatchEvent(new PopStateEvent("popstate", { state }));
+	}
+};
+const anchorNavigate = (event) => {
+	event.preventDefault();
+	navigate(event.currentTarget?.getAttribute("href") ?? "/");
+};
+
+//#endregion
+export { Handler, Outlet, Radix, activeElement, activeEvent, addStyles, anchorNavigate, components, createApp, createCompute, createElement, createEvent, createRuntime, createState, defineComponent, defineRoute, defineSocket, fromValue, getAssets, getGlobalStyles, getMimeType, globalStyles, isClient, isServer, markdownToSlot, navigate, onCleanUp, registerComponent, runCompute, runningCompute, sendHtml, sendJson, sendText, setHeader, slotToNode, slotToString, targets, toCustomElement, toPath, toString };

package/dist/jsx/index.d.ts

@@ -0,0 +1,8 @@
+import { type Slot } from "../html";
+export declare namespace JSX {
+    type Element = Slot;
+    interface IntrinsicElements {
+        [key: string]: any;
+    }
+}
+export declare const h: <TEvents extends import("..").Events, TAttributes extends import("..").Attributes>(input: string | import("..").ComponentConstructor<TEvents, TAttributes>, attributes?: import("..").AttributeInput<TAttributes>, ...children: Array<Slot>) => Slot;

package/dist/jsx/index.js

@@ -0,0 +1,16 @@
+
+//#region src/html/index.ts
+const createElement = (input, attributes, ...children) => {
+	return {
+		tag: typeof input === "function" ? input.$name : input,
+		attributes: attributes ?? {},
+		children
+	};
+};
+
+//#endregion
+//#region src/jsx/index.ts
+const h = createElement;
+
+//#endregion
+export { h };

package/dist/markdown/index.d.ts

@@ -0,0 +1,2 @@
+import type { Slot, Template } from "../html";
+export declare const markdownToSlot: (input: string, options?: Record<string, Template>) => Slot[];

package/dist/presets/bun.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/presets/bun.js

@@ -0,0 +1,7 @@
+import { runtime } from "#virtual/runtime";
+import { serve } from "bun";
+
+//#region src/presets/bun.ts
+serve({ fetch: (request) => runtime.fetch(request, { inputs: {} }) });
+
+//#endregion

package/dist/presets/cloudflare.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    fetch: (request: Request, context: import("..").Context) => Promise<Response>;
+};
+export default _default;

package/dist/presets/cloudflare.js

@@ -0,0 +1,7 @@
+import { runtime } from "#virtual/runtime";
+
+//#region src/presets/cloudflare.ts
+var cloudflare_default = { fetch: runtime.fetch };
+
+//#endregion
+export { cloudflare_default as default };

package/dist/presets/deno.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/presets/deno.js

@@ -0,0 +1,5 @@
+
+//#region src/presets/deno.ts
+console.log("Hello from Deno");
+
+//#endregion

package/dist/presets/node.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/presets/node.js

@@ -0,0 +1,5 @@
+
+//#region src/presets/node.ts
+console.log("Hello from Node");
+
+//#endregion

package/dist/radix/index.d.ts

@@ -0,0 +1,12 @@
+export type Match<T> = {
+    value?: T;
+    inputs: Record<string, string>;
+};
+export declare class Radix<T> {
+    value?: T;
+    input?: string;
+    children: Map<string, Radix<T>>;
+    constructor(input?: string);
+    insert: (path: string, value: T) => this;
+    match: (path: string) => Match<T>;
+}

package/dist/router/index.d.ts

@@ -0,0 +1,4 @@
+import { type ComponentConstructor } from "../html";
+export declare const Outlet: ComponentConstructor<{}, {}>;
+export declare const navigate: (url: string) => void;
+export declare const anchorNavigate: (event: MouseEvent) => void;

package/dist/runtime/index.d.ts

@@ -0,0 +1,17 @@
+import type { Context, Event } from "../event";
+export type Route<T = Context> = {
+    fetch: (event: Event<T>) => void | Response | Promise<void | Response>;
+};
+export type Socket<T = Context> = {
+    open: (event: Event<T>) => void | Promise<void>;
+    message: (event: Event<T>) => void | Promise<void>;
+    close: (event: Event<T>) => void | Promise<void>;
+};
+export type Runtime<T = Context> = {
+    fetch: (request: Request, context: T) => Promise<Response>;
+};
+export declare const defineRoute: <T = Context>(route: Route<T>) => Route<T>;
+export declare const defineSocket: <T = Context>(socket: Socket<T>) => Socket<T>;
+export declare const toPath: (value: string) => string;
+export declare const createRuntime: <T = Context>() => Promise<Runtime<T>>;
+export declare let activeEvent: Event | undefined;

package/dist/signals/index.d.ts

@@ -0,0 +1,20 @@
+export type Value<T> = T | State<T> | (() => Value<T>);
+export interface State<T = unknown> {
+    value: T;
+}
+export interface Compute<T = unknown> {
+    invoke: () => T;
+    cleanUps: Array<(compute: Compute) => void>;
+    previous?: Compute;
+}
+export declare class Handler<T extends object> implements ProxyHandler<T> {
+    get: <TValue>(target: T, path: string | symbol) => TValue;
+    set: <TValue>(target: T, path: string | symbol, value: TValue) => boolean;
+}
+export declare const createState: <T>(value: T) => State<T>;
+export declare const createCompute: <T>(invoke: () => T) => T;
+export declare const runCompute: <T>(compute: Compute<T>) => T;
+export declare const fromValue: <T>(value: Value<T>) => T;
+export declare const onCleanUp: <T>(cleanUp: (compute: Compute) => T) => void;
+export declare const targets: WeakMap<object, Map<string | symbol, Set<Compute<unknown>>>>;
+export declare let runningCompute: Compute | undefined;

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "revojs",
+    "version": "0.0.1",
+    "type": "module",
+    "repository": "coverbase/revojs",
+    "license": "MIT",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./presets/*": {
+            "types": "./dist/presets/*.d.ts",
+            "import": "./dist/presets/*.js"
+        },
+        "./jsx-runtime": {
+            "types": "./dist/jsx/index.d.ts",
+            "import": "./dist/jsx/index.js"
+        }
+    },
+    "types": "./dist/index.d.ts",
+    "module": "./dist/index.js",
+    "main": "./dist/index.js",
+    "files": ["dist"],
+    "scripts": {
+        "build": "rolldown -c rolldown.config.ts && tsc",
+        "watch": "rolldown -w -c rolldown.config.ts && tsc --watch"
+    },
+    "dependencies": {
+        "defu": "^6.1.4"
+    },
+    "devDependencies": {
+        "@revojs/tsconfig": "0.0.0",
+        "@revojs/rolldown": "0.0.0",
+        "rolldown": "^1.0.0-beta.1"
+    }
+}