@idlizer/core 2.1.2 → 2.1.7

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.d.ts

@@ -17,8 +17,11 @@ export declare class EtsAssignStatement implements LanguageStatement {
 }
 export declare class ArkTSEnumEntityStatement implements LanguageStatement {
     private readonly enumEntity;
-    private readonly isExport;
-    constructor(enumEntity: IDLEnum, isExport: boolean);
+    private readonly options;
+    constructor(enumEntity: IDLEnum, options: {
+        isExport: boolean;
+        isDeclare: boolean;
+    });
     write(writer: LanguageWriter): void;
 }
 export declare class ETSLambdaExpression extends LambdaExpression {
@@ -28,8 +31,8 @@ export declare class ETSLambdaExpression extends LambdaExpression {
     asString(): string;
 }
 export declare function generateTypeCheckerName(typeName: string): string;
-export declare function generateEnumToOrdinalName(typeName: string): string;
-export declare function generateEnumFromOrdinalName(typeName: string): string;
+export declare function generateEnumToNumericName(typeName: string): string;
+export declare function generateEnumFromNumericName(typeName: string): string;
 export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName: string, writer: LanguageWriter): LanguageExpression;
 export declare class ETSLanguageWriter extends TSLanguageWriter {
     private arrayConvertor;
@@ -44,14 +47,17 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     get supportedModifiers(): MethodModifier[];
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index?: number): LanguageExpression;
-    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     makeDiscriminatorFromFields(convertor: {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
     makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
-    makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
+    makeEnumEntity(enumEntity: IDLEnum, options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }): LanguageStatement;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     isQuickType(type: IDLType): boolean;
@@ -66,7 +72,10 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     instanceOf(convertor: ArgConvertor, value: string, duplicateMembers?: Set<string>): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
-    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
+    static _isUseTypeChecker: boolean;
+    static get isUseTypeChecker(): boolean;
+    static useTypeChecker<T>(isUseTypeChecker: boolean, op: () => T): T;
 }
 export declare function makeEnumTypeCheckerCall(valueAccessor: string, enumName: string, writer: LanguageWriter): LanguageExpression;
 //# sourceMappingURL=ETSLanguageWriter.d.ts.map

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.js

@@ -63,9 +63,9 @@ class ArkTSMapForEachStatement {
     }
 }
 export class ArkTSEnumEntityStatement {
-    constructor(enumEntity, isExport) {
+    constructor(enumEntity, options) {
         this.enumEntity = enumEntity;
-        this.isExport = isExport;
+        this.options = options;
     }
     write(writer) {
         let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
@@ -99,10 +99,7 @@ export class ArkTSEnumEntityStatement {
             }
             return res;
         });
-        const nss = idl.getNamespacesPathFor(this.enumEntity);
-        nss.forEach(it => writer.pushNamespace(it.name));
-        writer.writeEnum(enumName, members);
-        nss.forEach(() => writer.popNamespace());
+        writer.writeEnum(enumName, members, { isExport: this.options.isExport, isDeclare: this.options.isDeclare });
     }
 }
 export class ETSLambdaExpression extends LambdaExpression {
@@ -133,17 +130,18 @@ export class ETSLambdaExpression extends LambdaExpression {
 //                           UTILS                            //
 ////////////////////////////////////////////////////////////////
 export function generateTypeCheckerName(typeName) {
-    typeName = typeName.replaceAll('[]', 'BracketsArray')
-        .replaceAll('.', ''); // Todo: hack for namespaces
+    typeName = typeName
+        .replaceAll('[]', 'BracketsArray')
+        .split('.').at(-1); // Todo: hack for namespaces. Remove when ready to use FQNames
     return `is${typeName.replaceAll('[]', 'Brackets')}`;
 }
-export function generateEnumToOrdinalName(typeName) {
-    typeName = typeName.split(".").join("_");
-    return `${typeName}_ToOrdinal`;
+export function generateEnumToNumericName(typeName) {
+    typeName = typeName.split('.').at(-1); // Todo: hack for namespaces. Remove when ready to use FQNames
+    return `${typeName}_ToNumeric`;
 }
-export function generateEnumFromOrdinalName(typeName) {
-    typeName = typeName.split(".").join("_");
-    return `${typeName}_FromOrdinal`;
+export function generateEnumFromNumericName(typeName) {
+    typeName = typeName.split('.').at(-1); // Todo: hack for namespaces. Remove when ready to use FQNames
+    return `${typeName}_FromNumeric`;
 }
 export function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
     return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(typeName), [writer.makeString(valueAccessor)
@@ -182,13 +180,23 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     makeUnionVariantCast(value, type, convertor, index) {
         return this.makeString(`${value} as ${type}`);
     }
-    enumFromOrdinal(value, enumEntry) {
-        const enumName = this.getNodeName(enumEntry);
-        return this.makeMethodCall('TypeChecker', generateEnumFromOrdinalName(enumName), [this.makeString(value.asString())]);
+    i32FromEnum(value, enumEntry) {
+        if (ETSLanguageWriter.isUseTypeChecker) {
+            const enumName = this.getNodeName(enumEntry);
+            return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumName), [value]);
+        }
+        return idl.isStringEnum(enumEntry)
+            ? this.makeMethodCall(value.asString(), 'getOrdinal', [])
+            : this.makeMethodCall(value.asString(), 'valueOf', []);
     }
-    ordinalFromEnum(value, enumEntry) {
+    enumFromI32(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        return this.makeMethodCall('TypeChecker', generateEnumToOrdinalName(enumName), [this.makeString(value.asString())]);
+        if (ETSLanguageWriter.isUseTypeChecker) {
+            return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumName), [value]);
+        }
+        return idl.isStringEnum(enumEntry)
+            ? this.makeString(`${enumName}.values()[${value.asString()}]`)
+            : this.makeMethodCall(enumName, 'fromValue', [value]);
     }
     makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
         if (convertor instanceof AggregateConvertor
@@ -208,8 +216,11 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     makeIsTypeCall(value, decl) {
         return makeInterfaceTypeCheckerCall(value, decl.name, decl.properties.map(it => it.name), new Set(), this);
     }
-    makeEnumEntity(enumEntity, isExport) {
-        return new ArkTSEnumEntityStatement(enumEntity, isExport);
+    makeEnumEntity(enumEntity, options) {
+        return new ArkTSEnumEntityStatement(enumEntity, {
+            isExport: options === null || options === void 0 ? void 0 : options.isExport,
+            isDeclare: !!(options === null || options === void 0 ? void 0 : options.isDeclare),
+        });
     }
     getObjectAccessor(convertor, value, args) {
         return super.getObjectAccessor(convertor, value, args);
@@ -269,6 +280,11 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         // ])
     }
     castToInt(value, bitness) {
+        // This fix is used to avoid unnecessary writeInt8(value as int32) call, which is generated if value is already an int32
+        // The explicit cast forces ui2abc to call valueOf on an int, which fails the compilation
+        // TODO Fix this cast
+        if (bitness === 8)
+            return value;
         return `${value} as int32`; // FIXME: is there int8 in ARKTS?
     }
     castToBoolean(value) { return `${value} ? 1 : 0`; }
@@ -304,11 +320,20 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     makeTypeCast(value, type, options) {
         return this.makeString(`TypeChecker.typeCast<${this.getNodeName(type)}>(value)`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, options) {
         var _a;
-        return new TSCastExpression(value, `${this.getNodeName(type)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+        return new TSCastExpression(value, `${this.getNodeName(node)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+    }
+    static get isUseTypeChecker() { return this._isUseTypeChecker; }
+    static useTypeChecker(isUseTypeChecker, op) {
+        const prevIsUse = this.isReferenceRelativeToNamespaces;
+        this._isUseTypeChecker = isUseTypeChecker;
+        const result = op();
+        this._isUseTypeChecker = prevIsUse;
+        return result;
     }
 }
+ETSLanguageWriter._isUseTypeChecker = true;
 function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {
     return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(interfaceName), [writer.makeString(valueAccessor),
         ...allFields.map(it => {

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.d.ts

@@ -57,7 +57,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
     makeMapSize(map: string): LanguageExpression;
-    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeUnionSelector(value: string, valueType: string): LanguageStatement;
     makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, _type: string, convertorIndex: number): LanguageExpression;
@@ -69,7 +69,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
-    makeRuntimeTypeGetterCall(value: string): LanguageExpression;
+    protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;
     makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
     getTagType(): idl.IDLType;
     getRuntimeType(): idl.IDLType;
@@ -80,12 +80,10 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
     makeMapInit(type: idl.IDLType): LanguageExpression;
     makeTupleAccess(value: string, index: number): LanguageExpression;
-    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     makeValueFromOption(value: string): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
-    makeEnumCast(_enumEntry: idl.IDLEnum, enumName: string): string;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     castToBoolean(value: string): string;
-    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
 }
 //# sourceMappingURL=JavaLanguageWriter.d.ts.map

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.js

@@ -100,6 +100,13 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         this.typeConvertor = typeConvertor;
     }
     getNodeName(type) {
+        // another stub. Bad one.
+        // I hope that I will rewrite LWs soon
+        if (idl.isType(type) && idl.isReferenceType(type)) {
+            if (type.name.startsWith('%TEXT%:')) {
+                return type.name.substring(7);
+            }
+        }
         return this.typeConvertor.convert(type);
     }
     fork(options) {
@@ -203,9 +210,9 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     makeMapSize(map) {
         return this.makeString(`${map}.size()`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, options) {
         var _a;
-        return new JavaCastExpression(value, this.getNodeName(type), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+        return new JavaCastExpression(value, this.getNodeName(node), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
     makeStatement(expr) {
         return new CLikeExpressionStatement(expr);
@@ -276,29 +283,23 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     makeTupleAccess(value, index) {
         return this.makeString(`${value}.value${index}`);
     }
-    enumFromOrdinal(value, enumEntry) {
+    enumFromI32(value, enumEntry) {
         const enumName = idl.forceAsNamedNode(enumEntry).name;
         const ordinal = value.asString();
         return this.makeString(`${enumName}.values()[${ordinal}]`);
     }
-    ordinalFromEnum(value, _) {
-        return this.makeString(`${value.asString()}.ordinal()`);
-    }
     makeValueFromOption(value) {
         return this.makeString(`${value}`);
     }
     runtimeType(param, valueType, value) {
         this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
     }
-    makeEnumCast(_enumEntry, enumName) {
-        return `${enumName}.value`;
+    i32FromEnum(value, enumEntry) {
+        const i32Value = idl.isStringEnum(enumEntry)
+            ? `${value.asString()}.ordinal`
+            : `${value.asString()}.value`;
+        return this.makeString(i32Value);
     }
     castToBoolean(value) { return value; }
-    makeLengthSerializer(serializer, value) {
-        return this.makeBlock([
-            this.makeStatement(this.makeMethodCall(serializer, "writeInt8", [this.makeRuntimeType(RuntimeType.STRING)])),
-            this.makeStatement(this.makeMethodCall(serializer, "writeString", [this.makeString(`${value}.value`)]))
-        ], false);
-    }
 }
 //# sourceMappingURL=JavaLanguageWriter.js.map

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.d.ts

@@ -32,22 +32,28 @@ export declare class TSLanguageWriter extends LanguageWriter {
     protected typeConvertor: IdlNameConvertor;
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, language?: Language);
     maybeSemicolon(): string;
-    pushNamespace(namespace: string, ident?: boolean): void;
+    pushNamespace(namespace: string, options: {
+        ident: boolean;
+        isDeclared?: boolean;
+    }): void;
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
     getNodeName(type: idl.IDLNode): string;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isAbstract?: boolean): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[], isDeclared?: boolean): void;
-    writeFunctionDeclaration(name: string, signature: MethodSignature): void;
-    writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
+    writeFunctionDeclaration(name: string, signature: MethodSignature, generics?: string[]): void;
+    writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void, generics?: string[]): void;
     private generateFunctionDeclaration;
     writeEnum(name: string, members: {
         name: string;
         alias?: string | undefined;
         stringId: string | undefined;
         numberId: number;
-    }[]): void;
+    }[], options: {
+        isDeclare?: boolean;
+        isExport: boolean;
+    }): void;
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeNativeMethodDeclaration(method: Method): void;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
@@ -73,7 +79,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
     writePrintLog(message: string): void;
-    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
@@ -89,9 +95,8 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeTupleAssign(receiver: string, fields: string[]): LanguageStatement;
     get supportedModifiers(): MethodModifier[];
     get supportedFieldModifiers(): FieldModifier[];
-    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    makeEnumCast(enumEntry: idl.IDLEnum, param: string): string;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
     escapeKeyword(keyword: string): string;

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.js

@@ -20,7 +20,6 @@ import { AssignStatement, BlockStatement, CheckOptionalStatement, ExpressionStat
 import { RuntimeType } from "../common";
 import { rightmostIndexOf, throwException } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
-import { isStringEnumType } from '../../peer-generation/isEnumType';
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
@@ -125,10 +124,11 @@ export class TSLanguageWriter extends LanguageWriter {
         this.typeConvertor = typeConvertor;
     }
     maybeSemicolon() { return ""; }
-    pushNamespace(namespace, ident = true) {
+    pushNamespace(namespace, options) {
         this.namespaceStack.push(namespace);
-        this.print(`export namespace ${namespace} {`);
-        if (ident)
+        const declaredPrefix = options.isDeclared ? "declare " : "";
+        this.print(`export ${declaredPrefix}namespace ${namespace} {`);
+        if (options.ident)
             this.pushIndent();
     }
     fork(options) {
@@ -136,14 +136,14 @@ export class TSLanguageWriter extends LanguageWriter {
         return new TSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
     }
     getNodeName(type) {
-        // just stub.
-        // language writers and name convertors are subject to rework for namespaces
-        const row = this.typeConvertor.convert(type);
-        const nsPrefix = this.namespaceStack.join('.') + '.';
-        if (row.startsWith(nsPrefix)) {
-            return row.substring(nsPrefix.length);
+        // another stub. Bad one.
+        // I hope that I will rewrite LWs soon
+        if (idl.isType(type) && idl.isReferenceType(type)) {
+            if (type.name.startsWith('%TEXT%:')) {
+                return type.name.substring(7);
+            }
         }
-        return row;
+        return this.typeConvertor.convert(type);
     }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? ` extends ${superClass}` : '';
@@ -166,27 +166,28 @@ export class TSLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeFunctionDeclaration(name, signature) {
-        this.printer.print(this.generateFunctionDeclaration(name, signature));
+    writeFunctionDeclaration(name, signature, generics) {
+        this.printer.print(this.generateFunctionDeclaration(name, signature, generics));
     }
-    writeFunctionImplementation(name, signature, op) {
-        this.printer.print(`${this.generateFunctionDeclaration(name, signature)} {`);
+    writeFunctionImplementation(name, signature, op, generics) {
+        this.printer.print(`${this.generateFunctionDeclaration(name, signature, generics)} {`);
         this.printer.pushIndent();
         op(this);
         this.printer.popIndent();
         this.printer.print('}');
     }
-    generateFunctionDeclaration(name, signature) {
+    generateFunctionDeclaration(name, signature, generics) {
         const rightmostRegularParameterIndex = rightmostIndexOf(signature.args, it => !isOptionalType(it));
         const args = signature.args.map((it, index) => {
             const optionalToken = idl.isOptionalType(it) && index > rightmostRegularParameterIndex ? '?' : '';
             return `${signature.argName(index)}${optionalToken}: ${this.getNodeName(it)}`;
         });
         const returnType = this.getNodeName(signature.returnType);
-        return `export function ${name}(${args.join(", ")}): ${returnType}`;
+        const typeParams = generics && generics.length ? '<' + (generics === null || generics === void 0 ? void 0 : generics.join(', ')) + '>' : '';
+        return `export function ${name}${typeParams}(${args.join(", ")}): ${returnType}`;
     }
-    writeEnum(name, members) {
-        this.printer.print(`export enum ${name} {`);
+    writeEnum(name, members, options) {
+        this.printer.print(`${options.isExport ? "export " : ""}${options.isDeclare ? "declare " : ""}enum ${name} {`);
         this.printer.pushIndent();
         for (const [index, member] of members.entries()) {
             let value;
@@ -274,7 +275,6 @@ export class TSLanguageWriter extends LanguageWriter {
         this.print(`export const ${constName}: ${this.getNodeName(constType)}${constVal ? ' = ' + constVal : ''}`);
     }
     writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
-        var _a;
         let prefix = !modifiers ? undefined : this.supportedModifiers
             .filter(it => modifiers.includes(it))
             .map(it => this.mapMethodModifier(it)).join(" ");
@@ -290,19 +290,8 @@ export class TSLanguageWriter extends LanguageWriter {
         }
         prefix = prefix ? prefix.trim() + " " : "";
         const typeParams = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : "";
-        // FIXME:
-        const isSetter = modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER);
-        const canBeOptional = [];
-        for (let i = signature.args.length - 1; i >= 0; --i) {
-            const prevCanBeOptional = (_a = canBeOptional.at(-1)) !== null && _a !== void 0 ? _a : true;
-            const curr = signature.args[i];
-            const result = prevCanBeOptional && (idl.isOptionalType(curr) || signature.argDefault(i) !== undefined);
-            canBeOptional.push(result);
-        }
-        canBeOptional.reverse();
-        const isOptional = signature.args.map((it, i) => idl.isOptionalType(it) && canBeOptional[i] && !isSetter);
-        const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && isOptional[i] ? idl.maybeUnwrapOptionalType(it) : it);
-        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${isOptional[index] ? "?" : ""}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
+        const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && signature.isArgOptional(i) ? idl.maybeUnwrapOptionalType(it) : it);
+        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${signature.isArgOptional(index) ? "?" : ``}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
     }
     makeNull() {
         return new StringExpression("undefined");
@@ -334,9 +323,9 @@ export class TSLanguageWriter extends LanguageWriter {
     writePrintLog(message) {
         this.print(`console.log("${message}")`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, options) {
         var _a;
-        return new TSCastExpression(value, this.getNodeName(/* FIXME: */ idl.maybeUnwrapOptionalType(type)), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+        return new TSCastExpression(value, this.getNodeName(node), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
     typeInstanceOf(type, value, members) {
         if (idl.isInterface(type)) {
@@ -399,27 +388,19 @@ export class TSLanguageWriter extends LanguageWriter {
     get supportedFieldModifiers() {
         return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.STATIC];
     }
-    enumFromOrdinal(value, enumEntry) {
-        const enumName = idl.forceAsNamedNode(enumEntry).name;
+    enumFromI32(value, enumEntry) {
+        const enumName = enumEntry.name;
         const ordinal = value.asString();
-        return isStringEnumType(enumEntry, this.resolver)
+        return idl.isStringEnum(enumEntry)
             ? this.makeString(`Object.values(${enumName})[${ordinal}]`)
-            : this.makeString(`${ordinal}`);
+            : this.makeString(ordinal);
     }
-    ordinalFromEnum(value, enumEntry) {
-        const enumName = idl.forceAsNamedNode(enumEntry).name;
-        const decl = idl.isReferenceType(enumEntry) ? this.resolver.resolveTypeReference(enumEntry) : undefined;
-        if (decl && idl.isEnum(decl) && idl.isStringEnum(decl)) {
+    i32FromEnum(value, enumEntry) {
+        const enumName = this.getNodeName(enumEntry);
+        if (idl.isEnum(enumEntry) && idl.isStringEnum(enumEntry)) {
             return this.makeString(`Object.values(${enumName}).indexOf(${value.asString()})`);
         }
-        return value;
-    }
-    makeEnumCast(enumEntry, param) {
-        // Take the ordinal value if Enum is a string, and valueOf when it is an integer
-        // Enum.valueOf() - compatible with ArkTS/TS
-        return idl.isStringEnum(enumEntry)
-            ? this.ordinalFromEnum(this.makeString(param), idl.createReferenceType(enumEntry)).asString()
-            : `${param}.valueOf()`;
+        return this.makeString(`${value.asString()}.valueOf()`);
     }
     castToBoolean(value) { return `+${value}`; }
     makeCallIsObject(value) {
@@ -437,7 +418,7 @@ export class TSLanguageWriter extends LanguageWriter {
             throwException(`The type reference ${decl === null || decl === void 0 ? void 0 : decl.name} must be Enum`);
         }
         const ordinal = idl.isStringEnum(decl)
-            ? this.ordinalFromEnum(this.makeCast(this.makeString(this.getObjectAccessor(convertor, value)), convertor.idlType), idl.createReferenceType(this.getNodeName(convertor.nativeType())))
+            ? this.i32FromEnum(this.makeCast(this.makeString(this.getObjectAccessor(convertor, value)), convertor.idlType), decl)
             : this.makeUnionVariantCast(this.getObjectAccessor(convertor, value), this.getNodeName(idl.IDLI32Type), convertor, index);
         const { low, high } = idl.extremumOfOrdinals(decl);
         return this.discriminatorFromExpressions(value, convertor.runtimeTypes[0], [

package/build/lib/src/LibraryInterface.d.ts

@@ -3,12 +3,9 @@ import { Language } from "./Language";
 import { IdlNameConvertor } from "./LanguageWriters";
 import { ArgConvertor } from "./LanguageWriters/ArgConvertors";
 import { ReferenceResolver } from "./peer-generation/ReferenceResolver";
-export interface LibraryFileInterface {
-    get entries(): idl.IDLEntry[];
-}
 export interface LibraryInterface extends ReferenceResolver {
     language: Language;
-    get files(): LibraryFileInterface[];
+    get files(): idl.IDLFile[];
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     getInteropName(node: idl.IDLNode): string;