vorma 0.0.0-pre.0 → 0.82.0

package/internal/framework/_typescript/solid/src/solid.tsx

@@ -0,0 +1,204 @@
+import {
+	batch,
+	createEffect,
+	createMemo,
+	createRenderEffect,
+	createSignal,
+	type JSX,
+	Show,
+} from "solid-js";
+import { Dynamic } from "solid-js/web";
+import {
+	__applyScrollState,
+	addLocationListener,
+	addRouteChangeListener,
+	__vormaClientGlobal as ctx,
+	getLocation,
+	getRouterData,
+	type RouteChangeEvent,
+} from "vorma/client";
+
+/////////////////////////////////////////////////////////////////////
+/////// CORE SETUP
+/////////////////////////////////////////////////////////////////////
+
+const [latestEvent, setLatestEvent] = createSignal<RouteChangeEvent | null>(
+	null,
+);
+const [loadersData, setLoadersData] = createSignal(ctx.get("loadersData"));
+const [clientLoadersData, setClientLoadersData] = createSignal(
+	ctx.get("clientLoadersData"),
+);
+const [routerData, setRouterData] = createSignal(getRouterData());
+const [outermostErrorIdx, setOutermostErrorIdx] = createSignal(
+	ctx.get("outermostErrorIdx"),
+);
+const [outermostError, setOutermostError] = createSignal(
+	ctx.get("outermostError"),
+);
+const [activeComponents, setActiveComponents] = createSignal(
+	ctx.get("activeComponents"),
+);
+const [activeErrorBoundary, setActiveErrorBoundary] = createSignal(
+	ctx.get("activeErrorBoundary"),
+);
+const [importURLs, setImportURLs] = createSignal(ctx.get("importURLs"));
+const [exportKeys, setExportKeys] = createSignal(ctx.get("exportKeys"));
+
+export { clientLoadersData, loadersData, routerData };
+
+let isInited = false;
+
+function initUIListeners() {
+	if (isInited) return;
+	isInited = true;
+
+	addRouteChangeListener((e) => {
+		batch(() => {
+			setLatestEvent(e);
+			setLoadersData(ctx.get("loadersData"));
+			setClientLoadersData(ctx.get("clientLoadersData"));
+			setRouterData(getRouterData());
+			setOutermostErrorIdx(ctx.get("outermostErrorIdx"));
+			setOutermostError(ctx.get("outermostError"));
+			setActiveComponents(ctx.get("activeComponents"));
+			setActiveErrorBoundary(ctx.get("activeErrorBoundary"));
+			setImportURLs(ctx.get("importURLs"));
+			setExportKeys(ctx.get("exportKeys"));
+		});
+	});
+
+	addLocationListener(() => {
+		setLocation(getLocation());
+	});
+}
+
+const [location, setLocation] = createSignal(getLocation());
+
+export { location };
+
+/////////////////////////////////////////////////////////////////////
+/////// COMPONENT
+/////////////////////////////////////////////////////////////////////
+
+export function VormaRootOutlet(props: { idx?: number }): JSX.Element {
+	const idx = props.idx ?? 0;
+
+	if (idx === 0) {
+		initUIListeners();
+
+		batch(() => {
+			setLoadersData(ctx.get("loadersData"));
+			setClientLoadersData(ctx.get("clientLoadersData"));
+			setRouterData(getRouterData());
+			setOutermostErrorIdx(ctx.get("outermostErrorIdx"));
+			setOutermostError(ctx.get("outermostError"));
+			setActiveComponents(ctx.get("activeComponents"));
+			setActiveErrorBoundary(ctx.get("activeErrorBoundary"));
+			setImportURLs(ctx.get("importURLs"));
+			setExportKeys(ctx.get("exportKeys"));
+		});
+	}
+
+	const [currentImportURL, setCurrentImportURL] = createSignal(
+		importURLs()?.[idx],
+	);
+	const [currentExportKey, setCurrentExportKey] = createSignal(
+		exportKeys()?.[idx],
+	);
+
+	createEffect(() => {
+		if (!currentImportURL()) {
+			return;
+		}
+		const e = latestEvent();
+		if (!e) {
+			return;
+		}
+
+		const newCurrentImportURL = importURLs()?.[idx];
+		const newCurrentExportKey = exportKeys()?.[idx];
+
+		if (currentImportURL() !== newCurrentImportURL) {
+			setCurrentImportURL(newCurrentImportURL);
+		}
+		if (currentExportKey() !== newCurrentExportKey) {
+			setCurrentExportKey(newCurrentExportKey);
+		}
+	});
+
+	createRenderEffect(() => {
+		const e = latestEvent();
+		if (!e || idx !== 0) {
+			return;
+		}
+		window.requestAnimationFrame(() => {
+			__applyScrollState(e.detail.__scrollState);
+		});
+	});
+
+	const isErrorIdxMemo = createMemo(() => {
+		return idx === outermostErrorIdx();
+	});
+
+	const currentCompMemo = createMemo(() => {
+		if (isErrorIdxMemo()) {
+			return null;
+		}
+		currentImportURL();
+		currentExportKey();
+		return activeComponents()?.[idx];
+	});
+
+	const shouldFallbackOutletMemo = createMemo(() => {
+		if (isErrorIdxMemo() || currentCompMemo()) {
+			return false;
+		}
+		return idx + 1 < loadersData().length;
+	});
+
+	const errorCompMemo = createMemo(() => {
+		if (!isErrorIdxMemo()) {
+			return null;
+		}
+		return activeErrorBoundary();
+	});
+
+	const remountKeyNext = createMemo(
+		() => `${importURLs()[idx + 1]}|${exportKeys()[idx + 1]}`,
+	);
+
+	const Outlet = (localProps: Record<string, any> | undefined) => (
+		<Show when={remountKeyNext()} keyed>
+			<VormaRootOutlet {...localProps} {...props} idx={idx + 1} />
+		</Show>
+	);
+
+	return (
+		<>
+			<Show when={currentCompMemo()}>
+				<Dynamic
+					component={currentCompMemo()}
+					idx={idx}
+					Outlet={Outlet}
+				/>
+			</Show>
+
+			<Show when={shouldFallbackOutletMemo()}>
+				<Outlet />
+			</Show>
+
+			<Show when={isErrorIdxMemo()}>
+				<Show
+					when={errorCompMemo()}
+					fallback={`Error: ${outermostError() || "unknown"}`}
+				>
+					<Dynamic
+						component={errorCompMemo()}
+						error={outermostError()}
+					/>
+				</Show>
+			</Show>
+		</>
+	);
+}

package/internal/framework/_typescript/solid/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"extends": "../../../../tsconfig.base.json",
+	"compilerOptions": {
+		"jsx": "preserve",
+		"jsxImportSource": "solid-js"
+	}
+}

package/internal/framework/_typescript/vite/tsconfig.json

@@ -0,0 +1,3 @@
+{
+	"extends": "../../../../tsconfig.base.json"
+}

package/internal/framework/_typescript/vite/vite.ts

@@ -0,0 +1,93 @@
+type VormaVitePluginConfig = {
+	rollupInput: ReadonlyArray<string>;
+	publicPathPrefix: string;
+	staticPublicAssetMap: Record<string, string>;
+	buildtimePublicURLFuncName: string;
+	ignoredPatterns: ReadonlyArray<string>;
+	dedupeList: ReadonlyArray<string>;
+};
+
+export default function vormaVitePlugin(config: VormaVitePluginConfig): any {
+	return {
+		name: "vorma-vite-plugin",
+		config(c: any, { command }: any) {
+			const mp = c.build?.modulePreload;
+			const roi = c.build?.rollupOptions?.input;
+			const ign = c.server?.watch?.ignored;
+			const dedupe = c.resolve?.dedupe;
+
+			const isDev = command === "serve";
+
+			return {
+				base: isDev ? "/" : config.publicPathPrefix,
+				build: {
+					target: "es2022",
+					emptyOutDir: false,
+					modulePreload: {
+						polyfill: false,
+						...(typeof mp === "object" ? mp : {}),
+					},
+					rollupOptions: {
+						...c.build?.rollupOptions,
+						input: [
+							...config.rollupInput,
+							...(Array.isArray(roi) ? roi : []),
+						],
+						preserveEntrySignatures: "exports-only",
+						output: {
+							assetFileNames:
+								"vorma_out_vite_[name]-[hash][extname]",
+							chunkFileNames: "vorma_out_vite_[name]-[hash].js",
+							entryFileNames: "vorma_out_vite_[name]-[hash].js",
+						},
+					},
+				},
+				server: {
+					headers: {
+						...c.server?.headers,
+						// ensure versions of dynamic imports without the latest
+						// hmr updates are not cached by the browser during dev
+						"cache-control": "no-store",
+					},
+					watch: {
+						...c.server?.watch,
+						ignored: [
+							...(Array.isArray(ign) ? ign : []),
+							...config.ignoredPatterns,
+						],
+					},
+				},
+				resolve: {
+					dedupe: [
+						...(Array.isArray(dedupe) ? dedupe : []),
+						...config.dedupeList,
+					],
+				},
+			};
+		},
+		transform(code: any, id: any) {
+			const isNodeModules = /node_modules/.test(id);
+			if (isNodeModules) return null;
+
+			const regex = new RegExp(
+				`${config.buildtimePublicURLFuncName}\\s*\\(\\s*(["'\`])(.*?)\\1\\s*\\)`,
+				"g",
+			);
+
+			const needsReplacement = regex.test(code);
+			if (!needsReplacement) return null;
+
+			const replacedCode = code.replace(
+				regex,
+				(_: any, __: any, assetPath: any) => {
+					const hashed = config.staticPublicAssetMap[assetPath];
+					if (!hashed) return `"${assetPath}"`;
+					return `"${config.publicPathPrefix}${hashed}"`;
+				},
+			);
+
+			if (replacedCode === code) return null;
+			return replacedCode;
+		},
+	};
+}

package/kit/_typescript/converters/converters.ts

@@ -0,0 +1,152 @@
+/////////////////////////////////////////////////////////////////////
+/////// TYPE ALIASES
+/////////////////////////////////////////////////////////////////////
+
+export type Bytes = Uint8Array;
+export type UTF8 = string;
+export type Hex = string;
+export type Base64 = string;
+export type Base64URL = string;
+
+/////////////////////////////////////////////////////////////////////
+/////// BYTES --> X
+/////////////////////////////////////////////////////////////////////
+
+// --> UTF8
+export function bytesToUTF8(bytes: Uint8Array): UTF8 {
+	return new TextDecoder().decode(bytes);
+}
+
+// --> HEX
+export function bytesToHex(bytes: Uint8Array): Hex {
+	return Array.from(bytes, (x) => x.toString(16).padStart(2, "0")).join("");
+}
+
+// --> BASE64
+export function bytesToBase64(bytes: Uint8Array): Base64 {
+	const callback = (x: number) => String.fromCodePoint(x);
+	return btoa(Array.from(bytes, callback).join(""));
+}
+
+// --> BASE64URL
+export function bytesToBase64URL(bytes: Uint8Array): Base64 {
+	const base64 = bytesToBase64(bytes);
+	return base64ToBase64URL(base64);
+}
+
+/////////////////////////////////////////////////////////////////////
+/////// UTF8 --> X
+/////////////////////////////////////////////////////////////////////
+
+// --> BYTES
+export function utf8ToBytes(utf8: UTF8): Uint8Array {
+	return new TextEncoder().encode(utf8);
+}
+
+// --> HEX
+export function utf8ToHex(utf8: UTF8): Hex {
+	const bytes = utf8ToBytes(utf8);
+	return bytesToHex(bytes);
+}
+
+// --> BASE64
+export function utf8ToBase64(utf8: UTF8): Base64 {
+	const bytes = utf8ToBytes(utf8);
+	return bytesToBase64(bytes);
+}
+
+// --> BASE64URL
+export function utf8ToBase64URL(utf8: UTF8): Base64 {
+	const bytes = utf8ToBytes(utf8);
+	return bytesToBase64URL(bytes);
+}
+
+/////////////////////////////////////////////////////////////////////
+/////// HEX --> X
+/////////////////////////////////////////////////////////////////////
+
+// --> BYTES
+export function hexToBytes(hex: Hex): Uint8Array {
+	const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+	const bytes =
+		cleanHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || [];
+	return new Uint8Array(bytes);
+}
+
+// --> UTF8
+export function hexToUTF8(hex: Hex): UTF8 {
+	const bytes = hexToBytes(hex);
+	return bytesToUTF8(bytes);
+}
+
+// --> BASE64
+export function hexToBase64(hex: Hex): Base64 {
+	const bytes = hexToBytes(hex);
+	return bytesToBase64(bytes);
+}
+
+// --> BASE64URL
+export function hexToBase64URL(hex: Hex): Base64 {
+	const bytes = hexToBytes(hex);
+	return bytesToBase64URL(bytes);
+}
+
+/////////////////////////////////////////////////////////////////////
+/////// BASE64 --> X
+/////////////////////////////////////////////////////////////////////
+
+// --> BYTES
+export function base64ToBytes(base64: Base64): Uint8Array {
+	return Uint8Array.from(atob(base64), (m) => m.codePointAt(0) || 0);
+}
+
+// --> UTF8
+export function base64ToUTF8(base64: Base64): UTF8 {
+	const bytes = base64ToBytes(base64);
+	return bytesToUTF8(bytes);
+}
+
+// --> HEX
+export function base64ToHex(base64: Base64): Hex {
+	const bytes = base64ToBytes(base64);
+	return bytesToHex(bytes);
+}
+
+// --> BASE64URL
+export function base64ToBase64URL(base64: Base64): Base64 {
+	return base64
+		.replace(/[\r\n\t ]+/g, "")
+		.replace(/\+/g, "-")
+		.replace(/\//g, "_")
+		.replace(/=+$/, "");
+}
+
+/////////////////////////////////////////////////////////////////////
+/////// BASE64URL --> X
+/////////////////////////////////////////////////////////////////////
+
+// --> BYTES
+export function base64URLToBytes(base64URL: Base64URL): Uint8Array {
+	const base64 = base64URLToBase64(base64URL);
+	return base64ToBytes(base64);
+}
+
+// --> UTF8
+export function base64URLToUTF8(base64URL: Base64URL): UTF8 {
+	const bytes = base64URLToBytes(base64URL);
+	return bytesToUTF8(bytes);
+}
+
+// --> HEX
+export function base64URLToHex(base64URL: Base64URL): Hex {
+	const bytes = base64URLToBytes(base64URL);
+	return bytesToHex(bytes);
+}
+
+// --> BASE64
+export function base64URLToBase64(base64URL: Base64URL): Base64 {
+	return base64URL
+		.padEnd(base64URL.length + ((4 - (base64URL.length % 4)) % 4), "=")
+		.replace(/-/g, "+")
+		.replace(/_/g, "/");
+}

package/kit/_typescript/cookies/cookies.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks the client cookie for a specific name. Returns the value if
+ * found, otherwise undefined. Does not do any encoding or decoding.
+ */
+export function getClientCookie(name: string) {
+	const match = document.cookie.match(new RegExp(`(^| )${name}=([^;]*)`));
+	return match ? match[2] : undefined;
+}
+
+/**
+ * Sets a client cookie with the specified name and value. The cookie
+ * is set to expire in one year and is accessible to all paths on the
+ * domain. The SameSite attribute is set to Lax. Does not do any
+ * encoding or decoding.
+ */
+export function setClientCookie(name: string, value: string) {
+	document.cookie = `${name}=${value}; path=/; max-age=31536000; SameSite=Lax`;
+}

package/kit/_typescript/csrf/csrf.ts

@@ -0,0 +1,10 @@
+import { getClientCookie } from "vorma/kit/cookies";
+
+export function getCSRFToken(opts: {
+	isDev: boolean;
+	cookieName?: string;
+}): string | undefined {
+	const prefix = opts.isDev ? "__Dev-" : "__Host-";
+	const name = opts.cookieName || "csrf_token";
+	return getClientCookie(prefix + name);
+}

package/kit/_typescript/debounce/debounce.ts

@@ -0,0 +1,17 @@
+type Fn = (...args: Array<any>) => any;
+
+export function debounce<T extends Fn>(
+	fn: T,
+	delayInMs: number,
+): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>> {
+	let timeoutID: number;
+
+	return (...args: Parameters<T>) => {
+		return new Promise<Awaited<ReturnType<T>>>((resolve) => {
+			clearTimeout(timeoutID);
+			timeoutID = window.setTimeout(() => {
+				resolve(fn(...args));
+			}, delayInMs);
+		});
+	};
+}

package/kit/_typescript/fmt/fmt.ts

@@ -0,0 +1,3 @@
+export function prettyJSON(obj: any): string {
+	return JSON.stringify(obj, null, 2);
+}

package/kit/_typescript/json/deep_equals.ts

@@ -0,0 +1,54 @@
+/**
+ * Performs a deep equality comparison of two JSON-compatible values.
+ * Handles null, undefined, primitives, arrays, and plain objects, recursively.
+ * Does not support Maps, Sets, Functions, or other non-JSON types.
+ */
+export function jsonDeepEquals(a: unknown, b: unknown): boolean {
+	// Tautology
+	if (a === b) {
+		return true;
+	}
+
+	// If both were null or both were undefined, we would have early returned above.
+	// So if either at this point is loosely null, we know they're not equal.
+	if (a == null || b == null) {
+		return false;
+	}
+
+	// If types are different, we know they're not equal.
+	if (typeof a !== typeof b) {
+		return false;
+	}
+
+	const aIsArray = Array.isArray(a);
+	const bIsArray = Array.isArray(b);
+
+	// If one is an array and the other is not, we know they're not equal.
+	if (aIsArray !== bIsArray) {
+		return false;
+	}
+
+	// Handle arrays
+	if (aIsArray && bIsArray) {
+		if (a.length !== b.length) {
+			return false;
+		}
+		return a.every((item, index) => jsonDeepEquals(item, b[index]));
+	}
+
+	// Handle objects
+	if (typeof a === "object" && typeof b === "object") {
+		const aKeys = Object.keys(a as object);
+		const bKeys = Object.keys(b as object);
+
+		if (aKeys.length !== bKeys.length) {
+			return false;
+		}
+
+		return aKeys.every((key) => {
+			return Object.hasOwn(b, key) && jsonDeepEquals((a as any)[key], (b as any)[key]);
+		});
+	}
+
+	return false;
+}

package/kit/_typescript/json/json.ts

@@ -0,0 +1,3 @@
+export { jsonDeepEquals } from "./deep_equals.ts";
+export { serializeToSearchParams } from "./search_param_serializer.ts";
+export { jsonStringifyStable } from "./stringify_stable.ts";

package/kit/_typescript/json/search_param_serializer.ts

@@ -0,0 +1,49 @@
+export function serializeToSearchParams(obj: Record<any, any>): URLSearchParams {
+	const params = new URLSearchParams();
+
+	function appendValue(key: string, value: any) {
+		if (value === null || value === undefined) {
+			params.append(key, "");
+			return;
+		}
+
+		if (Array.isArray(value)) {
+			if (value.length === 0) {
+				params.append(key, "");
+			} else {
+				for (const item of value) {
+					appendValue(key, item);
+				}
+			}
+			return;
+		}
+
+		if (typeof value === "object") {
+			const entries = Object.entries(value);
+			if (entries.length === 0) {
+				params.append(key, "");
+			} else {
+				// Sort nested keys alphabetically
+				entries.sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
+				for (const [subKey, subValue] of entries) {
+					const newKey = key ? `${key}.${subKey}` : subKey;
+					appendValue(newKey, subValue);
+				}
+			}
+			return;
+		}
+
+		params.append(key, String(value));
+	}
+
+	if (typeof obj === "object" && obj !== null) {
+		// Sort top-level keys alphabetically
+		const entries = Object.entries(obj);
+		entries.sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
+		for (const [key, value] of entries) {
+			appendValue(key, value);
+		}
+	}
+
+	return params;
+}

package/kit/_typescript/json/stringify_stable.ts

@@ -0,0 +1,43 @@
+/**
+ * Deterministically serializes a JSON-compatible value to a stable string.
+ * Throws if it detects a circular reference. Does not support Maps, Sets,
+ * Functions, or other non-JSON types.
+ */
+export function jsonStringifyStable(input: unknown): string {
+	// First stabilize the structure, then JSON.stringify
+	const stabilized = stabilizeStructure(input, new WeakSet());
+
+	return JSON.stringify(stabilized);
+}
+
+function stabilizeStructure(value: unknown, visited: WeakSet<object>): unknown {
+	// Handle primitives and null
+	if (value === null || typeof value !== "object") {
+		return value;
+	}
+
+	// Prevent circular references
+	if (visited.has(value)) {
+		throw new Error("Circular reference detected during stable JSON stringification");
+	}
+	visited.add(value);
+
+	// Handle arrays - recursively stabilize each element
+	if (Array.isArray(value)) {
+		const result = value.map((item) => stabilizeStructure(item, visited));
+		visited.delete(value); // Clean up after processing
+		return result;
+	}
+
+	// Handle objects - sort keys and recursively stabilize values
+	const keys = Object.keys(value).sort();
+	const stable: Record<string, unknown> = {};
+
+	// Add sorted keys with stabilized values
+	for (const key of keys) {
+		stable[key] = stabilizeStructure((value as Record<string, unknown>)[key], visited);
+	}
+
+	visited.delete(value); // Clean up after processing
+	return stable;
+}