@tutao/licc 3.106.4 → 3.106.5

package/lib/Parser.ts

@@ -1,19 +1,146 @@
 export const PRIMITIVES = ["string", "boolean", "number", "bytes", "void"]
 const KOTLIN_KEYWORDS = [
-	"as", "break", "class", "continue", "do", "else", "false", "for", "fun", "if", "in", "interface", "is", "null", "object", "package", "return", "super",
-	"this", "throw", "true", "try", "typealias", "typeof", "val", "var", "when", "while"
+	"as",
+	"break",
+	"class",
+	"continue",
+	"do",
+	"else",
+	"false",
+	"for",
+	"fun",
+	"if",
+	"in",
+	"interface",
+	"is",
+	"null",
+	"object",
+	"package",
+	"return",
+	"super",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typealias",
+	"typeof",
+	"val",
+	"var",
+	"when",
+	"while",
 ]
 const TYPESCRIPT_KEYWORDS = [
-	"var", "const", "let", "break", "return", "case", "catch", "class", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends",
-	"false", "finally", "for", "function", "if", "import", "in", "instanceOf", "new", "null", "return", "super", "switch", "this", "throw", "true", "try",
-	"typeOf", "void", "while", "with"
+	"var",
+	"const",
+	"let",
+	"break",
+	"return",
+	"case",
+	"catch",
+	"class",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceOf",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeOf",
+	"void",
+	"while",
+	"with",
 ]
 const SWIFT_KEYWORDS = [
-	"Class", "deinit", "Enum", "extension", "Func", "import", "Init", "internal", "Let", "operator", "private", "protocol", "public", "static", "struct", "subscript",
-	"typealias", "var", "break", "case", "continue", "default", "do", "else", "fallthrough", "for", "if", "in", "return", "switch", "where", "while",
-	"as", "dynamicType", "false", "is", "nil", "self", "Self", "super", "true", "_COLUMN_", "_FILE_", "_FUNCTION_", "_LINE_",
-	"associativity", "convenience", "dynamic", "didSet", "final", "get", "infix", "inout", "lazy", "left", "mutating", "none", "nonmutating",
-	"optional", "override", "postfix", "precedence", "prefix", "Protocol", "required", "right", "set", "Type", "unowned", "weak", "willSet"
+	"Class",
+	"deinit",
+	"Enum",
+	"extension",
+	"Func",
+	"import",
+	"Init",
+	"internal",
+	"Let",
+	"operator",
+	"private",
+	"protocol",
+	"public",
+	"static",
+	"struct",
+	"subscript",
+	"typealias",
+	"var",
+	"break",
+	"case",
+	"continue",
+	"default",
+	"do",
+	"else",
+	"fallthrough",
+	"for",
+	"if",
+	"in",
+	"return",
+	"switch",
+	"where",
+	"while",
+	"as",
+	"dynamicType",
+	"false",
+	"is",
+	"nil",
+	"self",
+	"Self",
+	"super",
+	"true",
+	"_COLUMN_",
+	"_FILE_",
+	"_FUNCTION_",
+	"_LINE_",
+	"associativity",
+	"convenience",
+	"dynamic",
+	"didSet",
+	"final",
+	"get",
+	"infix",
+	"inout",
+	"lazy",
+	"left",
+	"mutating",
+	"none",
+	"nonmutating",
+	"optional",
+	"override",
+	"postfix",
+	"precedence",
+	"prefix",
+	"Protocol",
+	"required",
+	"right",
+	"set",
+	"Type",
+	"unowned",
+	"weak",
+	"willSet",
 ]
 
 const FORBIDDEN_IDENTIFIERS = new Set([...KOTLIN_KEYWORDS, ...TYPESCRIPT_KEYWORDS, ...SWIFT_KEYWORDS])
@@ -33,14 +160,14 @@ export function parseType(typeString: string): ParsedType {
 	const listMatch = typeString.match(/^\s*List<\s*(.*)\s*>\s*$/)
 	if (listMatch) {
 		const nested = parseType(listMatch[1])
-		return {baseName: "List", generics: [nested], nullable, external: false}
+		return { baseName: "List", generics: [nested], nullable, external: false }
 	}
 
 	const mapMatch = typeString.match(/^\s*Map<\s*(.*?),\s*(.*?)\s*>\s*$/)
 	if (mapMatch) {
 		const nestedKey = parseType(mapMatch[1])
 		const nestedValue = parseType(mapMatch[2])
-		return {baseName: "Map", generics: [nestedKey, nestedValue], nullable, external: false}
+		return { baseName: "Map", generics: [nestedKey, nestedValue], nullable, external: false }
 	}
 
 	// this is a basic type without generic params
@@ -51,7 +178,7 @@ export function parseType(typeString: string): ParsedType {
 		throw new Error(`illegal identifier: "${typeString}"`)
 	}
 
-	return {baseName: typeString, generics: [], external, nullable}
+	return { baseName: typeString, generics: [], external, nullable }
 } // frontend type
 
 /**
@@ -79,4 +206,4 @@ export interface ParsedType {
 	baseName: string
 	// contained generic types, if any
 	generics: ParsedType[]
-}
+}

package/lib/SwiftGenerator.ts

@@ -7,10 +7,10 @@ import {
 	minusculize,
 	RenderedType,
 	StructDefinition,
-	TypeRefDefinition
+	TypeRefDefinition,
 } from "./common.js"
-import {Accumulator} from "./Accumulator.js"
-import {ParsedType, parseType} from "./Parser.js"
+import { Accumulator } from "./Accumulator.js"
+import { ParsedType, parseType } from "./Parser.js"
 
 export class SwiftGenerator implements LangGenerator {
 	handleStructDefinition(definition: StructDefinition): string {
@@ -55,9 +55,7 @@ export class SwiftGenerator implements LangGenerator {
 		const lastArg = args[args.length - 1]
 		for (const argument of args) {
 			const renderedArgument = typeNameSwift(argument.type)
-			const argLine =
-				`_ ${argument.name}: ${renderedArgument.name}` +
-				((argument === lastArg) ? "" : ",")
+			const argLine = `_ ${argument.name}: ${renderedArgument.name}` + (argument === lastArg ? "" : ",")
 			argGenerator.line(argLine)
 		}
 		const renderedReturn = typeNameSwift(methodDefinition.ret)
@@ -83,7 +81,7 @@ export class SwiftGenerator implements LangGenerator {
 			const arg = getArgs(methodName, method)
 			const decodedArgs = []
 			for (let i = 0; i < arg.length; i++) {
-				const {name: argName, type} = arg[i]
+				const { name: argName, type } = arg[i]
 				const renderedArgType = typeNameSwift(type)
 				decodedArgs.push([argName, renderedArgType] as const)
 			}
@@ -120,40 +118,38 @@ export class SwiftGenerator implements LangGenerator {
 	generateGlobalDispatcher(name: string, facadeNames: Array<string>): string {
 		return new Accumulator()
 			.line(`public class ${name} {`)
-			.indented(acc => acc
-				.lines(facadeNames.map(facadeName => `private let ${minusculize(facadeName)}: ${facadeName}ReceiveDispatcher`))
-				.line()
-				.line(`init(`)
-				.indented(acc => acc
-					.lines(
-						facadeNames.map(name => `${minusculize(name)} : ${name}`,),
-						{suffix: ",", trailing: false}
+			.indented((acc) =>
+				acc
+					.lines(facadeNames.map((facadeName) => `private let ${minusculize(facadeName)}: ${facadeName}ReceiveDispatcher`))
+					.line()
+					.line(`init(`)
+					.indented((acc) =>
+						acc.lines(
+							facadeNames.map((name) => `${minusculize(name)} : ${name}`),
+							{ suffix: ",", trailing: false },
+						),
+					)
+					.line(`) {`)
+					.indented((acc) =>
+						acc.lines(facadeNames.map((name) => `self.${minusculize(name)} = ${name}ReceiveDispatcher(facade: ${minusculize(name)})`)),
 					)
-				)
-				.line(`) {`)
-				.indented(acc => acc
-					.lines(facadeNames.map(name =>
-						`self.${minusculize(name)} = ${name}ReceiveDispatcher(facade: ${minusculize(name)})`
-					))
-				)
-				.line(`}`)
-				.line()
-				.line(`func dispatch(facadeName: String, methodName: String, args: Array<String>) async throws -> String {`)
-				.indented(acc => acc
-					.line(`switch facadeName {`)
-					.indented(acc => {
-						for (let facadeName of facadeNames) {
-							acc.line(`case "${facadeName}":`)
-							   .indent()
-							   .line(`return try await self.${minusculize(facadeName)}.dispatch(method: methodName, arg: args)`)
-						}
-						acc.line(`default:`)
-						   .indent()
-						   .line(`fatalError("licc messed up! " + facadeName)`)
-					})
 					.line(`}`)
-				)
-				.line(`}`)
+					.line()
+					.line(`func dispatch(facadeName: String, methodName: String, args: Array<String>) async throws -> String {`)
+					.indented((acc) =>
+						acc
+							.line(`switch facadeName {`)
+							.indented((acc) => {
+								for (let facadeName of facadeNames) {
+									acc.line(`case "${facadeName}":`)
+										.indent()
+										.line(`return try await self.${minusculize(facadeName)}.dispatch(method: methodName, arg: args)`)
+								}
+								acc.line(`default:`).indent().line(`fatalError("licc messed up! " + facadeName)`)
+							})
+							.line(`}`),
+					)
+					.line(`}`),
 			)
 			.line(`}`)
 			.finish()
@@ -185,7 +181,9 @@ export class SwiftGenerator implements LangGenerator {
 			methodBodyAcc.line(`let encodedFacadeName = toJson("${definition.name}")`)
 			methodBodyAcc.line(`let encodedMethodName = toJson("${methodName}")`)
 			if (methodDefinition.ret !== "void") {
-				methodBodyAcc.line(`let returnValue = try await self.transport.sendRequest(requestType: "ipc",  args: [encodedFacadeName, encodedMethodName] + args)`)
+				methodBodyAcc.line(
+					`let returnValue = try await self.transport.sendRequest(requestType: "ipc",  args: [encodedFacadeName, encodedMethodName] + args)`,
+				)
 				methodBodyAcc.line(`return try! JSONDecoder().decode(${typeNameSwift(methodDefinition.ret).name}.self, from: returnValue.data(using: .utf8)!)`)
 			} else {
 				methodBodyAcc.line(`let _ = try await self.transport.sendRequest(requestType: "ipc",  args: [encodedFacadeName, encodedMethodName] + args)`)
@@ -201,7 +199,7 @@ export class SwiftGenerator implements LangGenerator {
 
 	generateExtraFiles(): Record<string, string> {
 		return {
-			"NativeInterface": SwiftGenerator.generateNativeInterface()
+			NativeInterface: SwiftGenerator.generateNativeInterface(),
 		}
 	}
 
@@ -222,11 +220,11 @@ export class SwiftGenerator implements LangGenerator {
 		return null
 	}
 
-	generateEnum({name, values, doc}: EnumDefinition): string {
+	generateEnum({ name, values, doc }: EnumDefinition): string {
 		return new Accumulator()
-			.do(acc => this.generateDocComment(acc, doc))
+			.do((acc) => this.generateDocComment(acc, doc))
 			.line(`public enum ${name}: Int {`)
-			.indented(acc => acc.lines(values.map((value, index) => `case ${value} = ${index}`)))
+			.indented((acc) => acc.lines(values.map((value, index) => `case ${value} = ${index}`)))
 			.line("}")
 			.finish()
 	}
@@ -238,33 +236,33 @@ function typeNameSwift(name: string): RenderedType {
 }
 
 function renderSwiftType(parsed: ParsedType): RenderedType {
-	const {baseName, nullable} = parsed
+	const { baseName, nullable } = parsed
 	switch (baseName) {
 		case "List":
 			const renderedListInner = renderSwiftType(parsed.generics[0])
-			return {externals: renderedListInner.externals, name: maybeNullable(`[${renderedListInner.name}]`, nullable)}
+			return { externals: renderedListInner.externals, name: maybeNullable(`[${renderedListInner.name}]`, nullable) }
 		case "Map":
 			const renderedKey = renderSwiftType(parsed.generics[0])
 			const renderedValue = renderSwiftType(parsed.generics[1])
 			return {
 				externals: [...renderedKey.externals, ...renderedValue.externals],
-				name: maybeNullable(`[${renderedKey.name} : ${renderedValue.name}]`, nullable)
+				name: maybeNullable(`[${renderedKey.name} : ${renderedValue.name}]`, nullable),
 			}
 		case "string":
-			return {externals: [], name: maybeNullable("String", nullable)}
+			return { externals: [], name: maybeNullable("String", nullable) }
 		case "boolean":
-			return {externals: [], name: maybeNullable("Bool", nullable)}
+			return { externals: [], name: maybeNullable("Bool", nullable) }
 		case "number":
-			return {externals: [], name: maybeNullable("Int", nullable)}
+			return { externals: [], name: maybeNullable("Int", nullable) }
 		case "bytes":
-			return {externals: [], name: maybeNullable("DataWrapper", nullable)}
+			return { externals: [], name: maybeNullable("DataWrapper", nullable) }
 		case "void":
-			return {externals: [], name: maybeNullable("Void", nullable)}
+			return { externals: [], name: maybeNullable("Void", nullable) }
 		default:
-			return {externals: [baseName], name: maybeNullable(baseName, nullable)}
+			return { externals: [baseName], name: maybeNullable(baseName, nullable) }
 	}
 }
 
 function maybeNullable(name: string, nullable: boolean) {
 	return nullable ? `${name}?` : name
-}
+}

package/lib/TypescriptGenerator.ts

@@ -1,10 +1,9 @@
-import {Accumulator} from "./Accumulator.js"
-import {EnumDefinition, FacadeDefinition, getArgs, LangGenerator, minusculize, RenderedType, StructDefinition, TypeRefDefinition} from "./common.js"
-import {ParsedType, parseType} from "./Parser.js"
+import { Accumulator } from "./Accumulator.js"
+import { EnumDefinition, 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) {
@@ -50,7 +49,7 @@ export class TypescriptGenerator implements LangGenerator {
 		acc.line(`export interface ${definition.name} {`)
 		let bodyGenerator = acc.indent()
 		for (const [fieldName, fieldType] of Object.entries(definition.fields)) {
-			const {name, externals} = typeNameTypescript(fieldType)
+			const { name, externals } = typeNameTypescript(fieldType)
 			for (const external of externals) {
 				acc.addImport(`import {${external}} from "./${external}.js"`)
 			}
@@ -59,7 +58,6 @@ export class TypescriptGenerator implements LangGenerator {
 		acc.line("}")
 
 		return acc.finish()
-
 	}
 
 	private generateDocComment(acc: Accumulator, comment: string | null | undefined) {
@@ -112,7 +110,7 @@ export class TypescriptGenerator implements LangGenerator {
 			const arg = getArgs(methodName, methodDef)
 			const decodedArgs = []
 			for (let i = 0; i < arg.length; i++) {
-				const {name: argName, type} = arg[i]
+				const { name: argName, type } = arg[i]
 				const renderedArgType = renderTypeAndAddImports(type, acc)
 				decodedArgs.push([argName, renderedArgType] as const)
 			}
@@ -154,62 +152,57 @@ export class TypescriptGenerator implements LangGenerator {
 	}
 
 	generateExtraFiles(): Record<string, string> {
-		return {};
+		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
+		const actualPath = isRelative ? path.relative(path.resolve(outDir), path.resolve(definitionPath, tsPath)) : tsPath
 		acc.line(`export {${definition.name}} from "${actualPath}"`)
 
 		return acc.finish()
 	}
 
-	generateEnum({name, values, doc}: EnumDefinition): string {
+	generateEnum({ name, values, doc }: EnumDefinition): string {
 		return new Accumulator()
-			.do(acc => this.generateDocComment(acc, doc))
+			.do((acc) => this.generateDocComment(acc, doc))
 			.line(`export const enum ${name} {`)
-			.indented(acc => acc.lines(values.map((value, index) => `${value} = ${index},`)))
+			.indented((acc) => acc.lines(values.map((value, index) => `${value} = ${index},`)))
 			.line("}")
 			.finish()
 	}
 }
 
 function renderTypescriptType(parsed: ParsedType): RenderedType {
-	const {baseName, nullable, external} = parsed
+	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)
+				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)
+				name: maybeNullable(`Record<${renderedKey.name}, ${renderedValue.name}>`, nullable),
 			}
 		case "string":
-			return {externals: [], name: maybeNullable("string", nullable)}
+			return { externals: [], name: maybeNullable("string", nullable) }
 		case "boolean":
-			return {externals: [], name: maybeNullable("boolean", nullable)}
+			return { externals: [], name: maybeNullable("boolean", nullable) }
 		case "number":
-			return {externals: [], name: maybeNullable("number", nullable)}
+			return { externals: [], name: maybeNullable("number", nullable) }
 		case "bytes":
-			return {externals: [], name: maybeNullable("Uint8Array", nullable)}
+			return { externals: [], name: maybeNullable("Uint8Array", nullable) }
 		case "void":
-			return {externals: [], name: maybeNullable("void", nullable)}
+			return { externals: [], name: maybeNullable("void", nullable) }
 		default:
-			return {externals: [baseName], name: maybeNullable(baseName, nullable)}
+			return { externals: [baseName], name: maybeNullable(baseName, nullable) }
 	}
 }
 
@@ -228,4 +221,4 @@ function renderTypeAndAddImports(name: string, acc: Accumulator) {
 		acc.addImport(`import {${external}} from "./${external}.js"`)
 	}
 	return rendered.name
-}
+}

package/lib/cli.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import {generate} from "./index.js"
+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"
+import { globby } from "zx"
+import { Platform } from "./common"
+import { Argument, Option, program } from "commander"
 import JSON5 from "json5"
 
 const PLATFORMS: Array<Platform> = ["ios", "web", "android", "desktop"]
@@ -18,17 +18,23 @@ 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.'
+	.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),
 	)
-		.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.")
+	.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) {
@@ -37,7 +43,7 @@ await program
 			// 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> = JSON5.parse(await fs.promises.readFile(confPath, {encoding: "utf-8"}))
+				const relConf: Record<Platform, string> = JSON5.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}`)
@@ -53,12 +59,8 @@ await program
 	.parseAsync(process.argv)
 
 async function run(from_dir: string, conf: Record<Platform, string>): Promise<void> {
-	const inputFiles = await globby(["*/**/*.json", "*/**/*.json5"].map(glob => path.join(process.cwd(), from_dir, glob)))
-	const inputMap = new Map(
-		inputFiles.map((n: string) => (
-			[path.basename(n, n.endsWith("5") ? ".json5" : ".json"), fs.readFileSync(n, "utf8")]
-		))
-	)
+	const inputFiles = await globby(["*/**/*.json", "*/**/*.json5"].map((glob) => path.join(process.cwd(), from_dir, glob)))
+	const inputMap = new Map(inputFiles.map((n: string) => [path.basename(n, n.endsWith("5") ? ".json5" : ".json"), fs.readFileSync(n, "utf8")]))
 
 	// doing it here because some platforms generate into the same dir.
 	for (let outDir of Object.values(conf)) {
@@ -68,7 +70,7 @@ async function run(from_dir: string, conf: Record<Platform, string>): Promise<vo
 	for (let [confPlatform, confOutDir] of Object.entries(conf)) {
 		console.log("generating for", confPlatform, "into", confOutDir)
 		try {
-			await generate(confPlatform as Platform, inputMap, confOutDir,)
+			await generate(confPlatform as Platform, inputMap, confOutDir)
 		} catch (e) {
 			assert(false, `compilation failed with ${e}`)
 		}

package/lib/common.ts

@@ -50,7 +50,7 @@ export interface FacadeDefinition {
 	senders: Array<Platform>
 	receivers: Array<Platform>
 	methods: Record<string, MethodDefinition>
-	doc?: string,
+	doc?: string
 }
 
 export interface TypeRefDefinition {
@@ -66,8 +66,8 @@ export interface MethodDefinition {
 }
 
 export interface EnumDefinition {
-	type: "enum",
-	name: string,
+	type: "enum"
+	name: string
 	values: Array<string>
 	doc?: string
 }
@@ -75,11 +75,11 @@ export interface EnumDefinition {
 export type ArgumentDefinition = Record<string, string>
 
 export interface RenderedType {
-	externals: string[],
+	externals: string[]
 	name: string
 }
 
-export function getArgs(methName: string, methodDef: MethodDefinition): {name: string, type: 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) {
@@ -87,14 +87,14 @@ export function getArgs(methName: string, methodDef: MethodDefinition): {name: s
 		} 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]}
+		return { name: entries[0][0], type: entries[0][1] }
 	})
 }
 
 export function capitalize(input: string): string {
-	return input.replace(/^\w/, c => c.toUpperCase())
+	return input.replace(/^\w/, (c) => c.toUpperCase())
 }
 
 export function minusculize(input: string): string {
-	return input.replace(/^\w/, c => c.toLowerCase())
-}
+	return input.replace(/^\w/, (c) => c.toLowerCase())
+}

package/lib/index.ts

@@ -1,7 +1,7 @@
-import {TypescriptGenerator} from "./TypescriptGenerator.js"
-import {capitalize, EnumDefinition, FacadeDefinition, LangGenerator, Language, Platform, StructDefinition, TypeRefDefinition} from "./common.js"
-import {SwiftGenerator} from "./SwiftGenerator.js"
-import {KotlinGenerator} from "./KotlinGenerator.js"
+import { TypescriptGenerator } from "./TypescriptGenerator.js"
+import { capitalize, EnumDefinition, 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"
 import JSON5 from "json5"
@@ -117,15 +117,15 @@ function getFileExtensionForLang(lang: string): string {
 }
 
 function write(code: string, outDir: string, target: string) {
-	fs.mkdirSync(outDir, {recursive: true})
+	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)
+	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

@@ -1,6 +1,6 @@
 {
 	"name": "@tutao/licc",
-	"version": "3.106.4",
+	"version": "3.106.5",
 	"bin": {
 		"licc": "dist/cli.js"
 	},
@@ -20,7 +20,7 @@
 		"zx": "6.1.0"
 	},
 	"devDependencies": {
-		"@tutao/tutanota-test-utils": "3.106.4",
+		"@tutao/tutanota-test-utils": "3.106.5",
 		"ospec": "https://github.com/tutao/ospec.git#0472107629ede33be4c4d19e89f237a6d7b0cb11"
 	}
 }