@apisurf/wireui 0.1.2

package/dist/server/_libs/hookable.mjs

@@ -0,0 +1,41 @@
+//#region ../../node_modules/.pnpm/hookable@6.1.2/node_modules/hookable/dist/index.mjs
+function callHooks(hooks, args, startIndex, task) {
+	for (let i = startIndex; i < hooks.length; i += 1) try {
+		const result = task ? task.run(() => hooks[i](...args)) : hooks[i](...args);
+		if (result && typeof result.then === "function") return Promise.resolve(result).then(() => callHooks(hooks, args, i + 1, task));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+var HookableCore = class {
+	_hooks;
+	constructor() {
+		this._hooks = {};
+	}
+	hook(name, fn) {
+		if (!name || typeof fn !== "function") return () => {};
+		this._hooks[name] = this._hooks[name] || [];
+		this._hooks[name].push(fn);
+		return () => {
+			if (fn) {
+				this.removeHook(name, fn);
+				fn = void 0;
+			}
+		};
+	}
+	removeHook(name, function_) {
+		const hooks = this._hooks[name];
+		if (hooks) {
+			const index = hooks.indexOf(function_);
+			if (index !== -1) hooks.splice(index, 1);
+			if (hooks.length === 0) this._hooks[name] = void 0;
+		}
+	}
+	callHook(name, ...args) {
+		const hooks = this._hooks[name];
+		if (!hooks || hooks.length === 0) return;
+		return callHooks(hooks.slice(), args, 0);
+	}
+};
+//#endregion
+export { HookableCore };

package/dist/server/_libs/tanstack__history.mjs

@@ -0,0 +1,369 @@
+//#region ../../node_modules/.pnpm/@tanstack+history@1.162.4/node_modules/@tanstack/history/dist/esm/index.js
+var stateIndexKey = "__TSR_index";
+var popStateEvent = "popstate";
+var beforeUnloadEvent = "beforeunload";
+/**
+* Turn protocol-relative inputs such as "//evil.example" into paths
+* such as "/evil.example", keeping navigation on the current origin.
+*
+* For HTTP(S) URLs, WHATWG parsing ignores leading C0 controls and spaces,
+* removes tabs/newlines, and treats backslashes as slashes, so inputs like
+* "/\evil.example" also need normalization. This only allocates when those
+* rules would make the input protocol-relative.
+*/
+var protocolRelativePrefix = /^[\x00-\x20]*(?:[\\/][\t\n\r]*){2,}/;
+function normalizeProtocolRelative(url) {
+	const match = protocolRelativePrefix.exec(url);
+	return match ? "/" + url.slice(match[0].length) : url;
+}
+function normalizeHref(href) {
+	if (/[\x00-\x1f\x7f]/.test(href)) href = href.replace(/[\x00-\x1f\x7f]/g, (character) => "	\n\r".includes(character) ? "" : encodeURIComponent(character));
+	return normalizeProtocolRelative(href);
+}
+function createHistory(opts) {
+	let location = opts.getLocation();
+	const subscribers = /* @__PURE__ */ new Set();
+	const notify = (action) => {
+		location = opts.getLocation();
+		subscribers.forEach((subscriber) => subscriber({
+			location,
+			action
+		}));
+	};
+	const handleIndexChange = (action) => {
+		if (opts.notifyOnIndexChange ?? true) notify(action);
+		else location = opts.getLocation();
+	};
+	const tryNavigation = async ({ task, navigateOpts, ...actionInfo }) => {
+		if (navigateOpts?.ignoreBlocker ?? false) {
+			task();
+			return;
+		}
+		const blockers = opts.getBlockers?.() ?? [];
+		const isPushOrReplace = actionInfo.type === "PUSH" || actionInfo.type === "REPLACE";
+		if (typeof document !== "undefined" && blockers.length && isPushOrReplace) for (const blocker of blockers) {
+			const nextLocation = parseHref(actionInfo.path, actionInfo.state);
+			if (await blocker.blockerFn({
+				currentLocation: location,
+				nextLocation,
+				action: actionInfo.type
+			})) {
+				opts.onBlocked?.();
+				return;
+			}
+		}
+		task();
+	};
+	return {
+		get location() {
+			return location;
+		},
+		get length() {
+			return opts.getLength();
+		},
+		subscribers,
+		subscribe: (cb) => {
+			subscribers.add(cb);
+			return () => {
+				subscribers.delete(cb);
+			};
+		},
+		push: (path, state, navigateOpts) => {
+			const currentIndex = location.state[stateIndexKey];
+			state = assignKeyAndIndex(currentIndex + 1, state);
+			tryNavigation({
+				task: () => {
+					opts.pushState(path, state);
+					notify({ type: "PUSH" });
+				},
+				navigateOpts,
+				type: "PUSH",
+				path,
+				state
+			});
+		},
+		replace: (path, state, navigateOpts) => {
+			const currentIndex = location.state[stateIndexKey];
+			state = assignKeyAndIndex(currentIndex, state);
+			tryNavigation({
+				task: () => {
+					opts.replaceState(path, state);
+					notify({ type: "REPLACE" });
+				},
+				navigateOpts,
+				type: "REPLACE",
+				path,
+				state
+			});
+		},
+		go: (index, navigateOpts) => {
+			tryNavigation({
+				task: () => {
+					opts.go(index, navigateOpts?.ignoreBlocker ?? false);
+					handleIndexChange({
+						type: "GO",
+						index
+					});
+				},
+				navigateOpts,
+				type: "GO"
+			});
+		},
+		back: (navigateOpts) => {
+			tryNavigation({
+				task: () => {
+					opts.back(navigateOpts?.ignoreBlocker ?? false);
+					handleIndexChange({ type: "BACK" });
+				},
+				navigateOpts,
+				type: "BACK"
+			});
+		},
+		forward: (navigateOpts) => {
+			tryNavigation({
+				task: () => {
+					opts.forward(navigateOpts?.ignoreBlocker ?? false);
+					handleIndexChange({ type: "FORWARD" });
+				},
+				navigateOpts,
+				type: "FORWARD"
+			});
+		},
+		canGoBack: () => location.state[stateIndexKey] !== 0,
+		createHref: (str) => opts.createHref(str),
+		block: (blocker) => {
+			if (!opts.setBlockers) return () => {};
+			const blockers = opts.getBlockers?.() ?? [];
+			opts.setBlockers([...blockers, blocker]);
+			return () => {
+				const blockers = opts.getBlockers?.() ?? [];
+				opts.setBlockers?.(blockers.filter((b) => b !== blocker));
+			};
+		},
+		flush: () => opts.flush?.(),
+		destroy: () => opts.destroy?.(),
+		notify,
+		_getBlockers: () => opts.getBlockers?.() ?? []
+	};
+}
+function assignKeyAndIndex(index, state) {
+	const key = createRandomKey();
+	return {
+		...state,
+		key,
+		__TSR_key: key,
+		[stateIndexKey]: index
+	};
+}
+/**
+* Creates a history object that can be used to interact with the browser's
+* navigation. This is a lightweight API wrapping the browser's native methods.
+* It is designed to work with TanStack Router, but could be used as a standalone API as well.
+* IMPORTANT: This API implements history throttling via a microtask to prevent
+* excessive calls to the history API. In some browsers, calling history.pushState or
+* history.replaceState in quick succession can cause the browser to ignore subsequent
+* calls. This API smooths out those differences and ensures that your application
+* state will *eventually* match the browser state. In most cases, this is not a problem,
+* but if you need to ensure that the browser state is up to date, you can use the
+* `history.flush` method to immediately flush all pending state changes to the browser URL.
+* @param opts
+* @param opts.getHref A function that returns the current href (path + search + hash)
+* @param opts.createHref A function that takes a path and returns a href (path + search + hash)
+* @returns A history instance
+*/
+function createBrowserHistory(opts) {
+	const win = opts?.window ?? (typeof document !== "undefined" ? window : void 0);
+	const originalPushState = win.history.pushState;
+	const originalReplaceState = win.history.replaceState;
+	let blockers = [];
+	const _getBlockers = () => blockers;
+	const _setBlockers = (newBlockers) => blockers = newBlockers;
+	const createHref = (path) => normalizeHref(opts?.createHref ? opts.createHref(path) : path);
+	const parseLocation = opts?.parseLocation ?? (() => parseHref(`${win.location.pathname}${win.location.search}${win.location.hash}`, win.history.state));
+	if (!win.history.state?.__TSR_key && !win.history.state?.key) {
+		const addedKey = createRandomKey();
+		win.history.replaceState({
+			[stateIndexKey]: 0,
+			key: addedKey,
+			__TSR_key: addedKey
+		}, "");
+	}
+	let currentLocation = parseLocation();
+	let rollbackLocation;
+	let nextPopIsGo = false;
+	let ignoreNextPop = false;
+	let skipBlockerNextPop = false;
+	let ignoreNextBeforeUnload = false;
+	const getLocation = () => currentLocation;
+	let next;
+	const flush = () => {
+		if (!next) return;
+		history._ignoreSubscribers = true;
+		(next[2] ? win.history.pushState : win.history.replaceState)(next[1], "", next[0]);
+		history._ignoreSubscribers = false;
+		next = void 0;
+		rollbackLocation = void 0;
+	};
+	const queueHistoryAction = (isPush, destHref, state) => {
+		const href = opts?.createHref ? createHref(destHref) : void 0;
+		const hasPendingAction = !!next;
+		if (!hasPendingAction) rollbackLocation = currentLocation;
+		currentLocation = parseHref(destHref, state);
+		next = [
+			href ?? currentLocation.href,
+			state,
+			next?.[2] || isPush
+		];
+		if (!hasPendingAction) queueMicrotask(() => flush());
+	};
+	const onPushPop = (type) => {
+		currentLocation = parseLocation();
+		history.notify({ type });
+	};
+	const onPushPopEvent = async () => {
+		ignoreNextBeforeUnload = false;
+		if (ignoreNextPop) {
+			ignoreNextPop = false;
+			return;
+		}
+		const nextLocation = parseLocation();
+		const delta = nextLocation.state[stateIndexKey] - currentLocation.state[stateIndexKey];
+		const isForward = delta === 1;
+		const isBack = delta === -1;
+		const isGo = !isForward && !isBack || nextPopIsGo;
+		nextPopIsGo = false;
+		const action = isGo ? "GO" : isBack ? "BACK" : "FORWARD";
+		const notify = isGo ? {
+			type: "GO",
+			index: delta
+		} : { type: isBack ? "BACK" : "FORWARD" };
+		if (skipBlockerNextPop) skipBlockerNextPop = false;
+		else {
+			const blockers = _getBlockers();
+			if (typeof document !== "undefined" && blockers.length) {
+				for (const blocker of blockers) if (await blocker.blockerFn({
+					currentLocation,
+					nextLocation,
+					action
+				})) {
+					ignoreNextPop = true;
+					win.history.go(-delta);
+					history.notify(notify);
+					return;
+				}
+			}
+		}
+		currentLocation = parseLocation();
+		history.notify(notify);
+	};
+	const onBeforeUnload = (e) => {
+		if (ignoreNextBeforeUnload) {
+			ignoreNextBeforeUnload = false;
+			return;
+		}
+		let shouldBlock = false;
+		const blockers = _getBlockers();
+		if (typeof document !== "undefined" && blockers.length) for (const blocker of blockers) {
+			const shouldHaveBeforeUnload = blocker.enableBeforeUnload ?? true;
+			if (shouldHaveBeforeUnload === true) {
+				shouldBlock = true;
+				break;
+			}
+			if (typeof shouldHaveBeforeUnload === "function" && shouldHaveBeforeUnload() === true) {
+				shouldBlock = true;
+				break;
+			}
+		}
+		if (shouldBlock) {
+			e.preventDefault();
+			return e.returnValue = "";
+		}
+	};
+	const history = createHistory({
+		getLocation,
+		getLength: () => win.history.length,
+		pushState: (href, state) => queueHistoryAction(true, href, state),
+		replaceState: (href, state) => queueHistoryAction(false, href, state),
+		back: (ignoreBlocker) => {
+			if (ignoreBlocker) {
+				skipBlockerNextPop = true;
+				ignoreNextBeforeUnload = true;
+			}
+			return win.history.back();
+		},
+		forward: (ignoreBlocker) => {
+			if (ignoreBlocker) {
+				skipBlockerNextPop = true;
+				ignoreNextBeforeUnload = true;
+			}
+			win.history.forward();
+		},
+		go: (n, ignoreBlocker) => {
+			nextPopIsGo = true;
+			if (ignoreBlocker) {
+				skipBlockerNextPop = true;
+				ignoreNextBeforeUnload = true;
+			}
+			win.history.go(n);
+		},
+		createHref: (href) => createHref(href),
+		flush,
+		destroy: () => {
+			win.history.pushState = originalPushState;
+			win.history.replaceState = originalReplaceState;
+			win.removeEventListener(beforeUnloadEvent, onBeforeUnload, { capture: true });
+			win.removeEventListener(popStateEvent, onPushPopEvent);
+		},
+		onBlocked: () => {
+			if (rollbackLocation && currentLocation !== rollbackLocation) currentLocation = rollbackLocation;
+		},
+		getBlockers: _getBlockers,
+		setBlockers: _setBlockers,
+		notifyOnIndexChange: false
+	});
+	history._ignoreNextBeforeUnload = (href) => {
+		ignoreNextBeforeUnload = false;
+		try {
+			href = new URL(href, win.document.baseURI).href;
+			ignoreNextBeforeUnload = /^https?:/.test(href) && (!href.includes("#") || href.split("#")[0] !== win.location.href.split("#")[0]);
+		} catch {}
+	};
+	win.addEventListener(beforeUnloadEvent, onBeforeUnload, { capture: true });
+	win.addEventListener(popStateEvent, onPushPopEvent);
+	win.history.pushState = function(...args) {
+		const res = originalPushState.apply(win.history, args);
+		if (!history._ignoreSubscribers) onPushPop("PUSH");
+		return res;
+	};
+	win.history.replaceState = function(...args) {
+		const res = originalReplaceState.apply(win.history, args);
+		if (!history._ignoreSubscribers) onPushPop("REPLACE");
+		return res;
+	};
+	return history;
+}
+function parseHref(href, state) {
+	const sanitizedHref = normalizeHref(href);
+	const hashIndex = sanitizedHref.indexOf("#");
+	const searchIndex = sanitizedHref.indexOf("?");
+	if (!state) {
+		const key = createRandomKey();
+		state = {
+			[stateIndexKey]: 0,
+			key,
+			__TSR_key: key
+		};
+	}
+	return {
+		href: sanitizedHref,
+		pathname: sanitizedHref.substring(0, hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : sanitizedHref.length),
+		hash: hashIndex > -1 ? sanitizedHref.substring(hashIndex) : "",
+		search: searchIndex > -1 ? sanitizedHref.slice(searchIndex, hashIndex === -1 ? void 0 : hashIndex) : "",
+		state
+	};
+}
+function createRandomKey() {
+	return (Math.random() + 1).toString(36).substring(7);
+}
+//#endregion
+export { createBrowserHistory, normalizeProtocolRelative, parseHref };

package/dist/server/_libs/ufo.mjs

@@ -0,0 +1,64 @@
+String.fromCharCode;
+var ENC_SLASH_RE = /%2f/gi;
+function decode(text = "") {
+	try {
+		return decodeURIComponent("" + text);
+	} catch {
+		return "" + text;
+	}
+}
+function decodePath(text) {
+	return decode(text.replace(ENC_SLASH_RE, "%252F"));
+}
+var TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
+var JOIN_LEADING_SLASH_RE = /^\.?\//;
+function hasTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/");
+	return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+	if (!hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+	}
+	const [s0, ...s] = path.split("?");
+	return ((s0.endsWith("/") ? s0.slice(0, -1) : s0) || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function withTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/") ? input : input + "/";
+	if (hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+		if (!path) return fragment;
+	}
+	const [s0, ...s] = path.split("?");
+	return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function hasLeadingSlash(input = "") {
+	return input.startsWith("/");
+}
+function withLeadingSlash(input = "") {
+	return hasLeadingSlash(input) ? input : "/" + input;
+}
+function isNonEmptyURL(url) {
+	return url && url !== "/";
+}
+function joinURL(base, ...input) {
+	let url = base || "";
+	for (const segment of input.filter((url2) => isNonEmptyURL(url2))) if (url) {
+		const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+		url = withTrailingSlash(url) + _segment;
+	} else url = segment;
+	return url;
+}
+//#endregion
+export { decodePath, joinURL, withLeadingSlash, withoutTrailingSlash };

package/dist/server/_runtime.mjs

@@ -0,0 +1,35 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __commonJSMin, __exportAll, __require, __toESM };