Jacob Schneider J-Cake

An absolutely tiny JSX runtime.

Drop this into your project and import, and you have a simple JSX runtime. It's very bare-bones but does have a reactive mechanism.

import * as dom from './jsx.js';
import {JSX} from './jsx.js';

dom.renderer(document.querySelector("#root")!, <div>

I hate dependencies. Here's a router that you can copy+paste into your code. Does it have all the features? No. Does it do X? Fuck off. It's a simple router. Take it. Enjoy it.

Usage

import Router, {RouterView, Link} from './router.js';

export default function App() {
 return &lt;&gt;

Test Runner

The NodeJS test runner is kinda whacky. This one is a simple test runner which makes your life easy.

Invoking the test runner is simple:

find ./test -iname *.test.js | xargs -d \\n -I {} node runner.js {}

JCake's Error Macro

I like the ? syntax a lot because it is very readable and delegates errors nicely but it often becomes unwieldly because ? only coerces between like-typed error types. If you define a type which contains each error type and the necessary impls for automatic type coercion, your life becomes much easier. This macro does that. You define a list of all possible error types, and this macro spits out a system which you need only import.

Here a code example:

pub mod error;

Rendering text

Easy peasy....

mod text;

let mut ctx = raqote::DrawTarget::new(720, 480);
let buffer = text::text(&text::TextProps { text: format!("Hello World"), size: 14 });

	use std::fs::{File, OpenOptions};
	use std::io;
	use std::os::fd::{AsRawFd, FromRawFd, RawFd};
	use syscall::PAGE_SIZE;

	fn main() {
	let file = syscall::open(std::env::args().skip(1).next().unwrap(), syscall::O_CLOEXEC \| syscall::O_NONBLOCK \| syscall::O_RDWR)
	.map(\|socket\| {
	unsafe { File::from_raw_fd(socket as RawFd) }
	}).unwrap();

	<!DOCTYPE html>
	<html>
	<head>
	<style>
	pre, pre code {
	font-family: sans-serif;
	}
	</style>
	<meta charset="utf-8"/>
	<meta name="viewport" content="width=device-width,initial-scale=1.0"/>

	import fs from 'fs';
	import cp from 'child_process';
	import readline from 'readline';

	export enum Status {
	Success = 0,
	Unauthorised,
	Nonexistent,
	Invalid

	type Option<Parser extends (arg: string) => any> =
	({ long?: string, short: string } \| { long: string, short?: string })
	& { format?: Parser, default?: ReturnType<Parser>, description?: string };

	export type Parameters<Names extends { [name: string]: any }> = { [name in keyof Names]: Option<Names[name]> };

	export type Options<Main, Names extends { [name: string]: any }, Config extends Parameters<Names>> = { default: Main }
	& { [Parameter in keyof Config]: Config[Parameter] extends Option<(arg: string) => infer Type> ? Type : boolean };

	export default function parse<Main, Names extends { [name: string]: any }>(parameters: Parameters<Names>, main?: (arg: string) => Main): (args: string[]) => Options<Main, Names, typeof parameters> {

	export function toPromise<ReturnType extends any[], ArgTypes extends any[]>(callbackFn: (...args: [...ArgTypes, (err: any, ...data: ReturnType) => void]) => void): (...args: ArgTypes) => Promise<ReturnType> {
	return function (...args: ArgTypes): Promise<ReturnType> {
	return new Promise(function (resolve) {
	callbackFn(...args, (err: any, ...data: ReturnType) => resolve(data));
	});
	};
	}