@tutao/licc 3.98.2

package/lib/TypescriptGenerator.ts

@@ -0,0 +1,222 @@
+import {Accumulator} from "./Accumulator.js"
+import {FacadeDefinition, getArgs, LangGenerator, minusculize, RenderedType, StructDefinition, TypeRefDefinition} from "./common.js"
+import {ParsedType, parseType} from "./Parser.js"
+import path from "path"
+
+export class TypescriptGenerator implements LangGenerator {
+
+	generateGlobalDispatcher(name: string, facadeNames: Array<string>): string {
+		const acc = new Accumulator()
+		for (let facadeName of facadeNames) {
+			acc.line(`import {${facadeName}} from "./${facadeName}.js"`)
+			acc.line(`import {${facadeName}ReceiveDispatcher} from "./${facadeName}ReceiveDispatcher.js"`)
+		}
+		acc.line()
+		acc.line(`export class ${name} {`)
+		const methodAcc = acc.indent()
+		for (let facadeName of facadeNames) {
+			methodAcc.line(`private readonly ${minusculize(facadeName)} : ${facadeName}ReceiveDispatcher`)
+		}
+		methodAcc.line(`constructor(`)
+		for (let facadeName of facadeNames) {
+			methodAcc.indent().line(`${minusculize(facadeName)} : ${facadeName},`)
+		}
+		methodAcc.line(`) {`)
+		for (let facadeName of facadeNames) {
+			methodAcc.indent().line(`this.${minusculize(facadeName)} = new ${facadeName}ReceiveDispatcher(${minusculize(facadeName)})`)
+		}
+		methodAcc.line("}")
+		methodAcc.line()
+
+		methodAcc.line(`async dispatch(facadeName: string, methodName: string, args: Array<any>) {`)
+		const switchAcc = methodAcc.indent()
+		switchAcc.line(`switch (facadeName) {`)
+		const caseAcc = switchAcc.indent()
+		for (let facadeName of facadeNames) {
+			caseAcc.line(`case "${facadeName}":`)
+			caseAcc.indent().line(`return this.${minusculize(facadeName)}.dispatch(methodName, args)`)
+		}
+		caseAcc.line(`default:`)
+		caseAcc.indent().line(`throw new Error("licc messed up! " + facadeName)`)
+		switchAcc.line(`}`)
+		methodAcc.line(`}`)
+		acc.line(`}`)
+		return acc.finish()
+	}
+
+	handleStructDefinition(definition: StructDefinition): string {
+		let acc = new Accumulator()
+		this.generateDocComment(acc, definition.doc)
+		acc.line(`export interface ${definition.name} {`)
+		let bodyGenerator = acc.indent()
+		for (const [fieldName, fieldType] of Object.entries(definition.fields)) {
+			const {name, externals} = typeNameTypescript(fieldType)
+			for (const external of externals) {
+				acc.addImport(`import {${external}} from "./${external}.js"`)
+			}
+			bodyGenerator.line(`readonly ${fieldName}: ${name}`)
+		}
+		acc.line("}")
+
+		return acc.finish()
+
+	}
+
+	private generateDocComment(acc: Accumulator, comment: string | null | undefined) {
+		if (!comment) return
+
+		acc.line("/**")
+		acc.line(` * ${comment}`)
+		acc.line(" */")
+	}
+
+	private static generateNativeInterface(accumulator: Accumulator) {
+		// Duplicate interface to not import it
+		accumulator.line("interface NativeInterface {")
+		accumulator.indent().line("invokeNative(requestType: string, args: unknown[]): Promise<any>")
+		accumulator.line("}")
+	}
+
+	generateFacade(definition: FacadeDefinition): string {
+		const acc = new Accumulator()
+		this.generateDocComment(acc, definition.doc)
+		acc.line(`export interface ${definition.name} {\n`)
+		let methodAcc = acc.indent()
+		for (const [name, method] of Object.entries(definition.methods)) {
+			this.generateDocComment(methodAcc, method.doc)
+			methodAcc.line(`${name}(`)
+			let argAccumulator = methodAcc.indent()
+			for (const arg of getArgs(name, method)) {
+				const name = renderTypeAndAddImports(arg.type, acc)
+				argAccumulator.line(`${arg.name}: ${name},`)
+			}
+			const resolvedReturnType = renderTypeAndAddImports(method.ret, acc)
+			methodAcc.line(`): Promise<${resolvedReturnType}>`)
+			methodAcc.line()
+		}
+		acc.line("}")
+		return acc.finish()
+	}
+
+	generateReceiveDispatcher(definition: FacadeDefinition): string {
+		const acc = new Accumulator()
+		acc.line(`import {${definition.name}} from "./${definition.name}.js"`)
+		acc.line()
+		acc.line(`export class ${definition.name}ReceiveDispatcher {`)
+		acc.indent().line(`constructor(private readonly facade: ${definition.name}) {}`)
+		acc.indent().line(`async dispatch(method: string, arg: Array<any>) : Promise<any> {`)
+		acc.indent().indent().line(`switch(method) {`)
+		const switchAccumulator = acc.indent().indent().indent()
+		for (const [methodName, methodDef] of Object.entries(definition.methods)) {
+			switchAccumulator.line(`case "${methodName}": {`)
+			const arg = getArgs(methodName, methodDef)
+			const decodedArgs = []
+			for (let i = 0; i < arg.length; i++) {
+				const {name: argName, type} = arg[i]
+				const renderedArgType = renderTypeAndAddImports(type, acc)
+				decodedArgs.push([argName, renderedArgType] as const)
+			}
+
+			for (let i = 0; i < arg.length; i++) {
+				const [argName, renderedType] = decodedArgs[i]
+				switchAccumulator.indent().line(`const ${argName}: ${renderedType} = arg[${i}]`)
+			}
+			switchAccumulator.indent().line(`return this.facade.${methodName}(`)
+			for (let i = 0; i < arg.length; i++) {
+				const [argName] = decodedArgs[i]
+				switchAccumulator.indent().indent().line(`${argName},`)
+			}
+			switchAccumulator.indent().line(`)`)
+			switchAccumulator.line(`}`)
+		}
+		acc.indent().indent().line(`}`)
+		acc.indent().line(`}`)
+		acc.line(`}`)
+		return acc.finish()
+	}
+
+	generateSendDispatcher(definition: FacadeDefinition): string {
+		const acc = new Accumulator()
+		acc.line(`import {${definition.name}} from "./${definition.name}.js"`)
+		acc.line()
+		TypescriptGenerator.generateNativeInterface(acc)
+		acc.line(`export class ${definition.name}SendDispatcher implements ${definition.name} {`)
+		acc.indent().line(`constructor(private readonly transport: NativeInterface) {}`)
+		for (const [methodName, _] of Object.entries(definition.methods)) {
+			const methodAccumulator = acc.indent()
+			methodAccumulator.line(`async ${methodName}(...args: Parameters<${definition.name}["${methodName}"]>) {`)
+			methodAccumulator.indent().line(`return this.transport.invokeNative("ipc",  ["${definition.name}", "${methodName}", ...args])`)
+			methodAccumulator.line(`}`)
+		}
+
+		acc.line(`}`)
+		return acc.finish()
+	}
+
+	generateExtraFiles(): Record<string, string> {
+		return {};
+	}
+
+	generateTypeRef(outDir: string, definitionPath: string, definition: TypeRefDefinition): string {
+		const acc = new Accumulator()
+		let tsPath = definition.location.typescript
+		const isRelative = tsPath.startsWith(".")
+		const actualPath = (isRelative)
+			? path.relative(
+				path.resolve(outDir),
+				path.resolve(definitionPath, tsPath)
+			)
+			: tsPath
+		acc.line(`export {${definition.name}} from "${actualPath}"`)
+
+		return acc.finish()
+	}
+}
+
+function renderTypescriptType(parsed: ParsedType): RenderedType {
+	const {baseName, nullable, external} = parsed
+	switch (baseName) {
+		case "List":
+			const renderedListInner = renderTypescriptType(parsed.generics[0])
+			return {
+				externals: renderedListInner.externals,
+				name: maybeNullable(`ReadonlyArray<${renderedListInner.name}>`, nullable)
+			}
+		case "Map":
+			const renderedKey = renderTypescriptType(parsed.generics[0])
+			const renderedValue = renderTypescriptType(parsed.generics[1])
+			return {
+				externals: [...renderedKey.externals, ...renderedValue.externals],
+				name: maybeNullable(`Record<${renderedKey.name}, ${renderedValue.name}>`, nullable)
+			}
+		case "string":
+			return {externals: [], name: maybeNullable("string", nullable)}
+		case "boolean":
+			return {externals: [], name: maybeNullable("boolean", nullable)}
+		case "number":
+			return {externals: [], name: maybeNullable("number", nullable)}
+		case "bytes":
+			return {externals: [], name: maybeNullable("Uint8Array", nullable)}
+		case "void":
+			return {externals: [], name: maybeNullable("void", nullable)}
+		default:
+			return {externals: [baseName], name: maybeNullable(baseName, nullable)}
+	}
+}
+
+function maybeNullable(name: string, nullable: boolean): string {
+	return nullable ? name + " | null" : name
+}
+
+function typeNameTypescript(name: string): RenderedType {
+	const parsed = parseType(name)
+	return renderTypescriptType(parsed)
+}
+
+function renderTypeAndAddImports(name: string, acc: Accumulator) {
+	const rendered = typeNameTypescript(name)
+	for (const external of rendered.externals) {
+		acc.addImport(`import {${external}} from "./${external}.js"`)
+	}
+	return rendered.name
+}

package/lib/cli.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import {generate} from "./index.js"
+import * as fs from "fs"
+import * as path from "path"
+import {globby} from "zx"
+import {Platform} from "./common"
+import {Argument, Option, program} from "commander"
+
+const PLATFORMS: Array<Platform> = ["ios", "web", "android", "desktop"]
+
+const USAGE = `licc [options] from_dir to_dir
+
+will recursively take all JSON files from \`from-dir\` and compile them.
+output files are written into \`to-dir\`, without preserving subdirectory structure.`
+
+await program
+	.usage(USAGE)
+	.addArgument(new Argument("from_dir").argRequired())
+	.addArgument(new Argument("to_dir").argOptional())
+	.addOption(new Option(
+		'-p, --platform <platform>',
+		'platform to generate code for. if not specified, from_dir must be omitted as well. In this case, licc will read <from_dir>/.liccc as a json map from platform to output dir. if -p is set, from_dir must be set as well.'
+	)
+		.makeOptionMandatory(false)
+		.choices(PLATFORMS))
+	.action(async (from_dir, to_dir, {platform}) => {
+		assert(!(platform == null && to_dir != null),
+			"can't omit platform and use an explicit output dir. specify both -p <platform> and to_dir or none of them.")
+		assert(!(platform != null && to_dir == null),
+			"can't use an explicit platform but no output dir. specify both -p <platform> and to_dir or none of them.")
+
+		let conf: Record<string, string> = {}
+		if (platform != null) {
+			conf[platform] = path.resolve(process.cwd(), to_dir)
+		} else {
+			// check if there's a .liccc file that states the desired platforms and output dirs
+			const confPath = path.join(from_dir, ".liccc")
+			try {
+				const relConf: Record<Platform, string> = JSON.parse(await fs.promises.readFile(confPath, {encoding: "utf-8"}))
+				for (let [relPlatform, relPath] of Object.entries(relConf) as [Platform | "__comment", string][]) {
+					if (relPlatform === "__comment") continue
+					assert(PLATFORMS.includes(relPlatform), `invalid platform in .liccc: ${relPlatform}`)
+					conf[relPlatform] = path.resolve(process.cwd(), from_dir, relPath)
+				}
+			} catch (e) {
+				console.log(`unable to read ${confPath} as JSON: ${e}`)
+				process.exit(1)
+			}
+		}
+		await run(from_dir, conf)
+	})
+	.parseAsync(process.argv)
+
+async function run(from_dir: string, conf: Record<Platform, string>): Promise<void> {
+	const inputFiles = await globby(path.join(process.cwd(), from_dir, "*/**/*.json"))
+	const inputMap = new Map(inputFiles.map((n: string) => (
+		[path.basename(n, ".json"), fs.readFileSync(n, "utf8")]
+	)))
+
+	// doing it here because some platforms generate into the same dir.
+	for (let outDir of Object.values(conf)) {
+		clearDir(outDir)
+	}
+
+	for (let [confPlatform, confOutDir] of Object.entries(conf)) {
+		console.log("generating for", confPlatform, "into", confOutDir)
+		try {
+			await generate(confPlatform as Platform, inputMap, confOutDir,)
+		} catch (e) {
+			assert(false, `compilation failed with ${e}`)
+		}
+		console.log("done; no errors\n")
+	}
+}
+
+function assert(proposition: boolean, text: string): void {
+	if (proposition) return
+	console.log("\nFatal Error:\n", text)
+	console.log("")
+	console.log(program.helpInformation())
+	process.exit(1)
+}
+
+function clearDir(dir: string) {
+	console.log("clearing dir:", dir)
+	try {
+		const files = fs.readdirSync(dir)
+		for (const file of files) {
+			fs.unlinkSync(path.join(dir, file))
+		}
+	} catch (e) {
+		console.log("could not clear dir:", e)
+	}
+}

package/lib/common.ts

@@ -0,0 +1,91 @@
+export interface LangGenerator {
+	/**
+	 * generate a structured type definition
+	 * @param definition
+	 */
+	handleStructDefinition(definition: StructDefinition): string
+
+	/**
+	 * generate a collection of methods with arguments and return types
+	 * and its associated dispatchers
+	 * @param definition
+	 */
+	generateFacade(definition: FacadeDefinition): string
+
+	generateReceiveDispatcher(definition: FacadeDefinition): string
+
+	generateSendDispatcher(definition: FacadeDefinition): string
+
+	/**
+	 * generate the receiving dispatcher for the facades we are on the receiving side of
+	 */
+	generateGlobalDispatcher(name: string, facadeNames: Array<string>): string
+
+	/**
+	 * generate extra type definitions needed to make the interface work
+	 */
+	generateExtraFiles(): Record<string, string>
+
+	/**
+	 * external types that don't get generated but are located somewhere else
+	 */
+	generateTypeRef(outDir: string, definitionPath: string, definition: TypeRefDefinition): string | null
+}
+
+export type Platform = "ios" | "web" | "android" | "desktop"
+export type Language = "kotlin" | "swift" | "typescript"
+
+export interface StructDefinition {
+	type: "struct"
+	name: string
+	fields: Record<string, string>
+	doc?: string
+}
+
+export interface FacadeDefinition {
+	type: "facade"
+	name: string
+	senders: Array<Platform>
+	receivers: Array<Platform>
+	methods: Record<string, MethodDefinition>
+	doc?: string,
+}
+
+export interface TypeRefDefinition {
+	"type": "typeref"
+	"name": string
+	"location": Record<Language, string>
+}
+
+export interface MethodDefinition {
+	arg: Array<ArgumentDefinition>
+	ret: string
+	doc?: string
+}
+
+export type ArgumentDefinition = Record<string, string>
+
+export interface RenderedType {
+	externals: string[],
+	name: string
+}
+
+export function getArgs(methName: string, methodDef: MethodDefinition): {name: string, type: string}[] {
+	return methodDef.arg.map((a, i) => {
+		const entries = Object.entries(a)
+		if (entries.length === 0) {
+			throw new Error(`Syntax Error: method ${methName} argument ${i} is empty`)
+		} else if (entries.length > 1) {
+			throw new Error(`Syntax Error: method ${methName} argument ${i} has too many entries`)
+		}
+		return {"name": entries[0][0], "type": entries[0][1]}
+	})
+}
+
+export function capitalize(input: string): string {
+	return input.replace(/^\w/, c => c.toUpperCase())
+}
+
+export function minusculize(input: string): string {
+	return input.replace(/^\w/, c => c.toLowerCase())
+}

package/lib/index.ts

@@ -0,0 +1,126 @@
+import {TypescriptGenerator} from "./TypescriptGenerator.js"
+import {capitalize, FacadeDefinition, LangGenerator, Language, Platform, StructDefinition, TypeRefDefinition} from "./common.js"
+import {SwiftGenerator} from "./SwiftGenerator.js"
+import {KotlinGenerator} from "./KotlinGenerator.js"
+import * as path from "path"
+import * as fs from "fs"
+
+function generatorForLang(lang: Language): LangGenerator {
+	switch (lang) {
+		case "typescript":
+			return new TypescriptGenerator()
+		case "swift":
+			return new SwiftGenerator()
+		case "kotlin":
+			return new KotlinGenerator()
+		default:
+			throw new Error("Unknown output language:" + lang)
+	}
+}
+
+function mapPlatformToLang(platform: string): Language {
+	switch (platform) {
+		case "ios":
+			return "swift"
+		case "android":
+			return "kotlin"
+		case "web":
+		case "desktop":
+			return "typescript"
+		default:
+			throw new Error("unknown platform " + platform)
+	}
+}
+
+/**
+ * generate and write all target language source files.
+ *
+ * @param platform one of the supported platform names
+ * @param sources a map from the definition file name to the definition json string
+ * @param outDir the directory the output files should be written to
+ */
+export function generate(platform: Platform, sources: Map<string, string>, outDir: string) {
+	const lang = mapPlatformToLang(platform)
+	const ext = getFileExtensionForLang(lang)
+	const generator = generatorForLang(lang)
+	const facadesToImplement: Array<string> = []
+	for (const [inputPath, source] of Array.from(sources.entries())) {
+		console.log("handling ipc schema file", inputPath)
+		const definition = JSON.parse(source) as FacadeDefinition | StructDefinition | TypeRefDefinition
+		if (!("name" in definition)) {
+			throw new Error(`malformed definition: ${inputPath} doesn't have name field`)
+		}
+		if (!("type" in definition)) {
+			throw new Error(`missing type declaration: ${inputPath}`)
+		}
+		switch (definition.type) {
+			case "facade":
+				assertReturnTypesPresent(definition)
+				const isReceiving = definition.receivers.includes(platform)
+				const isSending = definition.senders.includes(platform)
+				if (!isReceiving && !isSending) {
+					continue
+				}
+				const facadeOutput = generator.generateFacade(definition)
+				write(facadeOutput, outDir, definition.name + ext)
+				if (isReceiving) {
+					const receiveOutput = generator.generateReceiveDispatcher(definition)
+					write(receiveOutput, outDir, definition.name + "ReceiveDispatcher" + ext)
+					facadesToImplement.push(definition.name)
+				}
+				if (isSending) {
+					const sendOutput = generator.generateSendDispatcher(definition)
+					write(sendOutput, outDir, definition.name + "SendDispatcher" + ext)
+				}
+				break
+			case "struct":
+				const structOutput = generator.handleStructDefinition(definition)
+				write(structOutput, outDir, definition.name + ext)
+				break
+			case "typeref":
+				const refOutput = generator.generateTypeRef(outDir, inputPath, definition)
+				if (refOutput != null) {
+					write(refOutput, outDir, definition.name + ext)
+				}
+				break
+			default:
+				throw new Error(`unknown definition type in ${inputPath}: ` + (definition as any).type)
+		}
+	}
+
+	const extraFiles = generator.generateExtraFiles()
+	for (let extraFilesKey in extraFiles) {
+		write(extraFiles[extraFilesKey], outDir, extraFilesKey + ext)
+	}
+
+	const dispatcherName = `${capitalize(platform)}GlobalDispatcher`
+	const dispatcherCode = generator.generateGlobalDispatcher(dispatcherName, facadesToImplement)
+	write(dispatcherCode, outDir, dispatcherName + ext)
+}
+
+function getFileExtensionForLang(lang: string): string {
+	switch (lang) {
+		case "typescript":
+			return ".ts"
+		case "swift":
+			return ".swift"
+		case "kotlin":
+			return ".kt"
+		default:
+			throw new Error("unknown output lang: " + lang)
+	}
+}
+
+function write(code: string, outDir: string, target: string) {
+	fs.mkdirSync(outDir, {recursive: true})
+	const filePath = path.join(outDir, target)
+	fs.writeFileSync(filePath, code)
+	console.log("written:", filePath)
+}
+
+function assertReturnTypesPresent(definition: FacadeDefinition): void {
+	const methNoRet = Object.entries(definition.methods).find(([_, {ret}]) => ret == null)
+	if (methNoRet) {
+		throw new Error(`missing return type on method ${methNoRet[0]} in ${definition.name}`)
+	}
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "@tutao/licc",
+	"version": "3.98.2",
+	"bin": {
+		"licc": "dist/cli.js"
+	},
+	"description": "little interface compiler",
+	"main": "index.js",
+	"type": "module",
+	"scripts": {
+		"build": "tsc -b",
+		"test": "rm -rf ./test/build && tsc -b test && cd test/build && node test/Suite.js",
+		"preinstall": "mkdir -p dist && touch dist/cli.js"
+	},
+	"author": "",
+	"license": "GPL-3.0",
+	"dependencies": {
+		"zx": "6.1.0",
+		"commander": "9.3.0"
+	},
+	"devDependencies": {
+		"@tutao/tutanota-test-utils": "3.98.2",
+		"ospec": "https://github.com/tutao/ospec.git#0472107629ede33be4c4d19e89f237a6d7b0cb11"
+	}
+}

package/test/ParserTest.ts

@@ -0,0 +1,124 @@
+import o from "ospec"
+import {ParsedType, parseType} from "../lib/Parser.js"
+import {assertThrows} from "@tutao/tutanota-test-utils"
+
+o.spec('Parser', function () {
+	o.spec("illegal identifiers are caught", function () {
+		o("empty string", async function () {
+			await assertThrows(Error, () => Promise.resolve(parseType("")))
+		})
+
+		o("number at start", async function () {
+			await assertThrows(Error, () => Promise.resolve(parseType("0hello")))
+		})
+
+		o("special character at start", async function () {
+			await assertThrows(Error, () => Promise.resolve(parseType("?some")))
+		})
+	})
+
+	o.spec("simple types are parsed correctly", function () {
+		o("string", async function () {
+			o(parseType("string")).deepEquals({baseName: "string", generics: [], nullable: false, external: false})
+		})
+		o("string?", async function () {
+			o(parseType("string?")).deepEquals({baseName: "string", generics: [], nullable: true, external: false})
+		})
+		o("external type", async function () {
+			o(parseType("SomeExternalType")).deepEquals({baseName: "SomeExternalType", external: true, generics: [], nullable: false})
+		})
+		o("nullable external", async function () {
+			o(parseType("SomeExternalType?")).deepEquals({baseName: "SomeExternalType", external: true, generics: [], nullable: true})
+		})
+
+		o("void", async function () {
+			o(parseType("void ")).deepEquals({baseName: "void", nullable: false, external: false, generics: []})
+		})
+	})
+
+	function stringToTest(typeString: string, expected: ParsedType) {
+		o(`"${typeString}"`, function () {
+			o(parseType(typeString)).deepEquals(expected)
+		})
+	}
+
+	o.spec("list type is parsed correctly", function () {
+		stringToTest("List<boolean>", {
+			baseName: "List",
+			generics: [{baseName: "boolean", nullable: false, generics: [], external: false}],
+			nullable: false,
+			external: false
+		})
+		stringToTest("List<string?>", {
+			baseName: "List",
+			generics: [{baseName: "string", nullable: true, generics: [], external: false}],
+			nullable: false,
+			external: false
+		})
+		stringToTest("List<number>?", {
+			baseName: "List",
+			generics: [{baseName: "number", nullable: false, generics: [], external: false}],
+			nullable: true,
+			external: false
+		})
+		stringToTest("List<List<External?>?>", {
+			baseName: "List",
+			generics: [{
+				baseName: "List", nullable: true, generics: [
+					{baseName: "External", nullable: true, external: true, generics: []}
+				], external: false
+			}],
+			nullable: false,
+			external: false
+		})
+		stringToTest(" List< number > ", {
+			baseName: "List",
+			generics: [{baseName: "number", nullable: false, generics: [], external: false}],
+			nullable: false,
+			external: false
+		})
+	})
+
+	o.spec("map type is parsed correctly", function () {
+		stringToTest("Map<boolean?, Foo>", {
+			baseName: "Map", external: false, generics: [{
+				baseName: 'boolean',
+				generics: [],
+				external: false,
+				nullable: true
+			},
+				{
+					baseName: 'Foo',
+					generics: [],
+					external: true,
+					nullable: false
+				}], nullable: false
+		})
+
+		stringToTest("Map<number, number>?", {
+			baseName: "Map", external: false, generics: [
+				{baseName: "number", nullable: false, external: false, generics: []},
+				{baseName: "number", nullable: false, external: false, generics: []}
+			], nullable: true
+		})
+
+		stringToTest("Map<string, string>", {
+			baseName: "Map", external: false, generics: [
+				{baseName: "string", nullable: false, external: false, generics: []},
+				{baseName: "string", nullable: false, external: false, generics: []}
+			], nullable: false
+		})
+
+		stringToTest("Map<List<number>?, number?>", {
+			baseName: "Map", external: false, generics: [
+				{
+					baseName: "List",
+					generics: [{baseName: "number", nullable: false, generics: [], external: false}],
+					nullable: true,
+					external: false
+				},
+				{baseName: "number", nullable: true, external: false, generics: []}
+			], nullable: false
+		})
+	})
+})

package/test/Suite.ts

@@ -0,0 +1,6 @@
+import o from "ospec"
+import "./ParserTest.js"
+
+(async function () {
+	await o.run()
+})()