roxxie-proxy-u-prod 0.1.0

package/source/external/dreamlandjs/src/core/state/pointers.ts

@@ -0,0 +1,310 @@
+import { DREAMLAND, NO_CHANGE, WEAKMAP, WEAKREF } from "../consts";
+import { currentComponentCx } from "../jsx";
+import { deref, ObjectProp } from "../utils";
+import {
+	_stateListen,
+	_stateListenRemove,
+	isStateful,
+	Stateful,
+} from "./state";
+import { useTrap, UseTrapMap, useTrapMap } from "./use";
+
+let constraints: WeakMap<any, Pointer<any>[]> = WEAKMAP();
+let internalPointers: WeakMap<Pointer<any>, InternalPointer<any>> = WEAKMAP();
+
+const enum PointerType {
+	Regular = 0,
+	Mapped = 1,
+	Zipped = 2,
+}
+
+type StateStepListener = (prop?: ObjectProp) => void;
+type StateStepVal = Pointer<ObjectProp> | ObjectProp;
+type StateStep = {
+	readonly _prop: StateStepVal;
+	// the computed value used in _recalculate
+	_computed?: any;
+	// the current state object that has the listener
+	_state?: Stateful<any>;
+	// the listener
+	_callback?: StateStepListener;
+	// listener weakref
+	_callbackRef?: WeakRef<StateStepListener>;
+};
+export type PointerListener<T> = (val: T) => void;
+type InternalPointer<T> = {
+	_listeners: PointerListener<T>[];
+	_weaks: WeakRef<PointerListener<T>>[];
+} & (
+	| {
+			readonly _type: PointerType.Regular;
+			readonly _state: Stateful<any>;
+			readonly _path: ReadonlyArray<StateStep>;
+	  }
+	| {
+			readonly _type: PointerType.Mapped;
+
+			readonly _ptr: Pointer<any>;
+			readonly _map: (val: any) => T;
+			readonly _reverse?: (val: T) => any | typeof NO_CHANGE;
+	  }
+	| {
+			readonly _type: PointerType.Zipped;
+
+			readonly _ptrs: ReadonlyArray<Pointer<any>>;
+	  }
+);
+type InternalRegularPointer<T> = InternalPointer<T> & {
+	readonly _type: PointerType.Regular;
+};
+type InternalZippedPointer<T> = InternalPointer<T> & {
+	readonly _type: PointerType.Zipped;
+};
+
+export interface InitializingPointer {
+	_state: Stateful<any>;
+	_path: ObjectProp[];
+}
+
+let unwrapStep = (val: StateStep): any => unwrapValue(val._prop);
+let followPath = (obj: any, path: ReadonlyArray<StateStep>): any =>
+	path.reduce((acc, x) => acc[unwrapStep(x)], obj);
+
+type DistributiveOmit<T, K extends PropertyKey> = T extends any
+	? Omit<T, K>
+	: never;
+let newPtr = (
+	ptr: DistributiveOmit<InternalPointer<any>, "_listeners" | "_weaks">
+) => new Pointer<any>({ ...ptr, _listeners: [], _weaks: [] });
+
+export let initializeStep = (
+	map: UseTrapMap,
+	step: ObjectProp
+): StateStepVal => {
+	// map will just return nothing, cast to reduce code size
+	let init = map.get(step as symbol);
+	if (init instanceof Pointer) return init;
+	else if (!init) return step;
+
+	return newPtr({
+		_type: PointerType.Regular,
+		_state: init._state,
+		_path: init._path.map((x) => ({ _prop: initializeStep(map, x) })),
+	});
+};
+
+type Truthy<T> = NonNullable<Exclude<T, false | 0 | "" | null | undefined>>;
+type Falsy<T> = Extract<T, false | 0 | "" | null | undefined>;
+
+export class Pointer<T> {
+	// @internal
+	_id: symbol = Symbol();
+	// @internal
+	_listener = this._callListeners.bind(this);
+	// @internal
+	_cssIdent?: string;
+
+	// @internal
+	get _ptr(): InternalPointer<T> {
+		return internalPointers.get(this)!;
+	}
+
+	// @internal
+	_recalculate(i: number, ptr: InternalRegularPointer<T>, step: StateStep) {
+		let old = step._state;
+		let last = ptr._path[i - 1]?._computed || ptr._state;
+
+		step._computed = followPath(ptr._state, ptr._path.slice(0, i))[
+			unwrapStep(step)
+		];
+		step._state = isStateful(last) ? last : null;
+
+		if (old !== step._state) {
+			if (old) _stateListenRemove(old, step._callbackRef!);
+			if (step._state) _stateListen(step._state, step._callbackRef!);
+		}
+	}
+
+	// @internal
+	_changed(i: number, _: any, prop?: ObjectProp) {
+		let ptr = this._ptr;
+		dev: {
+			if (ptr._type != PointerType.Regular) throw "unreachable";
+		}
+		if (prop && prop !== unwrapStep(ptr._path[i])) return;
+
+		for (; i < ptr._path.length; i++) {
+			this._recalculate(i, ptr, ptr._path[i]);
+		}
+
+		this._callListeners();
+	}
+
+	// @internal
+	_callListeners() {
+		let ptr = this._ptr;
+		ptr._listeners.map((x) => x(this.value));
+		(ptr._weaks = ptr._weaks.filter(deref)).map((x) => deref(x)!(this.value));
+	}
+
+	// @internal
+	constructor(internal: InternalPointer<T>) {
+		internalPointers.set(this, internal);
+
+		if (internal._type == PointerType.Regular) {
+			internal._path.map((x, i) => {
+				x._callback = this._changed.bind(this, i);
+				x._callbackRef = WEAKREF(x._callback);
+				if (x._prop instanceof Pointer) x._prop._listenWeak(x._callbackRef);
+				this._recalculate(i, internal, x);
+			});
+		} else if (internal._type == PointerType.Mapped) {
+			internal._ptr._listenWeak(WEAKREF(this._listener));
+		} else if (internal._type == PointerType.Zipped) {
+			internal._ptrs.map((x) => x._listenWeak(WEAKREF(this._listener)));
+		}
+
+		if (currentComponentCx) this.constrain(currentComponentCx.state);
+	}
+
+	get value(): T {
+		let ptr = this._ptr;
+
+		if (ptr._type == PointerType.Regular) {
+			return followPath(ptr._state, ptr._path);
+		} else if (ptr._type == PointerType.Mapped) {
+			return ptr._map(ptr._ptr.value);
+		} else if (ptr._type == PointerType.Zipped) {
+			return ptr._ptrs.map((x) => x.value) as any;
+		}
+		dev: {
+			throw "unreachable";
+		}
+	}
+
+	// @internal
+	_set(val: T): boolean {
+		let ptr = this._ptr;
+		let recalculated: any;
+
+		if (ptr._type == PointerType.Regular) {
+			followPath(ptr._state, ptr._path.slice(0, -1))[
+				unwrapStep(ptr._path[ptr._path.length - 1])
+			] = val;
+			return true;
+		} else if (ptr._type == PointerType.Mapped) {
+			if (ptr._reverse && (recalculated = ptr._reverse(val)) !== NO_CHANGE) {
+				ptr._ptr.value = recalculated;
+				return true;
+			}
+		}
+		// zipped
+		return false;
+	}
+	set value(val: T) {
+		this._set(val);
+	}
+
+	[DREAMLAND](): ReadonlyArray<Pointer<any>> | undefined {
+		return (this._ptr as InternalZippedPointer<T>)._ptrs;
+	}
+
+	[Symbol.toPrimitive]() {
+		if (useTrap) useTrapMap.set(this._id, this);
+		return this._id;
+	}
+
+	// @internal
+	_listenWeak(func: WeakRef<PointerListener<T>>): void {
+		this._ptr._weaks.push(func);
+	}
+	listen(func: PointerListener<T>) {
+		this._ptr._listeners.push(func);
+	}
+
+	zip<Ptrs extends ReadonlyArray<Pointer<any>>>(
+		...pointers: Ptrs
+	): Pointer<
+		[
+			T,
+			...{
+				[Idx in keyof Ptrs]: Ptrs[Idx] extends Pointer<infer Val> ? Val : never;
+			},
+		]
+	> {
+		return newPtr({
+			_type: PointerType.Zipped,
+			_ptrs: [this, ...pointers],
+		});
+	}
+
+	and<R>(then: R | ((val: Truthy<T>) => R)): Pointer<Falsy<T> | R> {
+		return this.map(
+			(val): Falsy<T> | R =>
+				(val as Falsy<T>) &&
+				(typeof then === "function"
+					? (then as (val: Truthy<T>) => R)(val as Truthy<T>)
+					: then)
+		);
+	}
+
+	or<R>(then: R | ((val: Falsy<T>) => R)): Pointer<Truthy<T> | R> {
+		return this.map(
+			(val) =>
+				(val as Truthy<T>) ||
+				(typeof then === "function"
+					? (then as (val: Falsy<T>) => R)(val as Falsy<T>)
+					: then)
+		);
+	}
+	not(): Pointer<boolean> {
+		return this.map((val) => !val);
+	}
+
+	map<U>(func: (val: T) => U): Pointer<U>;
+	map<U>(
+		func: (val: T) => U,
+		reverse: (val: U) => T | typeof NO_CHANGE
+	): Pointer<U>;
+	map<U>(_map: (val: T) => U, _reverse?: (val: U) => T | typeof NO_CHANGE) {
+		return newPtr({
+			_type: PointerType.Mapped,
+			_ptr: this,
+			_map,
+			_reverse,
+		});
+	}
+	mapEach<U, R>(
+		this: Pointer<ArrayLike<U>>,
+		func: (val: U, i: number) => R
+	): Pointer<R[]> {
+		return this.map((x) => Array.from(x).map(func));
+	}
+
+	constrain(to: any) {
+		if (!constraints.has(to)) constraints.set(to, []);
+		constraints.get(to)!.push(this);
+		return this;
+	}
+	unconstrain(to: any) {
+		constraints.set(to, constraints.get(to)?.filter((x) => x !== this) || []);
+	}
+}
+
+export let unwrapValue = <T>(val: Pointer<T> | T): T =>
+	val instanceof Pointer ? val.value : (val as T);
+export let maybeListen = <T>(
+	val: Pointer<T> | T,
+	constrain: any,
+	func: (val: T) => void,
+	pointer?: () => void
+) => {
+	let old = val;
+	if (val instanceof Pointer) {
+		pointer?.();
+		val
+			.constrain(constrain)
+			.listen((val) => old !== val && (func(val), (old = val)));
+	}
+	func(unwrapValue(val));
+};

package/source/external/dreamlandjs/src/core/state/state.ts

@@ -0,0 +1,112 @@
+import { COMMA_TOKEN, WEAKMAP } from "../consts";
+import { deref, ObjectProp } from "../utils";
+import { InitializingPointer, Pointer } from "./pointers";
+import { useTrap, useTrapMap } from "./use";
+
+let internalStatefuls: WeakMap<Stateful<any>, InternalStateful> = WEAKMAP();
+
+export type StatefulListener = (newValue: any, prop: ObjectProp) => void;
+
+interface InternalStateful {
+	_listeners: StatefulListener[];
+	_weaks: WeakRef<StatefulListener>[];
+	_proxies: Record<ObjectProp, Pointer<any>>;
+}
+
+export type Stateful<T extends object> = T & {
+	/// THIS IS A SEALED MARKER TYPE. do not try accessing it
+	readonly [COMMA_TOKEN]: unique symbol;
+};
+
+let getInternal = (stateful: Stateful<any>): InternalStateful =>
+	internalStatefuls.get(stateful)!;
+let callListeners = (
+	internal: InternalStateful,
+	prop: ObjectProp,
+	newValue: any
+) => {
+	internal._listeners.map((x) => x(newValue, prop));
+	(internal._weaks = internal._weaks.filter(deref)).map((x) =>
+		deref(x)!(newValue, prop)
+	);
+};
+
+export let _stateListen = <T extends object>(
+	stateful: Stateful<T>,
+	listener: WeakRef<StatefulListener>
+) => {
+	getInternal(stateful)._weaks.push(listener);
+};
+export let _stateListenRemove = <T extends object>(
+	stateful: Stateful<T>,
+	listener: WeakRef<StatefulListener>
+) => {
+	getInternal(stateful)._weaks = getInternal(stateful)._weaks.filter(
+		(x) => x !== listener
+	);
+};
+
+export let createState = <T extends object>(target: T): Stateful<T> => {
+	let internal: InternalStateful = {
+		_listeners: [],
+		_weaks: [],
+		_proxies: {},
+	} satisfies InternalStateful;
+
+	let ret = new Proxy(target, {
+		get(target, p, receiver) {
+			if (useTrap) {
+				let sym = Symbol();
+				let ptr: InitializingPointer = {
+					_state: ret,
+					_path: [p],
+				} satisfies InitializingPointer;
+				useTrapMap.set(sym, ptr);
+
+				return new Proxy(
+					{},
+					{
+						get(target, p, receiver) {
+							if (p === Symbol.toPrimitive) return () => sym;
+							ptr._path.push(p);
+							return receiver;
+						},
+					}
+				);
+			}
+
+			return internal._proxies[p]
+				? internal._proxies[p].value
+				: Reflect.get(target, p, receiver);
+		},
+		set(target, p, newValue, receiver) {
+			let setRet = internal._proxies[p]
+				? internal._proxies[p]._set(newValue)
+				: Reflect.set(target, p, newValue, receiver);
+			if (setRet) callListeners(internal, p, newValue);
+			// returning setRet would be better here but it would break a lot of strictmode code
+			return true;
+		},
+	}) as Stateful<T>;
+	internalStatefuls.set(ret, internal);
+	return ret;
+};
+
+export let stateListen = <T extends object>(
+	state: Stateful<T>,
+	func: StatefulListener
+) => {
+	getInternal(state)._listeners.push(func);
+};
+
+export let stateProxy = <T extends object, Key extends keyof T & ObjectProp>(
+	state: Stateful<T>,
+	key: Key,
+	ptr: Pointer<T[Key]>
+) => {
+	// `number` keys will get coerced to string anyway
+	getInternal(state)._proxies[key as ObjectProp] = ptr;
+	ptr.listen((val) => callListeners(getInternal(state), key, val));
+};
+
+export let isStateful = (val: any): val is Stateful<any> => !!getInternal(val);

package/source/external/dreamlandjs/src/core/state/use.ts

@@ -0,0 +1,82 @@
+import { MAP } from "../consts";
+import { initializeStep, InitializingPointer, Pointer } from "./pointers";
+import { createState, Stateful } from "./state";
+
+// epheremal strong reference allowing pointers to be recorded and then looked up later
+export type UseTrapElement = Pointer<any> | InitializingPointer;
+export type UseTrapMap = Map<symbol, UseTrapElement>;
+export let useTrapMap: UseTrapMap = MAP();
+
+export let useTrap = false;
+
+let initializeSteps = (map: UseTrapMap, ...steps: any) => {
+	let prims = steps.map((x: any) => [x, x[Symbol.toPrimitive]()]);
+	useTrap = false;
+	useTrapMap = MAP();
+	return prims.map(([a, b]: any) => {
+		let initialized = initializeStep(map, b);
+		return initialized instanceof Pointer ? initialized : a;
+	});
+};
+
+let usestr = (template: TemplateStringsArray, params: any[]) => {
+	let state = createState({}) as Stateful<{ _string: string }>;
+	let flattened = [];
+
+	for (let i in template) {
+		flattened.push(template[i]);
+		if (params[i]) {
+			let val = params[i];
+
+			if (val instanceof Pointer) {
+				let i = flattened.length;
+				val.constrain(state).listen((val) => {
+					flattened[i] = val;
+					state._string = flattened.join("");
+				});
+				flattened.push(val.value);
+			} else {
+				flattened.push(val);
+			}
+		}
+	}
+
+	state._string = flattened.join("");
+
+	return use(state._string);
+};
+
+export let defineUse = () => {
+	Object.defineProperty(globalThis, "use", {
+		get() {
+			useTrap = true;
+			return (
+				magicPtr: { [Symbol.toPrimitive]: () => symbol } | TemplateStringsArray,
+				...params: any[]
+			) => {
+				let map = useTrapMap;
+
+				usestr: {
+					if (magicPtr instanceof Array && "raw" in magicPtr)
+						return usestr(magicPtr, initializeSteps(map, ...params));
+				}
+
+				let [init, ...rest] = initializeSteps(map, magicPtr, ...params);
+
+				return params.length ? init.zip(...rest) : init;
+			};
+		},
+		configurable: true,
+	});
+};
+
+declare global {
+	function use<T>(stateful: T): Pointer<T>;
+	function use<T extends any[]>(...statefuls: T): Pointer<T>;
+	/* USESTR.START */
+	function use(
+		template: TemplateStringsArray,
+		...params: any[]
+	): Pointer<string>;
+	/* USESTR.END */
+}

package/source/external/dreamlandjs/src/core/utils.ts

@@ -0,0 +1,48 @@
+export type ObjectProp = string | symbol;
+
+export let deref = <T extends object>(x: WeakRef<T>): T | undefined =>
+	x.deref();
+
+export let fatal = () => {
+	throw new Error("dl");
+};
+
+// https://en.wikipedia.org/wiki/Longest_increasing_subsequence#Efficient_algorithms
+// we're using strings as indices because of `in`. we don't really care if it's a string or a number since it's only gonna be indexing someting
+export let findLIS = (arr: number[]): number[] => {
+	// M[i]: index of the smallest tail of the LIS with length i+1
+	let tails: number[] = [0];
+	// P[i]: index of the value before the tail of the LIS with length i+1
+	let predecessors: number[] = [];
+	// L: length of the longest subsequence found so far
+	let longest: number = 1;
+
+	let out: number[] = [];
+	let currentIndex: number;
+
+	for (let i in arr) {
+		let lo = 1;
+		let hi = longest + 1;
+		let mid: number;
+		let newLongest: number;
+
+		while (lo < hi) {
+			mid = lo + Math.floor((hi - lo) / 2);
+			if (arr[tails[mid]] >= arr[i]) hi = mid;
+			else lo = mid + 1;
+		}
+
+		newLongest = lo;
+		predecessors[i] = tails[newLongest - 1];
+		tails[newLongest] = +i;
+		if (newLongest > longest) longest = newLongest;
+	}
+
+	currentIndex = tails[longest];
+
+	for (let j = longest - 1; j >= 0; j--) {
+		out[j] = arr[currentIndex];
+		currentIndex = predecessors[currentIndex];
+	}
+	return out;
+};

package/source/external/dreamlandjs/src/js-runtime/index.ts

@@ -0,0 +1,4 @@
+import { h } from "dreamland/core";
+import htm from "htm/mini";
+
+export const html = htm.bind(h);

package/source/external/dreamlandjs/src/jsx-runtime/index.ts

@@ -0,0 +1,3 @@
+import { JSX, jsx, Fragment } from "dreamland/core";
+
+export { jsx as jsx, jsx as jsxs, jsx as jsxDEV, JSX, Fragment };