roxxie-proxy-u-prod 0.1.0

package/source/external/dreamlandjs/src/ssr/server/vdom.ts

@@ -0,0 +1,285 @@
+import { ComponentContext, DomImpl } from "dreamland/core";
+
+// @ts-expect-error rrweb-cssom doesn't have types
+import { CSSOM } from "rrweb-cssom";
+
+import {
+	Element as DomElement,
+	Comment as DomComment,
+	Text as DomText,
+	AnyNode as DomNode,
+} from "domhandler";
+import { parseDocument } from "htmlparser2";
+import renderToString from "dom-serializer";
+import { CSS_IDENT, SSR_ID } from "../common/consts";
+
+export class Node {
+	_id!: number;
+	nodeType!: number;
+
+	parent?: Node;
+	childNodes: Node[] = [];
+
+	appendChild(node: Node) {
+		node.parent = this;
+		if (!this.childNodes.includes(node)) this.childNodes.push(node);
+		return node;
+	}
+	append(node: Node) {
+		return this.appendChild(node);
+	}
+
+	removeChild(node: Node) {
+		node.parent = undefined;
+		this.childNodes = this.childNodes.filter((x) => x !== node);
+	}
+
+	insertBefore(node: Node, anchor: Node) {
+		this.removeChild(node);
+		node.parent = this;
+		this.childNodes.splice(
+			this.childNodes.findIndex((x) => x === anchor),
+			0,
+			node
+		);
+	}
+
+	toStandard(): DomNode {
+		return null!;
+	}
+
+	get parentNode() {
+		return this.parent;
+	}
+
+	get firstChild() {
+		return this.childNodes[0];
+	}
+
+	get nextSibling() {
+		let self = this.parent?.childNodes?.findIndex((x) => x === this);
+		return this.parent?.childNodes[self! + 1];
+	}
+}
+
+class ClassList extends Array {
+	constructor() {
+		super();
+	}
+
+	add(...classes: string[]) {
+		this.push(...classes.filter((x) => !this.includes(x)));
+	}
+	remove(...classes: string[]) {
+		for (let cls of classes) {
+			let idx = this.findIndex((x) => x === cls);
+			if (idx !== -1) this.splice(idx, 1);
+		}
+	}
+
+	empty(): boolean {
+		return this.length == 0;
+	}
+
+	toString(): string {
+		return this.join(" ");
+	}
+
+	_replace(classes: string[]) {
+		this.splice(0, this.length, ...classes);
+	}
+}
+
+export class Element extends Node {
+	nodeType: number = 1;
+
+	namespace?: string;
+
+	type: string;
+	attributes: Map<string, string> = new Map();
+	classList = new ClassList();
+
+	component: ComponentContext<any> | undefined;
+
+	style = new CSSOM.CSSStyleDeclaration();
+
+	constructor(type: string, namespace?: string) {
+		super();
+
+		this.type = type;
+		this.namespace = namespace;
+	}
+
+	addEventListener() {}
+
+	setAttribute(key: string, value: any) {
+		if (key === "class") this.classList._replace(value.split(" "));
+		this.attributes.set(key, "" + value);
+	}
+	removeAttribute(key: string) {
+		if (key === "class") this.classList._replace([]);
+		this.attributes.delete(key);
+	}
+
+	replaceWith(el: Element) {
+		if (!this.parent) throw new Error("element has no parent");
+		let idx = this.parent.childNodes.findIndex((x) => x === this);
+		this.parent.childNodes[idx] = el;
+	}
+
+	get $() {
+		return this.component;
+	}
+
+	set $(value: any) {
+		this.component = value;
+	}
+
+	get innerHTML() {
+		return renderToString(this.childNodes.map((x) => x.toStandard()));
+	}
+	set innerHTML(value: string) {
+		let parsed = parseDocument(value);
+		this.childNodes = parsed.childNodes.map((node) =>
+			fromDomhandler(node, this)
+		);
+	}
+
+	set innerText(value: string) {
+		this.childNodes = [new Text(value)];
+	}
+
+	toStandard(): DomElement {
+		if (this.style.cssText) {
+			this.attributes.set("style", this.style.cssText);
+		}
+
+		let el = new DomElement(this.type, {
+			...Object.fromEntries(this.attributes.entries()),
+			...(this.classList.empty() ? {} : { class: this.classList.toString() }),
+		});
+		el.namespace = this.namespace;
+		el.children = this.childNodes.map((x) => {
+			let child = x.toStandard();
+			child.parent = el;
+			return child;
+		});
+		return el;
+	}
+}
+
+function fromDomhandler(node: DomNode, parent: Node): Node {
+	let newNode: Node;
+	if (node.type === "text") {
+		newNode = new Text((node as DomText).data);
+	} else if (node.type === "comment") {
+		newNode = new Comment((node as DomComment).data);
+	} else if (node.type === "tag") {
+		const element = new Element((node as DomElement).name);
+		for (const key in (node as DomElement).attribs) {
+			element.setAttribute(key, (node as DomElement).attribs[key]);
+		}
+		for (const child of (node as DomElement).childNodes) {
+			element.appendChild(fromDomhandler(child, element));
+		}
+		newNode = element;
+	} else {
+		newNode = new Node();
+	}
+	newNode.parent = parent;
+	return newNode;
+}
+
+export class Style extends Element {
+	constructor() {
+		super("style");
+	}
+
+	sheet = new CSSOM.CSSStyleSheet();
+
+	set innerText(value: string) {
+		this.sheet = CSSOM.parse(value);
+	}
+
+	toStandard(): DomElement {
+		this.childNodes = [new Text(this.sheet.toString())];
+		return super.toStandard();
+	}
+}
+
+export class Comment extends Node {
+	nodeType: number = 8;
+	data: string;
+
+	constructor(text: string) {
+		super();
+
+		this.data = text;
+	}
+
+	toStandard(): DomComment {
+		return new DomComment(this.data);
+	}
+}
+
+export class Text extends Node {
+	nodeType: number = 3;
+
+	data: string;
+
+	constructor(text: string) {
+		super();
+
+		this.data = text;
+	}
+
+	toStandard(): DomText {
+		return new DomText(this.data);
+	}
+}
+
+export let newVDom = () => {
+	let elArr: Node[] = [];
+	let push = (el: Node) => {
+		let i = elArr.push(el) - 1;
+		el._id = i;
+		if (el instanceof Element) el.setAttribute(SSR_ID, "" + i);
+		return el;
+	};
+
+	let identArr: Map<number, string> = new Map();
+
+	let promises: (Promise<any> | any)[] = [];
+
+	return [
+		{
+			createElement(type: string) {
+				return push(type === "style" ? new Style() : new Element(type));
+			},
+			createElementNS(ns: string, type: string) {
+				return push(new Element(type, ns));
+			},
+
+			elArr,
+			identArr,
+
+			promises,
+
+			head: new Element("head"),
+		},
+		Node,
+		(text?: any) => push(new Text("" + text)),
+		(text?: any) => push(new Comment("" + text)),
+		() => {
+			let ret = "" + identArr.size;
+			identArr.set(elArr.length, ret);
+			return ret;
+		},
+		new Map(),
+		undefined, // enables "ssr mode"
+		undefined,
+		undefined,
+		promises,
+		promises,
+	] as const satisfies DomImpl;
+};

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

@@ -0,0 +1,10 @@
+export {
+	serializeState,
+	deserializeState,
+	createStore,
+	saveAllStores,
+	StoreSyncBacking,
+	StoreAsyncBacking,
+	StoreAsyncOptions,
+	StoreSyncOptions,
+} from "./store";

package/source/external/dreamlandjs/src/util/store.ts

@@ -0,0 +1,134 @@
+import { Stateful, createState, isStateful, stateListen } from "dreamland/core";
+
+let DLS_TY = "__dls_ty";
+let LOCALSTORAGE = globalThis.localStorage || {};
+
+export let serializeState = (state: Stateful<any>): any => {
+	let set = new Set([state]);
+	return JSON.stringify(state, (_, v) => {
+		if (set.has(v)) return v;
+
+		if (isStateful(v)) {
+			set.add(v);
+			return { [DLS_TY]: "s", v };
+		}
+
+		return v;
+	});
+};
+
+export let deserializeState = (saved: any): Stateful<any> => {
+	return createState(
+		JSON.parse(saved, (_, v) => {
+			if (v && typeof v === "object" && DLS_TY in v) {
+				if (v[DLS_TY] == "s") {
+					return createState(v.v);
+				}
+			}
+			return v;
+		})
+	);
+};
+
+export type StoreSyncBacking = {
+	read: (ident: string) => string | undefined;
+	write: (ident: string, data: string) => void;
+};
+export type StoreAsyncBacking = {
+	read: (ident: string) => Promise<string | undefined>;
+	write: (ident: string, data: string) => Promise<void>;
+};
+export type StoreSyncOptions = {
+	ident: string;
+	backing: "localstorage" | StoreSyncBacking | StoreAsyncBacking;
+	autosave: "auto" | "manual" | "beforeunload";
+};
+export type StoreAsyncOptions = {
+	ident: string;
+	backing: StoreAsyncBacking;
+	autosave: "auto" | "manual" | "beforeunload";
+};
+
+let saveDelegates: (() => void)[] = [];
+
+function _createStore<T extends object>(
+	target: T,
+	options: StoreAsyncOptions
+): Promise<Stateful<T>>;
+function _createStore<T extends object>(
+	target: T,
+	options: StoreSyncOptions
+): Stateful<T>;
+function _createStore<T extends object>(
+	target: T,
+	{ ident, backing, autosave }: StoreAsyncOptions | StoreSyncOptions
+): Stateful<T> | Promise<Stateful<T>> {
+	ident = "dls-" + ident;
+
+	if (backing === "localstorage") {
+		backing = {
+			read: (ident) => LOCALSTORAGE[ident],
+			write: (ident, data) => (LOCALSTORAGE[ident] = data),
+		};
+	}
+
+	let isAuto = autosave === "auto";
+	let last = "";
+	let saving: Promise<void> | undefined;
+	let asyncSave = async () => {
+		await saving;
+
+		let serialized = serializeState(target);
+		if (serialized === last) return;
+		dev: {
+			console.info("[dreamland.js]: saving " + ident);
+		}
+		await backing.write(ident, serialized);
+		last = serialized;
+	};
+	let save = () => {
+		saving = asyncSave();
+	};
+
+	let saveHook = (value: any) => {
+		if (isStateful(value) && isAuto) stateListen(value, saveHook);
+		save();
+	};
+
+	let deepMerge = (target: object, source: any) => {
+		for (let key in source) {
+			let val = source[key];
+			if (isStateful(val) && isAuto) stateListen(val, saveHook);
+			if (val instanceof Object && key in target) {
+				Object.assign(val, deepMerge((target as any)[key], val));
+			}
+		}
+
+		Object.assign(target, source);
+	};
+
+	let finish = (data?: string): Stateful<T> => {
+		if (data) {
+			deepMerge(target, deserializeState(data));
+		}
+
+		let state = createState(target);
+		saveDelegates.push(save);
+
+		if (isAuto) {
+			stateListen(state, saveHook);
+		} else if (autosave === "beforeunload") {
+			globalThis?.addEventListener(autosave, save);
+		}
+
+		return state;
+	};
+
+	let data = backing.read(ident);
+	return data instanceof Promise ? data.then(finish) : finish(data);
+}
+export let createStore = _createStore;
+
+export let saveAllStores = () => {
+	saveDelegates.forEach((cb) => cb());
+};

package/source/external/dreamlandjs/src/vite/css-minifier.ts

@@ -0,0 +1,222 @@
+import type { Plugin } from "vite";
+import { transform } from "lightningcss";
+import MagicString from "magic-string";
+import type { FilterPattern } from "vite";
+import { createFilter } from "vite";
+
+export type CssMinifierOptions = {
+	include?: FilterPattern;
+	exclude?: FilterPattern;
+};
+
+export let cssMinifier = (options: CssMinifierOptions = {}): Plugin => {
+	let filter = createFilter(
+		options.include || ["**/*.tsx", "**/*.ts", "**/*.jsx", "**/*.js"],
+		options.exclude
+	);
+
+	return {
+		name: "dreamland/vite/css-minifier",
+		transform(code, id) {
+			if (!filter(id)) return;
+			if (!code.includes("css`") && !/css\s+`/.test(code)) return;
+
+			let s: MagicString | undefined;
+
+			// find css`...` tagged template literals
+			// we scan character by character to correctly handle nesting
+			for (let i = 0; i < code.length; i++) {
+				// skip strings
+				if (code[i] === '"' || code[i] === "'") {
+					let quote = code[i];
+					i++;
+					while (i < code.length && code[i] !== quote) {
+						if (code[i] === "\\") i++;
+						i++;
+					}
+					continue;
+				}
+
+				// skip line comments
+				if (code[i] === "/" && code[i + 1] === "/") {
+					i = code.indexOf("\n", i);
+					if (i === -1) break;
+					continue;
+				}
+
+				// skip block comments
+				if (code[i] === "/" && code[i + 1] === "*") {
+					i = code.indexOf("*/", i + 2);
+					if (i === -1) break;
+					i++;
+					continue;
+				}
+
+				// look for css` or css ` (TypeScript may insert whitespace)
+				if (code[i] === "c" && code[i + 1] === "s" && code[i + 2] === "s") {
+					// make sure "css" is not part of a larger identifier
+					if (i > 0 && /[a-zA-Z0-9_$]/.test(code[i - 1])) continue;
+
+					// skip optional whitespace between css and backtick
+					let backtickStart = i + 3;
+					while (
+						backtickStart < code.length &&
+						(code[backtickStart] === " " ||
+							code[backtickStart] === "\t" ||
+							code[backtickStart] === "\n" ||
+							code[backtickStart] === "\r")
+					) {
+						backtickStart++;
+					}
+					if (code[backtickStart] !== "`") continue;
+
+					// parse the template literal, collecting quasis and expression ranges
+					let quasis: { start: number; end: number }[] = [];
+					let quasiStart = backtickStart + 1; // after opening backtick
+					let j = quasiStart;
+					let depth = 0;
+
+					while (j < code.length) {
+						if (code[j] === "\\" && j + 1 < code.length) {
+							j += 2;
+							continue;
+						}
+
+						if (depth === 0) {
+							if (code[j] === "`") {
+								// end of template literal
+								quasis.push({ start: quasiStart, end: j });
+								break;
+							}
+							if (code[j] === "$" && code[j + 1] === "{") {
+								quasis.push({ start: quasiStart, end: j });
+								depth = 1;
+								j += 2;
+								continue;
+							}
+						} else {
+							if (code[j] === "{") {
+								depth++;
+							} else if (code[j] === "}") {
+								depth--;
+								if (depth === 0) {
+									quasiStart = j + 1;
+								}
+							} else if (code[j] === "`") {
+								// nested template literal inside expression
+								j++;
+								let nestedDepth = 0;
+								while (j < code.length) {
+									if (code[j] === "\\" && j + 1 < code.length) {
+										j += 2;
+										continue;
+									}
+									if (
+										code[j] === "$" &&
+										code[j + 1] === "{" &&
+										nestedDepth === 0
+									) {
+										nestedDepth = 1;
+										j += 2;
+										continue;
+									}
+									if (code[j] === "{" && nestedDepth > 0) {
+										nestedDepth++;
+										j++;
+										continue;
+									}
+									if (code[j] === "}" && nestedDepth > 0) {
+										nestedDepth--;
+										j++;
+										continue;
+									}
+									if (code[j] === "`" && nestedDepth === 0) {
+										break;
+									}
+									j++;
+								}
+							} else if (code[j] === '"' || code[j] === "'") {
+								let q = code[j];
+								j++;
+								while (j < code.length && code[j] !== q) {
+									if (code[j] === "\\") j++;
+									j++;
+								}
+							}
+						}
+						j++;
+					}
+
+					if (quasis.length === 0) continue;
+
+					// build a combined CSS string with placeholders for expressions
+					// use an identifier placeholder that lightningcss won't strip (unlike comments)
+					let PLACEHOLDER = "__DLEXPR__";
+					let combined = quasis
+						.map((q) => code.slice(q.start, q.end))
+						.join(PLACEHOLDER);
+
+					// minify with lightningcss
+					try {
+						let result = transform({
+							filename: id,
+							code: Buffer.from(combined),
+							minify: true,
+						});
+						let minified = result.code.toString();
+
+						// split back on placeholders
+						let parts = minified.split(PLACEHOLDER);
+						if (parts.length !== quasis.length) {
+							// lightningcss removed or merged a placeholder;
+							// skip this literal to avoid corruption
+							let line = code.slice(0, backtickStart).split("\n").length;
+							this.warn(
+								`css\` literal could not be minified: placeholder count mismatch (expected ${quasis.length}, got ${parts.length})`,
+								{ line, column: 0 }
+							);
+							i = j;
+							continue;
+						}
+
+						// check if anything actually changed
+						let changed = false;
+						for (let k = 0; k < quasis.length; k++) {
+							if (parts[k] !== code.slice(quasis[k].start, quasis[k].end)) {
+								changed = true;
+								break;
+							}
+						}
+						if (!changed) {
+							i = j;
+							continue;
+						}
+
+						if (!s) s = new MagicString(code);
+
+						for (let k = 0; k < quasis.length; k++) {
+							let orig = code.slice(quasis[k].start, quasis[k].end);
+							if (parts[k] !== orig) {
+								s.overwrite(quasis[k].start, quasis[k].end, parts[k]);
+							}
+						}
+					} catch (e) {
+						let line = code.slice(0, backtickStart).split("\n").length;
+						this.warn(
+							`css\` literal could not be minified: ${e instanceof Error ? e.message : e}`,
+							{ line, column: 0 }
+						);
+					}
+
+					i = j;
+				}
+			}
+
+			if (!s) return;
+			return {
+				code: s.toString(),
+				map: s.generateMap({ hires: true }),
+			};
+		},
+	};
+};

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

@@ -0,0 +1,60 @@
+import type { Plugin, PluginOption, UserConfig } from "vite";
+import renderToString, { DomSerializerOptions } from "dom-serializer";
+import type { RenderedComponent } from "dreamland/ssr/server";
+
+export { cssMinifier } from "./css-minifier";
+export type { CssMinifierOptions } from "./css-minifier";
+
+export let jsxPlugin = (): Plugin => ({
+	name: "dreamland/vite/jsx",
+	config(config: UserConfig) {
+		config.esbuild ||= {};
+		config.esbuild.jsx = "automatic";
+		config.esbuild.jsxImportSource = "dreamland";
+	},
+});
+
+export let renderSsr = async (
+	html: string,
+	render: () => Promise<RenderedComponent> | RenderedComponent,
+	transform?: (html: string) => Promise<string> | string
+): Promise<string> => {
+	if (transform) html = await transform(html);
+
+	let cfg: DomSerializerOptions = {
+		encodeEntities: "utf8",
+		decodeEntities: false,
+	};
+	let dom = await render();
+	let head = renderToString([dom.data, ...dom.head], cfg);
+	let body = renderToString(dom.component, cfg);
+
+	return html.replace(`<!--ssr-head-->`, head).replace(`<!--ssr-body-->`, body);
+};
+
+export type DevSsrPluginOptions = {
+	entry: string;
+	transform?: (html: string) => string;
+};
+let _devSsr = (options: DevSsrPluginOptions): PluginOption => ({
+	name: "dreamland/vite/dev-ssr",
+	apply: "serve",
+	async transformIndexHtml(input, ctx) {
+		let server = ctx.server!;
+		try {
+			let entry = await server.ssrLoadModule(options.entry);
+			let html = await renderSsr(
+				input,
+				() => entry.default(ctx.originalUrl!),
+				options.transform
+			);
+
+			return html;
+		} catch (e) {
+			server.ssrFixStacktrace(e as Error);
+			throw e;
+		}
+	},
+});
+// vite types are broken
+export let devSsr: (options: DevSsrPluginOptions) => any = _devSsr;

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

@@ -0,0 +1,7 @@
+{
+	"compilerOptions": {
+		"lib": ["ES2022"]
+	},
+	"include": ["."],
+	"extends": "../../tsconfig.json"
+}