@tutao/licc 3.106.4 → 3.107.0

package/dist/Accumulator.js

@@ -3,7 +3,7 @@ export class Accumulator {
     appender;
     code = "";
     imports = new Set();
-    constructor(appender = (code) => this.code += code) {
+    constructor(appender = (code) => (this.code += code)) {
         this.appender = appender;
     }
     line(code = "") {
@@ -17,9 +17,7 @@ export class Accumulator {
         const lineJoiner = opts?.suffix ?? "";
         const trailingJoiner = opts?.trailing ?? false;
         lines.forEach((line, idx) => {
-            const joiner = trailingJoiner || idx < lines.length - 1
-                ? lineJoiner
-                : "";
+            const joiner = trailingJoiner || idx < lines.length - 1 ? lineJoiner : "";
             this.line(line + joiner);
         });
         return this;

package/dist/KotlinGenerator.js

@@ -1,4 +1,4 @@
-import { getArgs, minusculize } from "./common.js";
+import { getArgs, minusculize, } from "./common.js";
 import { Accumulator } from "./Accumulator.js";
 import { parseType } from "./Parser.js";
 export class KotlinGenerator {
@@ -170,7 +170,7 @@ export class KotlinGenerator {
     }
     generateExtraFiles() {
         return {
-            "NativeInterface": KotlinGenerator.generateNativeInterface()
+            NativeInterface: KotlinGenerator.generateNativeInterface(),
         };
     }
     generateTypeRef(outDir, definitionPath, definition) {
@@ -186,9 +186,9 @@ export class KotlinGenerator {
     }
     generateEnum({ name, values, doc }) {
         return new Accumulator()
-            .do(acc => this.generateDocComment(acc, doc))
+            .do((acc) => this.generateDocComment(acc, doc))
             .line(`enum class ${name} {`)
-            .indented(acc => acc.lines(values.map(value => `${value},`)))
+            .indented((acc) => acc.lines(values.map((value) => `${value},`)))
             .line("}")
             .finish();
     }
@@ -204,14 +204,14 @@ function renderKotlinType(parsed) {
             const renderedListInner = renderKotlinType(parsed.generics[0]);
             return {
                 externals: renderedListInner.externals,
-                name: maybeNullable(`List<${renderedListInner.name}>`, nullable)
+                name: maybeNullable(`List<${renderedListInner.name}>`, nullable),
             };
         case "Map":
             const renderedKey = renderKotlinType(parsed.generics[0]);
             const renderedValue = renderKotlinType(parsed.generics[1]);
             return {
                 externals: [...renderedKey.externals, ...renderedValue.externals],
-                name: maybeNullable(`Map<${renderedKey.name}, ${renderedValue.name}>`, nullable)
+                name: maybeNullable(`Map<${renderedKey.name}, ${renderedValue.name}>`, nullable),
             };
         case "string":
             return { externals: [], name: maybeNullable("String", nullable) };

package/dist/Parser.js

@@ -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]);
 /**

package/dist/SwiftGenerator.js

@@ -1,4 +1,4 @@
-import { getArgs, minusculize } from "./common.js";
+import { getArgs, minusculize, } from "./common.js";
 import { Accumulator } from "./Accumulator.js";
 import { parseType } from "./Parser.js";
 export class SwiftGenerator {
@@ -42,8 +42,7 @@ export class SwiftGenerator {
         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);
@@ -104,29 +103,25 @@ export class SwiftGenerator {
     generateGlobalDispatcher(name, facadeNames) {
         return new Accumulator()
             .line(`public class ${name} {`)
-            .indented(acc => acc
-            .lines(facadeNames.map(facadeName => `private let ${minusculize(facadeName)}: ${facadeName}ReceiveDispatcher`))
+            .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((name) => `${minusculize(name)} : ${name}`), { suffix: ",", trailing: false }))
             .line(`) {`)
-            .indented(acc => acc
-            .lines(facadeNames.map(name => `self.${minusculize(name)} = ${name}ReceiveDispatcher(facade: ${minusculize(name)})`)))
+            .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
+            .indented((acc) => acc
             .line(`switch facadeName {`)
-            .indented(acc => {
+            .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)`);
+            acc.line(`default:`).indent().line(`fatalError("licc messed up! " + facadeName)`);
         })
             .line(`}`))
             .line(`}`))
@@ -174,7 +169,7 @@ export class SwiftGenerator {
     }
     generateExtraFiles() {
         return {
-            "NativeInterface": SwiftGenerator.generateNativeInterface()
+            NativeInterface: SwiftGenerator.generateNativeInterface(),
         };
     }
     static generateNativeInterface() {
@@ -194,9 +189,9 @@ export class SwiftGenerator {
     }
     generateEnum({ name, values, doc }) {
         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();
     }
@@ -216,7 +211,7 @@ function renderSwiftType(parsed) {
             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) };

package/dist/TypescriptGenerator.js

@@ -146,17 +146,15 @@ export class TypescriptGenerator {
         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 }) {
         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();
     }
@@ -168,14 +166,14 @@ function renderTypescriptType(parsed) {
             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) };

package/dist/common.js

@@ -7,12 +7,12 @@ export function getArgs(methName, methodDef) {
         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) {
-    return input.replace(/^\w/, c => c.toUpperCase());
+    return input.replace(/^\w/, (c) => c.toUpperCase());
 }
 export function minusculize(input) {
-    return input.replace(/^\w/, c => c.toLowerCase());
+    return input.replace(/^\w/, (c) => c.toLowerCase());
 }