@idlizer/core 2.1.2 → 2.1.5

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                         //
 ////////////////////////////////////////////////////////////////
@@ -136,14 +135,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}` : '';
@@ -185,8 +184,8 @@ export class TSLanguageWriter extends LanguageWriter {
         const returnType = this.getNodeName(signature.returnType);
         return `export function ${name}(${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 +273,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 +288,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 +321,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 +386,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 +416,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;