ajo-kit 0.1.0

package/dist/chunks/ssr-CCxCGcm6.js

@@ -0,0 +1,421 @@
+import { f as navigate, n as Failure, s as ancestors } from "./constants-5Eu0naK3.js";
+import { jsx } from "ajo/jsx-runtime";
+import navaid from "navaid";
+import { routes } from "virtual:ajo/routes";
+import * as devalue from "devalue";
+//#region packages/ajo-kit/src/head.tsx
+var key = {
+	meta: (entry) => "name" in entry ? entry.name : "property" in entry ? entry.property : entry.httpEquiv,
+	link: (entry) => entry.rel
+};
+var append = (items, index, entry, id) => {
+	const position = index.get(id);
+	if (position === void 0) {
+		index.set(id, items.length);
+		items.push(entry);
+		return;
+	}
+	items[position] = entry;
+};
+/** Merges route heads, letting later meta/link entries win by key. */
+function merge(...heads) {
+	const result = {};
+	const meta = [];
+	const link = [];
+	const index = {
+		meta: /* @__PURE__ */ new Map(),
+		link: /* @__PURE__ */ new Map()
+	};
+	for (const head of heads) {
+		if (!head) continue;
+		if (head.title) result.title = head.title;
+		for (const entry of head.meta ?? []) append(meta, index.meta, entry, key.meta(entry));
+		for (const entry of head.link ?? []) append(link, index.link, entry, key.link(entry));
+	}
+	if (meta.length) result.meta = meta;
+	if (link.length) result.link = link;
+	return result;
+}
+var text = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var attribute = (value) => text(value).replace(/"/g, "&quot;");
+var attrs = (entries) => Object.entries(entries).filter((entry) => entry[1] !== void 0).map(([name, value]) => `${name}="${attribute(value)}"`).join(" ");
+var tag = (name, entries) => `<${name} ${attrs(entries)}>`;
+/** Renders a Head object into SSR-safe HTML tags. */
+function render(head = {}) {
+	const tags = [];
+	if (head.title) tags.push(`<title>${text(head.title)}</title>`);
+	for (const entry of head.meta ?? []) tags.push(tag("meta", entry));
+	for (const entry of head.link ?? []) tags.push(tag("link", entry));
+	return tags.join("\n  ");
+}
+/** Applies a Head object to document.head during client navigation. */
+function apply(head = {}) {
+	if (head.title && document.title !== head.title) document.title = head.title;
+	const upsert = (selector, attrs) => {
+		let node = document.head.querySelector(selector);
+		if (!node) {
+			node = document.createElement(selector.startsWith("link") ? "link" : "meta");
+			for (const [attr, value] of Object.entries(attrs)) node.setAttribute(attr, value);
+			document.head.appendChild(node);
+			return;
+		}
+		for (const [attr, value] of Object.entries(attrs)) if (node.getAttribute(attr) !== value) node.setAttribute(attr, value);
+	};
+	for (const entry of head.meta ?? []) {
+		const id = key.meta(entry);
+		upsert("name" in entry ? `meta[name="${id}"]` : "property" in entry ? `meta[property="${id}"]` : `meta[http-equiv="${id}"]`, entry);
+	}
+	for (const entry of head.link ?? []) upsert(`link[rel="${entry.rel}"]`, entry);
+}
+var cache = /* @__PURE__ */ new Map();
+var meta = /* @__PURE__ */ new Map();
+var now = () => Date.now();
+var remove = (url) => {
+	cache.delete(url);
+	meta.delete(url);
+};
+var clear = () => {
+	cache.clear();
+	meta.clear();
+};
+var get = (url, time = now()) => {
+	const state = cache.get(url);
+	const info = meta.get(url);
+	if (!state || !info) return;
+	if (time - info.cached > 3e5) {
+		remove(url);
+		return;
+	}
+	info.used = time;
+	return state;
+};
+var prune = (active, time = now()) => {
+	for (const [url, info] of meta) if (url !== active && time - info.cached > 3e5) remove(url);
+	while (cache.size > 50) {
+		let candidate;
+		let oldest = Infinity;
+		for (const [url, info] of meta) {
+			if (url === active) continue;
+			if (info.used < oldest) {
+				oldest = info.used;
+				candidate = url;
+			}
+		}
+		if (!candidate) break;
+		remove(candidate);
+	}
+};
+var set = (url, state, options) => {
+	const time = options?.now ?? now();
+	cache.set(url, state);
+	meta.set(url, {
+		cached: time,
+		used: time
+	});
+	prune(options?.active ?? url, time);
+};
+var invalidate = (topics) => {
+	if (!topics?.length) {
+		clear();
+		return;
+	}
+	const changed = new Set(topics);
+	for (const [url, state] of cache) if (!state.topics?.length || state.topics.some((topic) => changed.has(topic))) remove(url);
+};
+//#endregion
+//#region packages/ajo-kit/src/app.tsx
+var group = /^\(.*\)$/;
+var dynamic = /^\[(.+?)\]$/;
+var match = (segments) => segments.filter((segment) => segment && !group.test(segment)).map((segment) => segment.replace(dynamic, (_, name) => name === "..." ? "*" : `:${name}`)).join("/");
+var parts = (path) => path.slice(4).split("/").slice(0, -1);
+var initial;
+function init(state) {
+	initial = state ?? void 0;
+}
+var error = () => ({
+	segments: [""],
+	loader: async () => ({ default: () => null })
+});
+var layouts = /* @__PURE__ */ new Map();
+var pages = [];
+var parents = (segments) => ancestors(segments).filter((path) => layouts.has(path));
+for (const [path, loader] of Object.entries(routes)) {
+	const segments = parts(path);
+	const kind = path.split("/").pop()?.split(".")[0];
+	if (kind === "layout") layouts.set(segments.join("/"), loader);
+	if (kind === "page") pages.push({
+		pattern: match(segments),
+		segments,
+		loader
+	});
+}
+function compose(page, tree, paths, state) {
+	const Page = page.default;
+	const boundary = page.pending ? "page" : tree.findLast((entry) => entry.module.pending)?.path;
+	return tree.reduceRight((Child, { path, module }, depth) => {
+		const Layout = module.default;
+		return () => /* @__PURE__ */ jsx(Layout, {
+			params: state.params,
+			data: state.data[depth],
+			loading: state.loading && boundary === path,
+			error: state.error,
+			children: /* @__PURE__ */ jsx(Child, {})
+		}, path);
+	}, () => /* @__PURE__ */ jsx(Page, {
+		params: state.params,
+		data: state.data.at(-1),
+		loading: state.loading && boundary === "page",
+		error: state.error
+	}, paths.join("/")));
+}
+async function load(url) {
+	const cached = get(url);
+	const versions = cached?.versions ? JSON.stringify(cached.versions) : void 0;
+	const response = await fetch(url, {
+		credentials: "include",
+		cache: "no-store",
+		headers: {
+			Accept: "application/json",
+			...cached?.hash && { "X-Have": cached.hash },
+			...versions && { "X-Ajo-Versions": versions }
+		}
+	});
+	if (response.status === 304 && cached) return {
+		data: cached.data,
+		head: cached.head,
+		hash: cached.hash,
+		topics: cached.topics,
+		versions: cached.versions
+	};
+	const json = await response.json().catch(() => null);
+	if (!json || !response.ok) return {
+		data: [],
+		error: new Failure(json?.error?.status ?? response.status, json?.error?.message ?? "Load failed")
+	};
+	if (json.redirect) return {
+		data: [],
+		redirect: json.redirect
+	};
+	return {
+		data: json.data ?? [],
+		head: json.head,
+		hash: json.hash,
+		topics: json.topics,
+		versions: json.versions
+	};
+}
+async function* resolve(url, layouts, page, data, error) {
+	const { loader, segments, params = {} } = page;
+	const paths = parents(segments);
+	const [target, ...tree] = await Promise.all([loader(), ...paths.map((path) => layouts.get(path)().then((module) => ({
+		path,
+		module
+	})))]);
+	if (error) {
+		const state = {
+			url,
+			params,
+			data: [],
+			loading: false,
+			error
+		};
+		yield {
+			page: compose(target, tree, paths, state),
+			state
+		};
+		return;
+	}
+	const cached = initial?.url === url ? initial : void 0;
+	if (cached) {
+		initial = void 0;
+		if (cached.hash) set(url, cached);
+		yield {
+			page: compose(target, tree, paths, cached),
+			state: cached
+		};
+		return;
+	}
+	yield { page: compose(target, tree, paths, {
+		url,
+		params,
+		data: [],
+		loading: true
+	}) };
+	const server = data ? { data } : await load(url);
+	if (server.redirect) {
+		navigate(server.redirect);
+		return;
+	}
+	if (server.error) {
+		const state = {
+			url,
+			params,
+			data: [],
+			loading: false,
+			error: server.error
+		};
+		yield {
+			page: compose(target, tree, paths, state),
+			state
+		};
+		return;
+	}
+	const state = {
+		url,
+		params,
+		data: server.data,
+		loading: false,
+		head: server.head,
+		hash: server.hash,
+		topics: server.topics,
+		versions: server.versions
+	};
+	if (state.hash) set(url, state);
+	yield {
+		page: compose(target, tree, paths, state),
+		state
+	};
+}
+function stream(update, notify) {
+	let source = null;
+	const status = (value) => notify?.(value);
+	const connect = (path) => {
+		source?.close();
+		if (globalThis.__AJO_DISABLE_SSE__) {
+			status("closed");
+			return;
+		}
+		status("connecting");
+		source = new EventSource(path);
+		source.onopen = () => status("open");
+		source.onmessage = (event) => {
+			const message = JSON.parse(event.data);
+			if (message.data) update(message);
+		};
+		source.onerror = () => status("connecting");
+	};
+	const close = () => {
+		source?.close();
+		source = null;
+		status("closed");
+	};
+	return {
+		connect,
+		close
+	};
+}
+var App = function* ({ page }) {
+	let Page = page ?? (() => null);
+	if (page) return /* @__PURE__ */ jsx(Page, {});
+	let hmr = false;
+	let active = null;
+	let timer = null;
+	let generation = 0;
+	let live = 0;
+	let phase = "closed";
+	const sse = stream((message) => {
+		if (!active || !message.data) return;
+		live++;
+		const [head, ...entries] = message.data;
+		active.data = entries;
+		active.hash = message.hash ?? active.hash;
+		active.topics = message.topics ?? active.topics;
+		active.versions = message.versions ?? active.versions;
+		if (head) apply(active.head = head);
+		if (active.hash) set(active.url, active);
+		this.next();
+	}, (status) => phase = status);
+	const go = async (target, options = {}) => {
+		const gen = ++generation;
+		const url = location.pathname + location.search;
+		const scroll = options.scroll ?? true;
+		sse.close();
+		try {
+			for await (const { page, state } of resolve(url, layouts, target)) {
+				if (gen !== generation) return;
+				if (hmr && !state) continue;
+				this.next(() => Page = page);
+				if (state?.head) apply(state.head);
+				if (state && !state.loading) active = state;
+			}
+		} catch (err) {
+			if (gen !== generation) return;
+			err = err instanceof Failure ? err : new Failure(500, err instanceof Error ? err.message : "Navigation failed");
+			for await (const { page } of resolve(url, layouts, error(), void 0, err)) {
+				if (gen !== generation) return;
+				this.next(() => Page = page);
+			}
+			return;
+		}
+		if (gen !== generation) return;
+		if (!hmr) {
+			sse.connect(url);
+			if (scroll) requestAnimationFrame(() => scrollTo({
+				top: 0,
+				behavior: "smooth"
+			}));
+		}
+		hmr = false;
+	};
+	const refresh = async () => {
+		if (!active) return;
+		const gen = generation;
+		const state = active;
+		const server = await load(state.url);
+		if (gen !== generation || active !== state) return;
+		if (server.redirect) {
+			navigate(server.redirect);
+			return;
+		}
+		if (server.error) {
+			state.data = [];
+			state.error = server.error;
+			state.loading = false;
+		} else {
+			state.data = server.data;
+			state.error = void 0;
+			state.head = server.head;
+			state.hash = server.hash;
+			state.topics = server.topics;
+			state.versions = server.versions;
+			if (server.head) apply(server.head);
+			if (state.hash) set(state.url, state);
+		}
+		this.next();
+	};
+	const reconcile = (topics) => {
+		if (!topics?.length || !active?.topics?.length) return;
+		const changed = new Set(topics);
+		if (!active.topics.some((topic) => changed.has(topic))) return;
+		const seen = live;
+		const delay = phase === "open" ? 250 : 0;
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = null;
+			if (live !== seen) return;
+			refresh();
+		}, delay);
+	};
+	const router = navaid("/", () => go(error()));
+	for (const config of pages) router.on(config.pattern, (params) => go({
+		...config,
+		params
+	}));
+	router.listen();
+	addEventListener("ajo:navigate", () => router.run(), { signal: this.signal });
+	addEventListener("ajo:action", (event) => reconcile(event.detail?.topics), { signal: this.signal });
+	this.signal.addEventListener("abort", () => {
+		if (timer) clearTimeout(timer);
+		sse.close();
+		router.unlisten?.();
+	});
+	while (true) yield /* @__PURE__ */ jsx(Page, {});
+};
+App.attrs = { class: "h-full" };
+//#endregion
+//#region packages/ajo-kit/src/ssr.ts
+var serialize = (value) => devalue.stringify(value);
+var parse = (value) => devalue.parse(value);
+var script = (value) => `<script type="application/json" id="__SSR__">${serialize(value)}<\/script>`;
+//#endregion
+export { init as a, pages as c, resolve as d, invalidate as f, error as i, parents as l, render as m, script as n, layouts as o, merge as p, App as r, match as s, parse as t, parts as u };

package/dist/client.js

@@ -0,0 +1,134 @@
+import { f as navigate } from "./chunks/constants-5Eu0naK3.js";
+import { a as init, f as invalidate, r as App, t as parse } from "./chunks/ssr-CCxCGcm6.js";
+import { jsx } from "ajo/jsx-runtime";
+import { render } from "ajo";
+import { current } from "ajo/context";
+//#region packages/ajo-kit/src/form.ts
+function fields(form) {
+	const seen = /* @__PURE__ */ new Set();
+	const arrays = /* @__PURE__ */ new Set();
+	for (const element of Array.from(form.elements)) {
+		const control = element;
+		const name = control.name;
+		if (!name) continue;
+		if (seen.has(name) || control instanceof HTMLSelectElement && control.multiple) arrays.add(name);
+		else seen.add(name);
+	}
+	return arrays;
+}
+function body(data, arrays = /* @__PURE__ */ new Set()) {
+	const body = {};
+	for (const [name, value] of data) {
+		if (typeof value !== "string") continue;
+		const current = body[name];
+		if (current === void 0) body[name] = arrays.has(name) ? [value] : value;
+		else if (Array.isArray(current)) current.push(value);
+		else body[name] = [current, value];
+	}
+	return body;
+}
+//#endregion
+//#region packages/ajo-kit/src/client.tsx
+/** Creates state and submit/invoke helpers for a route action. */
+function action(name, init) {
+	const component = current();
+	if (!component) throw new Error("action() must be called inside a stateful component.");
+	let controller;
+	const state = {
+		loading: false,
+		data: void 0,
+		error: void 0,
+		submit: () => {},
+		invoke: (value) => run(value),
+		reset: () => {
+			const current = controller;
+			controller = void 0;
+			current?.abort();
+			state.loading = false;
+			state.data = void 0;
+			state.error = void 0;
+			component.next();
+		}
+	};
+	const run = async (value) => {
+		controller?.abort();
+		const current = controller = new AbortController();
+		const forwardAbort = (signal) => {
+			if (!signal) return;
+			if (signal.aborted) current.abort(signal.reason);
+			else signal.addEventListener("abort", () => current.abort(signal.reason), {
+				once: true,
+				signal: current.signal
+			});
+		};
+		forwardAbort(component.signal);
+		forwardAbort(init?.signal);
+		state.loading = true;
+		state.error = void 0;
+		component.next();
+		try {
+			const response = await fetch(name ? `?/${name}` : "", {
+				method: "POST",
+				credentials: "include",
+				headers: {
+					"Content-Type": "application/json",
+					"Accept": "application/json"
+				},
+				body: JSON.stringify(value),
+				...init,
+				signal: current.signal
+			});
+			const json = await response.json().catch(() => null);
+			if (controller !== current || current.signal.aborted) return;
+			if (!response.ok) {
+				state.error = {
+					status: json?.error?.status ?? response.status,
+					message: json?.error?.message ?? json?.message ?? "Action failed",
+					fields: json?.error?.fields ?? json?.fields
+				};
+				return;
+			}
+			invalidate(json?.topics);
+			if (json?.redirect) {
+				navigate(json.redirect);
+				return;
+			}
+			state.data = json ?? {};
+			globalThis.dispatchEvent?.(new CustomEvent("ajo:action", { detail: json ?? {} }));
+			return state.data;
+		} catch (error) {
+			if (current.signal.aborted || error instanceof Error && error.name === "AbortError") return;
+			if (controller !== current) return;
+			state.error = {
+				status: 500,
+				message: error instanceof Error ? error.message : "Action failed"
+			};
+			return;
+		} finally {
+			if (controller === current) {
+				controller = void 0;
+				state.loading = false;
+				component.next();
+			}
+		}
+	};
+	state.submit = (event) => {
+		event.preventDefault();
+		const form = event.target;
+		run(body(new FormData(form), fields(form))).then(() => {
+			if (!state.error) form.reset();
+		});
+	};
+	return state;
+}
+{
+	const script = globalThis.document?.getElementById("__SSR__");
+	init(script?.textContent ? parse(script.textContent) : null);
+}
+var root = globalThis?.document?.getElementById("root");
+if (root) {
+	render(/* @__PURE__ */ jsx(App, {}), root);
+	document.documentElement.dataset.ajoReady = "true";
+}
+//#endregion
+export { action };

package/dist/database.js

@@ -0,0 +1,38 @@
+import { createRequire } from "node:module";
+import { Kysely, SqliteDialect, sql } from "kysely";
+/** better-sqlite3 constructor resolved from ajo-kit's own installation. */
+var Database = createRequire(import.meta.resolve("ajo-kit"))("better-sqlite3");
+var sqlite = null;
+var instance = null;
+/** Opens the SQLite database and configures safe defaults. */
+function connect(path = "./database.sqlite") {
+	sqlite = new Database(path);
+	sqlite.pragma("journal_mode = WAL");
+	sqlite.pragma("foreign_keys = ON");
+	sqlite.pragma("busy_timeout = 5000");
+	sqlite.pragma("synchronous = NORMAL");
+	return sqlite;
+}
+/** Returns the shared Kysely instance, opening SQLite on first use. */
+function db() {
+	if (!sqlite) connect();
+	return instance ??= new Kysely({ dialect: new SqliteDialect({ database: sqlite }) });
+}
+/** Returns the shared raw better-sqlite3 handle. */
+function raw() {
+	if (!sqlite) connect();
+	return sqlite;
+}
+/** Destroys the shared Kysely instance and closes SQLite. */
+async function close() {
+	if (instance) {
+		await instance.destroy();
+		instance = null;
+	}
+	if (sqlite) {
+		sqlite.close();
+		sqlite = null;
+	}
+}
+//#endregion
+export { Database, close, connect, db, raw, sql };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { a as Missing, c as api, f as navigate, i as Invalid, l as date, m as origin, n as Failure, o as ajax, p as normalize, r as Forbidden, t as Denied, u as ip } from "./chunks/constants-5Eu0naK3.js";
+export { Denied, Failure, Forbidden, Invalid, Missing, ajax, api, date, ip, navigate, normalize, origin };

package/dist/mail.js

@@ -0,0 +1,15 @@
+//#region packages/ajo-kit/src/mail/index.ts
+var transport = async (mail) => {
+	console.log("📧 Email:", mail.to, "-", mail.subject);
+	console.log(mail.text);
+};
+/** Sets the process-wide mail transport. */
+function configure(handler) {
+	transport = handler;
+}
+/** Sends one email through the configured transport. */
+async function send(mail) {
+	await transport(mail);
+}
+//#endregion
+export { configure, send };