roxxie-proxy-u-prod 0.1.0

package/source/external/dreamlandjs/src/motion/index.ts

@@ -0,0 +1,156 @@
+/* 
+
+simple svelte/motion spring port from https://github.com/sveltejs/svelte/tree/main/packages/svelte/src/motion
+
+Copyright (c) 2016-2025 [Svelte Contributors](https://github.com/sveltejs/svelte/graphs/contributors)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ */
+
+import { createState, Pointer, Stateful, stateProxy } from "dreamland/core";
+
+interface TickContext {
+	_inv_mass: number;
+	_dt: number;
+	_settled: boolean;
+
+	_stiffness: number;
+	_damping: number;
+	_precision: number;
+}
+
+let is_date = (val: any): val is Date => val instanceof Date;
+
+let tick_spring = <T>(
+	ctx: TickContext,
+	last_value: T,
+	current_value: T,
+	target_value: T
+): any => {
+	if (typeof current_value === "number" || is_date(current_value)) {
+		// @ts-expect-error value is date / number
+		let delta = target_value - current_value;
+		// @ts-expect-error value is date / number
+		let velocity = (current_value - last_value) / (ctx._dt || 1 / 60); // guard div by 0
+		let spring = ctx._stiffness * delta;
+		let damper = ctx._damping * velocity;
+		let acceleration = (spring - damper) * ctx._inv_mass;
+		let d = (velocity + acceleration) * ctx._dt;
+		if (Math.abs(d) < ctx._precision && Math.abs(delta) < ctx._precision) {
+			return target_value; // settled
+		} else {
+			ctx._settled = false; // signal loop to keep ticking
+			return is_date(current_value)
+				? (new Date(current_value.getTime() + d) as T)
+				: current_value + d;
+		}
+	} else if (Array.isArray(current_value)) {
+		return current_value.map((_, i) =>
+			tick_spring(
+				ctx,
+				(last_value as any)[i],
+				current_value[i],
+				(target_value as any)[i]
+			)
+		);
+	} else if (typeof current_value === "object") {
+		let next_value = {};
+		for (let k in current_value) {
+			// @ts-expect-error next_value is just an object
+			next_value[k] = tick_spring(
+				ctx,
+				last_value[k],
+				current_value[k],
+				target_value[k]
+			);
+		}
+		return next_value;
+	} else {
+		dev: {
+			throw new Error(`Cannot spring ${typeof current_value} values`);
+		}
+	}
+};
+
+export interface SpringOptions {
+	stiffness?: number;
+	damping?: number;
+	precision?: number;
+}
+export interface SpringState<T> {
+	stiffness: number;
+	damping: number;
+	precision: number;
+
+	target: T;
+	current: T;
+}
+export type Spring<T> = Stateful<SpringState<T>>;
+
+let timeNow = () => performance.now();
+
+let isPointer = <T>(x: T | Pointer<T>): x is Pointer<T> => x instanceof Pointer;
+
+export let createSpring = <T>(
+	val: T | Pointer<T>,
+	opts: SpringOptions = {}
+): Spring<T> => {
+	let state = createState({
+		stiffness: opts.stiffness ?? 0.15,
+		damping: opts.damping ?? 0.8,
+		precision: opts.precision ?? 0.01,
+
+		current: isPointer(val) ? val.value : val,
+	} satisfies Omit<SpringState<T>, "target"> as SpringState<T>);
+	if (isPointer(val)) stateProxy(state, "target", val);
+	else state.target = val;
+
+	let settling = false;
+	let last_time = 0;
+	let last_value = state.current;
+	let _inv_mass = 1;
+	let inv_mass_recovery_rate = 0;
+	let momentum = 0;
+
+	let update = () => {
+		let now = timeNow();
+
+		_inv_mass = Math.min(_inv_mass + inv_mass_recovery_rate, 1);
+		let elapsed = Math.min(now - last_time, 1000 / 30);
+
+		let ctx = {
+			_inv_mass,
+			_settled: true,
+			_dt: (elapsed * 60) / 1000,
+
+			_stiffness: state.stiffness,
+			_damping: state.damping,
+			_precision: state.precision,
+		} satisfies TickContext;
+		let next = tick_spring(ctx, last_value, state.current, state.target);
+		last_value = state.current;
+		last_time = now;
+		state.current = next;
+
+		if (ctx._settled) settling = false;
+		else requestAnimationFrame(update);
+	};
+
+	use(state.target)
+		.constrain(state)
+		.listen((_) => {
+			if (!settling) {
+				last_time = timeNow();
+				inv_mass_recovery_rate = 1000 / (momentum * 60);
+				settling = true;
+				requestAnimationFrame(update);
+			}
+		});
+
+	return state;
+};

package/source/external/dreamlandjs/src/router/index.tsx

@@ -0,0 +1,394 @@
+import {
+	ComponentChild,
+	Component,
+	ComponentState,
+	h,
+	Fragment,
+	DREAMLAND,
+	FC,
+	ComponentInstance,
+	NO_CHANGE,
+} from "dreamland/core";
+
+export type RouteParams = Record<string, string> & {
+	// @internal
+	[DREAMLAND]?: string;
+	[NO_CHANGE]: true;
+};
+
+export interface RouterState {
+	params: RouteParams;
+	path: string;
+	outlet?: HTMLElement;
+	error?: any;
+	loading: boolean;
+	initial: boolean;
+	[NO_CHANGE]: true;
+}
+
+export type LayoutComponent = Component<{ routerState: RouterState }>;
+
+export type ShowElement =
+	| ComponentInstance<Component<{}, { routerParams: RouteParams }>>
+	| HTMLElement;
+type _MaybePromiseShowEl = Promise<ShowElement> | ShowElement;
+export type ShowTarget = _MaybePromiseShowEl | (() => _MaybePromiseShowEl);
+
+export function Route(
+	this: FC<{
+		path?: string;
+		show?: ShowTarget;
+		layout?: LayoutComponent;
+		cork?: boolean;
+		children?: ComponentChild;
+	}>
+) {
+	return {
+		_path: this.path,
+		_show: this.show,
+		_layout: this.layout,
+		_cork: this.cork,
+		_children: this.children as any as RouteInternal[],
+	} satisfies RouteInternal as any;
+}
+
+interface RouteInternal {
+	_path?: string;
+	_layout?: LayoutComponent;
+	_layoutInstance?: ComponentInstance<LayoutComponent>;
+	_cork?: boolean;
+	_show?: ShowTarget;
+	_showInstance?: ShowElement;
+	_children: RouteInternal[];
+}
+let validateRoute = (route: RouteInternal) => {
+	let hasIndex = false;
+	if (route._children.length) {
+		if (route._show)
+			throw new Error(
+				"A route can't both show a page and have child pages. Use an index page."
+			);
+
+		for (let child of route._children) {
+			if (!child._path && !child._children) {
+				if (hasIndex)
+					throw new Error("A route cannot have multiple index pages");
+				hasIndex = true;
+			}
+			validateRoute(child);
+		}
+	}
+
+	if (!route._layout && route._cork) {
+		throw new Error("Corked routing only works on a route with a layout");
+	}
+};
+
+function _isComponent<T extends Component<any, any>>(
+	x: ComponentInstance<T> | HTMLElement
+): x is ComponentInstance<T> {
+	return (x as any).$;
+}
+let isComponent = _isComponent;
+
+let matchRoute = (
+	segment: string,
+	route: string,
+	params: RouteParams
+): boolean => {
+	if (params[DREAMLAND] || route === "*") {
+		params[DREAMLAND] += "/" + segment;
+		return true;
+	} else if (route.startsWith(":")) {
+		// param
+		params[route.slice(1)] = segment;
+		return true;
+	} else {
+		return segment === route;
+	}
+};
+
+let _route = (
+	route: RouteInternal,
+	path: string,
+	segments: string[],
+	params: RouteParams
+): RouteInternal[] => {
+	let routePath: string[] = [];
+	let indexRoute = false;
+	if (route._path) {
+		// has a path
+		routePath = route._path.split("/");
+	} else if (route._children.length) {
+		// will always match
+	} else {
+		// index route
+		indexRoute = true;
+	}
+
+	let ret: RouteInternal[] = [];
+
+	if (
+		!routePath.length ||
+		segments
+			.splice(0, routePath.length)
+			.every((x, i) => matchRoute(x, routePath[i], params))
+	) {
+		if (
+			(!segments.length ||
+				(segments[0] === "" && indexRoute) ||
+				params[DREAMLAND]) &&
+			!route._children.length &&
+			route._show
+		) {
+			if (params[DREAMLAND]) {
+				params["*"] = params[DREAMLAND].slice(10);
+				delete params[DREAMLAND];
+			}
+			// route matches fully
+			ret = [route];
+		} else {
+			// matched, continue searching for children
+			for (let child of route._children || []) {
+				ret = _route(child, path, [...segments], params);
+				if (ret.length) break;
+			}
+			if (ret.length) ret.unshift(route);
+		}
+	}
+
+	return ret;
+};
+
+type Disjoint<T1, T2> =
+	| ({ [P in keyof T2]?: never } & { [P in keyof T1]: T1[P] })
+	| ({ [P in keyof T1]?: never } & { [P in keyof T2]: T2[P] });
+type LayoutEl = ComponentInstance<LayoutComponent>;
+type ReconcileRet = Disjoint<
+	{ _el: Promise<ShowElement> },
+	{ _layout: LayoutEl; _dep: Promise<LayoutEl> }
+> & { _late: () => Promise<void> | void };
+let _reconcile = (
+	_current: RouteInternal[],
+	path: string,
+	params: RouteParams,
+	initial: boolean
+): ReconcileRet => {
+	let current = _current.pop();
+	dev: {
+		if (!current) throw "unreachable";
+	}
+	let reconcile = () => {
+		if (current._show) {
+			ret = {
+				_el: (async () => {
+					let show = current._show!;
+					let instance =
+						current._showInstance ||
+						(await (typeof show == "function" ? show() : show));
+
+					if (isComponent(instance)) instance.$.state.routerParams = params;
+					current._showInstance = instance;
+					return instance;
+				})(),
+				_late() {},
+			};
+		} else if (_current.length) {
+			ret = _reconcile(_current, path, params, initial);
+		} else {
+			dev: {
+				throw new Error(`Unable to navigate, route had no show target`);
+			}
+		}
+	};
+
+	let ret: ReconcileRet | undefined;
+	if (!current._cork) reconcile();
+
+	if (current._layout) {
+		let state: RouterState = {
+			params: { ...params },
+			path,
+			loading: true,
+			initial,
+			[NO_CHANGE]: true,
+		} satisfies RouterState;
+		let instance =
+			current._layoutInstance ||
+			((
+				<current._layout routerState={state} />
+			) as ComponentInstance<LayoutComponent>);
+		let instanceState = instance.$.state;
+		let finish = (ret: ReconcileRet) =>
+			(ret._dep || ret._el)
+				.then(
+					(x) => (state.outlet = x),
+					(x) => (state.error = x)
+				)
+				.finally((_: void) => {
+					state.loading = false;
+					instanceState.routerState = state;
+				});
+
+		current._layoutInstance = instance;
+		state.outlet = instanceState.routerState.outlet;
+		instance.$.state.routerState = state;
+
+		return {
+			_layout: instance,
+			_dep: ret ? finish(ret).then((_) => instance) : (async () => instance)(),
+			_late: ret
+				? ret._late
+				: async () => {
+						reconcile();
+						await ret!._late();
+						await finish(ret!);
+					},
+		};
+	}
+	return ret!;
+};
+
+export function Link(
+	this: FC<{
+		href: string;
+		class?: string;
+		children?: ComponentChild;
+		"on:click"?: () => void;
+	}>
+) {
+	this.class = this.class || "";
+
+	return (
+		<a
+			href={use(this.href)}
+			class={use(this.class)}
+			on:click={(e: MouseEvent) => {
+				e.preventDefault();
+				dev: {
+					if (!router) throw new Error("No router exists");
+				}
+
+				this["on:click"]?.();
+
+				router.navigate(this.href);
+			}}
+		>
+			{this.children}
+		</a>
+	);
+}
+
+export let router: ComponentState<typeof Router>;
+export function Router(
+	this: FC<
+		{
+			initial?: [path: string, origin: string] | [path: string] | [];
+			children: HTMLElement | HTMLElement[];
+		},
+		{
+			el?: ShowElement;
+
+			navigate: (path: string) => Promise<string | undefined>;
+			ssgables: () => [string, string][];
+			[NO_CHANGE]: true;
+		}
+	>
+) {
+	this[NO_CHANGE] = true;
+
+	// eslint-disable-next-line @typescript-eslint/no-this-alias
+	router = this;
+
+	let routes = { _children: this.children as any as RouteInternal[] };
+	dev: {
+		validateRoute(routes);
+	}
+
+	let latestNavId = 0;
+	let route = async (
+		initial: boolean,
+		path = location.pathname,
+		origin = location.origin
+	) => {
+		let currentNavId = ++latestNavId;
+		let realPath = new URL(path, origin).pathname;
+		if (realPath.endsWith(".html"))
+			realPath = realPath.slice(0, realPath.length - 5);
+		let segments = realPath.split("/").slice(1);
+		let params = { [NO_CHANGE]: true } as const;
+		let routePath = _route(routes, realPath, segments, params);
+
+		if (!routePath.length) {
+			throw new Error("Failed to route to " + path);
+		}
+
+		let reconciled = _reconcile(
+			[...routePath].reverse(),
+			realPath,
+			params,
+			initial
+		);
+		let el;
+
+		if (reconciled?._el) el = await reconciled._el;
+		else if (reconciled?._layout) {
+			el = reconciled._layout;
+			await reconciled._dep;
+		}
+
+		if (currentNavId !== latestNavId) return [];
+		this.el = el;
+
+		return [this.el && realPath, reconciled?._late] as const;
+	};
+	this.navigate = async (path) => {
+		let [ret, late] = await route(false, path);
+		await late?.();
+		if (ret) history.pushState(null, "", ret);
+		return ret;
+	};
+
+	this.ssgables = () => {
+		let traverse = (path: string, route: RouteInternal): [string, string][] => {
+			if (route._path) {
+				path += "/" + route._path;
+			}
+
+			if (route._children.length) {
+				return route._children.map((x) => traverse(path, x)).flat();
+			} else if (
+				!route._path ||
+				!(route._path.startsWith(":") || route._path === "*")
+			) {
+				return [
+					[path || "/", route._path ? path + ".html" : path + "/index.html"],
+				];
+			} else {
+				return [];
+			}
+		};
+		return traverse("", routes);
+	};
+
+	let late: () => Promise<void> | void;
+	let ran: boolean | undefined;
+	this.cx.init = () => {
+		let [path, origin] = this.initial || [];
+		return route(true, path, origin).then(([_, _late]) => {
+			if (ran) _late?.();
+			else late = _late;
+		});
+	};
+
+	this.cx.mount = () => {
+		addEventListener("popstate", () => {
+			route(false).then(([_, late]) => late?.());
+		});
+		let ret = late?.();
+		ran = true;
+		return ret;
+	};
+
+	return <>{use(this.el)}</>;
+}

package/source/external/dreamlandjs/src/router/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"compilerOptions": {
+		"jsx": "react",
+		"jsxFactory": "h",
+		"jsxFragmentFactory": "Fragment"
+	},
+	"include": ["."],
+	"extends": "../../tsconfig.json"
+}