Import existing code as-is

1 files changed, 304 insertions, 0 deletions

diff --git a/src/sjs.js b/src/sjs.js
new file mode 100644
index 0000000..799f964
--- /dev/null
+++ b/src/sjs.js
@@ -0,0 +1,304 @@
+export const getIn = (obj, path) =>
+	path.length === 0
+		? obj
+		: getIn(obj?.[path[0]], path.slice(1));
+
+export const merge = (lhs, rhs) => {
+	if (lhs === undefined) {
+		return rhs;
+	}
+
+	if (rhs === undefined) {
+		return lfs;
+	}
+
+	if (typeof lhs !== "object") {
+		return rhs;
+	}
+
+	const lkeys = Object.keys(lhs);
+	const rkeys = Object.keys(rhs);
+	const allKeys = lkeys.concat(rkeys);
+	return [...new Set(allKeys)].reduce(
+		(o, key) => ({ ...o, [key]: merge(lhs[key], rhs[key]) }),
+		{},
+	);
+};
+
+export const compareObject = (lhs, rhs) => {
+	const lstr = Object.entries(lhs).toSorted();
+	const rstr = Object.entries(rhs).toSorted();
+
+	if (lstr < rstr) {
+		return -1;
+	}
+
+	if (lstr > rstr) {
+		return 1;
+	}
+
+	throw new Error("unreachable");
+};
+
+const FROM = /[&<>'"]/g;
+
+const ESCAPES = {
+	'&': '&amp;',
+	'<': '&lt;',
+	'>': '&gt;',
+	"'": '&#39;',
+	'"': '&quot;'
+};
+
+const mappingFn = c => ESCAPES[c];
+
+export const escape = s =>
+	String.prototype.replace.call(s, FROM, mappingFn);
+
+export const eq = (a, b) => {
+	if (a === b) {
+		return true;
+	}
+
+	if (a === null || b === null) {
+		return false;
+	}
+
+	if (typeof a != "object" || typeof b != "object") {
+		return false;
+	}
+
+	if (Array.isArray(a) !== Array.isArray(b)) {
+		return false;
+	}
+
+	if (Object.keys(a).length !== Object.keys(b).length) {
+		return false;
+	}
+
+	for (const k in a) {
+		if (!b.hasOwnProperty(k)) {
+			return false;
+		}
+		if (!eq(a[k], b[k])) {
+			return false;
+		}
+	}
+	return true;
+};
+
+export const keys = (ks, obj) =>
+	ks.reduce(
+		(ret, k) =>
+			obj.hasOwnProperty(k) ?  {...ret, [k]: obj[k]} : ret,
+		{},
+	);
+
+export const difference = (a, b) => {
+	const diff = new Set(a);
+	for (const el of b) {
+		diff.delete(el);
+	}
+	return diff;
+};
+
+export const assocIn = (obj, path, value) =>
+	path.length === 0 ?  obj :
+		path.length === 1 ? { ...obj, [path[0]]: value } :
+			{
+				...obj,
+				[path[0]]: assocIn(
+					(obj[path[0]] || {}),
+					path.slice(1),
+					value
+				)
+			};
+
+export const dissoc = (obj, key) => {
+	const ret = { ...obj };
+	delete ret[key]
+	return ret;
+};
+
+export const findFirst = (arr, fn) => {
+	for (const x of arr) {
+		const ret = fn(x);
+		if (ret) {
+			return ret;
+		}
+	}
+
+	return null;
+};
+
+export const partial = (fn, ...startArgs) =>
+	(...endArgs) =>
+		fn(...startArgs, ...endArgs);
+
+export const strSortFn = (a, b) => a.localeCompare(b, "POSIX");
+
+export const undefinedAsNull = x => x === undefined ? null : x;
+
+export const first   = a => a[0];
+export const rest    = a => a.slice(1);
+export const butlast = a => a.slice(a, a.length - 1);
+export const last    = a => a[a.length - 1];
+
+export const take = function*(n, gen) {
+	let i = 0n;
+	for (const x of gen) {
+		if (i >= n) {
+			break;
+		}
+		i++;
+		yield x;
+	}
+};
+
+export const range = function*(x, y, step = 1n) {
+	if (x === undefined) {
+		let i = 0n;
+		while (true) {
+			yield i++;
+		}
+	}
+	const [from, to] = y === undefined ?
+		[0n, x] :
+		[x, y];
+	const fromn = BigInt(from);
+	const ton   = BigInt(to);
+	const stepn = BigInt(step);
+	if (stepn === 0n) {
+		while (true) {
+			yield fromn;
+		}
+	}
+	if (step < 0n) {
+		for (let i = fromn; i > ton; i+= stepn) {
+			yield i;
+		}
+	} else {
+		for (let i = fromn; i < ton; i += stepn) {
+			yield i;
+		}
+	}
+};
+
+const t = ({ colors, err, assertEq }) => ({
+	assertEq,
+	tap: x => {
+		err(`tap: ${x}\n`);
+		return x;
+	},
+	start: msg => {
+		err(`${msg}:\n`);
+	},
+	testing: async (msg, fn) => {
+		err(`${colors.yellow("testing")}: ${msg}... `);
+		try {
+			await fn();
+		} catch (e) {
+			err(`${colors.red("ERR")}.\n`);
+			throw e;
+		}
+		err(`${colors.green("OK")}.\n`);
+	},
+});
+
+class UnimplementedError extends Error {}
+
+export const getJSImpl = () => {
+	if (typeof scriptArgs !== "undefined") {
+		return "qjs";
+	}
+	if (typeof Deno !== "undefined") {
+		return "deno";
+	}
+	if (typeof process !== "undefined") {
+		return "node";
+	}
+	// FIXME: add browser and bun
+	return "unknown";
+};
+
+export const JSImpl = getJSImpl();
+
+const mappings = {
+	ARGV: {
+		qjs: () => scriptArgs,
+		node: () => process.argv.slice(1),
+		deno: () => Deno.mainModule.substring("file://".length),
+		unknown: () => {
+			throw new UnimplementedError(`ARGV["${JSImpl}"]`);
+		},
+	},
+	exit: {
+		qjs: async () => {
+			const { exit } = await import("std");
+			return exit;
+		},
+		node: async () => process.exit,
+		deno: async () => Deno.exit,
+		unknown: () => {
+			throw new UnimplementedError(`exit["${JSImpl}"]`);
+		},
+	},
+	tconf: {
+		qjs:  async () => await mappings.testConf.unknown(),
+		deno: async () => await mappings.testConf.node(),
+		browser: async () => {
+			class DOMAssertionError extends Error {}
+
+			const w = s => document.querySelector("#test-report").innerHTML += s;
+
+			const red    = s => `<span style="color: red;          ">${s}</span>`;
+			const green  = s => `<span style="color: green;        ">${s}</span>`;
+			const yellow = s => `<span style="color: darkgoldenrod;">${s}</span>`;
+			return {
+				testStart: msg => w(`${msg}:\n`),
+				testing: msg => w(`${yellow("testing")}: ${msg}...`),
+				testOK: () => w(` ${green("OK")}.\n`),
+				assert: (x, msg = "") => {
+					if (!x) {
+						w(` ${red("ERROR")}.\n`);
+						w("\nSee console for details.\n");
+						w("If possible, do report them.");
+						throw new DOMAssertionError(msg);
+					}
+				},
+			};
+		},
+
+		node: async () => {
+			const assert  = await import("node:assert/strict");
+			const process = await import("node:process");
+
+			const err = x => process.stderr.write(x);
+			const red    = s => `\x1b[31m${s}\x1b[0m`;
+			const green  = s => `\x1b[32m${s}\x1b[0m`;
+			const yellow = s => `\x1b[33m${s}\x1b[0m`;
+
+			return {
+				err,
+				assertEq: assert.deepEqual,
+				colors: {
+					red,
+					green,
+					yellow,
+				},
+			};
+		},
+		unknown: () => { throw new UnimplementedError(`exit["${JSImpl}"]`); },
+	},
+};
+
+export const exit  = await mappings.exit[ JSImpl]();
+export const ARGV  = await mappings.ARGV[ JSImpl]();
+export const tconf = await mappings.tconf[JSImpl]();
+
+export const runTests = async tests => {
+	const tFinal = t(tconf);
+	for (const testFn of tests) {
+		await testFn(tFinal);
+	}
+};