@idlizer/core 2.1.10-arktscgen-6 → 2.1.10-arktscgen-9

package/build/lib/src/LanguageWriters/ArgConvertors.js

@@ -17,14 +17,15 @@ import { Language } from "../Language";
 import { BlockStatement, PrintHint, StringExpression, NamedMethodSignature, ProxyStatement, ExpressionStatement } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { generatorConfiguration, generatorTypePrefix } from "../config";
-import { capitalize, getExtractor, getTransformer, hashCodeFromString, throwException, warn } from "../util";
+import { capitalize, getExtractor, entryToFunctionName as entryToFunctionName, getTransformer, hashCodeFromString, throwException, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { LayoutNodeRole } from "../peer-generation/LayoutManager";
 import { isInExternalModule } from "../peer-generation/modules";
+import { maybeRestoreGenerics } from "../transformers/GenericTransformer";
 export function getSerializerName(_library, _language, declaration) {
-    return `${idl.getQualifiedName(declaration, "package.namespace.name").split('.').map(capitalize).join('')}SerializerImpl`;
+    return entryToFunctionName(_language, declaration, "", "SerializerImpl");
 }
 export class BaseArgConvertor {
     constructor(idlType, runtimeTypes, isScoped, useArray, param) {
@@ -900,8 +901,9 @@ export class UnionConvertor extends BaseArgConvertor {
             statements.push(printer.makeAssign(varName, undefined, printer.makeUnionVariantCast(convertor.getObjectAccessor(printer.language, value), printer.getNodeName(convertor.idlType), convertor, index), true));
             statements.push(convertor.convertorSerialize(param, varName, printer));
         }
+        const genericDiscriminator = withGenericDiscriminator(this.library, this.memberConvertors, value, discriminator, type, printer);
         const stmt = new BlockStatement(statements, false);
-        return { expr: discriminator, stmt };
+        return { expr: genericDiscriminator, stmt };
     }
     makeArrayBranch(param, value, printer, arrayConvertorItems) {
         if (arrayConvertorItems.length == 0)
@@ -1349,4 +1351,25 @@ export function createOutArgConvertor(library, type, otherParams) {
     }
     return undefined;
 }
+function withGenericDiscriminator(library, convertors, value, discriminator, type, writer) {
+    if (writer.language == Language.CPP)
+        return discriminator;
+    if (!idl.isReferenceType(type))
+        return discriminator;
+    const mayBeGeneric = maybeRestoreGenerics(type, writer.resolver);
+    if (mayBeGeneric == undefined)
+        return discriminator;
+    const count = convertors
+        .map(it => it.idlType)
+        .filter(it => idl.isReferenceType(it))
+        .map(it => idl.isReferenceType(it) ? maybeRestoreGenerics(it, writer.resolver) : undefined)
+        .filter(it => it && idl.isReferenceType(it) && it.name == mayBeGeneric.name)
+        .length;
+    if (count < 2)
+        return discriminator;
+    writer.addFeature("typechecks", library.layout.handwrittenPackage());
+    const decl = writer.resolver.resolveTypeReference(type);
+    const checkGenericFunc = entryToFunctionName(writer.language, decl, "isGeneric_", "");
+    return writer.makeAnd(discriminator, writer.makeFunctionCall(`typechecks.${checkGenericFunc}`, [writer.makeString(value)]));
+}
 //# sourceMappingURL=ArgConvertors.js.map

package/build/lib/src/LanguageWriters/LanguageWriter.d.ts

@@ -123,7 +123,6 @@ export declare class TsEnumEntityStatement implements LanguageStatement {
         isDeclare: boolean;
     });
     write(writer: LanguageWriter): void;
-    private maybeQuoted;
 }
 export declare class ReturnStatement implements LanguageStatement {
     expression?: LanguageExpression | undefined;
@@ -169,7 +168,8 @@ export declare enum MethodModifier {
     THROWS = 8,
     FREE = 9,
     FORCE_CONTEXT = 10,
-    OVERRIDE = 11
+    OVERRIDE = 11,
+    OPEN = 12
 }
 export declare enum ClassModifier {
     PUBLIC = 0,
@@ -327,7 +327,8 @@ export declare abstract class LanguageWriter {
     writeStatements(...statements: LanguageStatement[]): void;
     writeExpressionStatement(smth: LanguageExpression): void;
     writeExpressionStatements(...statements: LanguageExpression[]): void;
-    writeStaticBlock(op: (writer: this) => void): void;
+    writePrefixedBlock(prefix: string, op: (writer: this) => void): void;
+    writeStaticInitBlock(op: (writer: this) => void): void;
     makeRef(type: idl.IDLType, _options?: MakeRefOptions): idl.IDLType;
     makeThis(): LanguageExpression;
     makeNull(type?: idl.IDLOptionalType): LanguageExpression;
@@ -388,12 +389,14 @@ export declare abstract class LanguageWriter {
     makeHasOwnProperty(value: string, property: string, propertyTypeName?: string): LanguageExpression;
     discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
     makeNot(expr: LanguageExpression): LanguageExpression;
+    makeAnd(...args: LanguageExpression[]): LanguageExpression;
+    makeOr(...args: LanguageExpression[]): LanguageExpression;
     makeSerializedBufferGetter(serializer: string): LanguageExpression;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
-    makeStaticBlock(op: (writer: LanguageWriter) => void): void;
+    writeStaticEntitiesBlock(op: (writer: LanguageWriter) => void): void;
     instanceOf(value: string, type: idl.IDLType): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     /**

package/build/lib/src/LanguageWriters/LanguageWriter.js

@@ -12,10 +12,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Language } from "../Language";
 import * as idl from "../idl";
 import * as fs from "fs";
 import { RuntimeType } from "./common";
-import { withInsideInstanceof } from "./nameConvertor";
+import { convertDeclaration, withInsideInstanceof } from "./nameConvertor";
+import { createDeclarationNameConvertor } from "../peer-generation/idl/IdlNameConvertor";
 export class TernaryExpression {
     constructor(condition, trueExpression, falseExpression) {
         this.condition = condition;
@@ -235,28 +237,33 @@ export class TsEnumEntityStatement {
         this.options = options;
     }
     write(writer) {
-        // writer.print(this.enumEntity.comment)
-        writer.print(`${this.options.isExport ? "export " : ""}${this.options.isDeclare ? "declare " : ""}enum ${this.enumEntity.name} {`);
-        writer.pushIndent();
+        let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
+        enumName = enumName.split('.').at(-1);
+        const correctStyleNames = [];
+        const originalStyleNames = [];
         this.enumEntity.elements.forEach((member, index) => {
-            // writer.print(member.comment)
-            const initValue = member.initializer
-                ? ` = ${this.maybeQuoted(member.initializer)}` : ``;
-            writer.print(`${member.name}${initValue},`);
-            let originalName = idl.getExtAttribute(member, idl.IDLExtendedAttributes.OriginalEnumMemberName);
-            if (originalName) {
-                const initValue = ` = ${member.name}`;
-                writer.print(`${originalName}${initValue},`);
-            }
+            var _a;
+            const initText = (_a = member.initializer) !== null && _a !== void 0 ? _a : index;
+            const isTypeString = typeof initText !== "number";
+            const originalName = idl.getExtAttribute(member, idl.IDLExtendedAttributes.OriginalEnumMemberName);
+            correctStyleNames.push({
+                name: originalName ? member.name : `${member.name}_DUMMY`,
+                alias: undefined,
+                stringId: isTypeString ? initText : undefined,
+                numberId: initText
+            });
+            originalStyleNames.push({
+                name: originalName !== null && originalName !== void 0 ? originalName : member.name,
+                alias: undefined,
+                stringId: isTypeString ? initText : undefined,
+                numberId: initText
+            });
         });
-        writer.popIndent();
-        writer.print(`}`);
-    }
-    maybeQuoted(value) {
-        if (typeof value == "string")
-            return `"${value}"`;
-        else
-            return `${value}`;
+        let members = originalStyleNames;
+        if (this.enumEntity.elements.some(it => idl.hasExtAttribute(it, idl.IDLExtendedAttributes.OriginalEnumMemberName))) {
+            members = members.concat(correctStyleNames);
+        }
+        writer.writeEnum(enumName, members, { isExport: this.options.isExport, isDeclare: this.options.isDeclare });
     }
 }
 export class ReturnStatement {
@@ -330,6 +337,7 @@ export var MethodModifier;
     MethodModifier[MethodModifier["FREE"] = 9] = "FREE";
     MethodModifier[MethodModifier["FORCE_CONTEXT"] = 10] = "FORCE_CONTEXT";
     MethodModifier[MethodModifier["OVERRIDE"] = 11] = "OVERRIDE";
+    MethodModifier[MethodModifier["OPEN"] = 12] = "OPEN";
 })(MethodModifier || (MethodModifier = {}));
 export var ClassModifier;
 (function (ClassModifier) {
@@ -489,13 +497,16 @@ export class LanguageWriter {
     writeExpressionStatements(...statements) {
         statements.forEach(it => this.writeExpressionStatement(it));
     }
-    writeStaticBlock(op) {
-        this.print("static {");
+    writePrefixedBlock(prefix, op) {
+        this.print(`${prefix} {`);
         this.pushIndent();
         op(this);
         this.popIndent();
         this.print("}");
     }
+    writeStaticInitBlock(op) {
+        this.writePrefixedBlock("static", op);
+    }
     makeRef(type, _options) {
         return type;
     }
@@ -676,6 +687,12 @@ export class LanguageWriter {
     makeNot(expr) {
         return this.makeString(`!(${expr.asString()})`);
     }
+    makeAnd(...args) {
+        return this.makeNaryOp("&&", args);
+    }
+    makeOr(...args) {
+        return this.makeNaryOp("||", args);
+    }
     makeSerializedBufferGetter(serializer) {
         return this.makeMethodCall(serializer, `asBuffer`, []);
     }
@@ -687,7 +704,7 @@ export class LanguageWriter {
     makeCallIsObject(value) {
         return this.makeString(`typeof ${value} === "object"`);
     }
-    makeStaticBlock(op) {
+    writeStaticEntitiesBlock(op) {
         op(this);
     }
     instanceOf(value, type) {

package/build/lib/src/LanguageWriters/convertors/TSConvertors.js

@@ -17,7 +17,7 @@ import { Language } from '../../Language';
 import { isTopLevelConflicted } from '../../peer-generation/ConflictingDeclarations';
 import { isDeclaredInCurrentFile, LayoutNodeRole } from '../../peer-generation/LayoutManager';
 import { maybeRestoreGenerics } from '../../transformers/GenericTransformer';
-import { convertNode, convertType, isInsideInstanceof } from '../nameConvertor';
+import { convertNode, convertType, isInsideInstanceof, withInsideInstanceof } from '../nameConvertor';
 export class TSTypeNameConvertor {
     constructor(library) {
         this.library = library;
@@ -142,7 +142,8 @@ export class TSTypeNameConvertor {
             }
             let typeSpec = type.name;
             let typeArgs = !isInsideInstanceof() || decl && idl.isCallback(decl)
-                ? (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.convert(it))) !== null && _b !== void 0 ? _b : []
+                // there is a bug with panda - if we're inside callback generics, we need to expand other generics too. So withInsideInstanceof is used
+                ? (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => withInsideInstanceof(false, () => this.convert(it)))) !== null && _b !== void 0 ? _b : []
                 : [];
             if (typeSpec === `Optional`)
                 return `${typeArgs} | undefined`;

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

@@ -1,7 +1,7 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature } from "../LanguageWriter";
 import { TSLanguageWriter } from "./TsLanguageWriter";
-import { IDLEnum, IDLType } from '../../idl';
+import { IDLType } from '../../idl';
 import { ArgConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
 import { IdlNameConvertor } from "../nameConvertor";
@@ -23,15 +23,6 @@ export declare class EtsAssignStatement implements LanguageStatement {
     constructor(variableName: string, type: IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions | undefined);
     write(writer: LanguageWriter): void;
 }
-export declare class ArkTSEnumEntityStatement implements LanguageStatement {
-    private readonly enumEntity;
-    private readonly options;
-    constructor(enumEntity: IDLEnum, options: {
-        isExport: boolean;
-        isDeclare: boolean;
-    });
-    write(writer: LanguageWriter): void;
-}
 export declare class ETSLambdaExpression extends LambdaExpression {
     private convertor;
     constructor(writer: LanguageWriter, convertor: IdlNameConvertor, signature: MethodSignature, resolver: ReferenceResolver, body?: LanguageStatement[]);
@@ -60,10 +51,6 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
-    makeEnumEntity(enumEntity: IDLEnum, options: {
-        isExport: boolean;
-        isDeclare?: boolean;
-    }): LanguageStatement;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     isQuickType(type: IDLType): boolean;
     writeNativeMethodDeclaration(method: Method): void;

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

@@ -15,11 +15,10 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { BlockStatement, LambdaExpression, MethodModifier } from "../LanguageWriter";
 import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
-import { getExtAttribute, IDLThisType } from '../../idl';
+import { IDLThisType } from '../../idl';
 import { AggregateConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
-import { convertDeclaration, withInsideInstanceof } from "../nameConvertor";
-import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
+import { withInsideInstanceof } from "../nameConvertor";
 import { Language } from "../../Language";
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
@@ -82,41 +81,6 @@ class ArkTSMapForEachStatement {
         writer.print(`}`);
     }
 }
-export class ArkTSEnumEntityStatement {
-    constructor(enumEntity, options) {
-        this.enumEntity = enumEntity;
-        this.options = options;
-    }
-    write(writer) {
-        let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
-        enumName = enumName.split('.').at(-1);
-        const correctStyleNames = [];
-        const originalStyleNames = [];
-        this.enumEntity.elements.forEach((member, index) => {
-            var _a;
-            const initText = (_a = member.initializer) !== null && _a !== void 0 ? _a : index;
-            const isTypeString = typeof initText !== "number";
-            const originalName = getExtAttribute(member, idl.IDLExtendedAttributes.OriginalEnumMemberName);
-            correctStyleNames.push({
-                name: originalName ? member.name : `${member.name}_DUMMY`,
-                alias: undefined,
-                stringId: isTypeString ? initText : undefined,
-                numberId: initText
-            });
-            originalStyleNames.push({
-                name: originalName !== null && originalName !== void 0 ? originalName : member.name,
-                alias: undefined,
-                stringId: isTypeString ? initText : undefined,
-                numberId: initText
-            });
-        });
-        let members = originalStyleNames;
-        if (this.enumEntity.elements.some(it => idl.hasExtAttribute(it, idl.IDLExtendedAttributes.OriginalEnumMemberName))) {
-            members = members.concat(correctStyleNames);
-        }
-        writer.writeEnum(enumName, members, { isExport: this.options.isExport, isDeclare: this.options.isDeclare });
-    }
-}
 export class ETSLambdaExpression extends LambdaExpression {
     constructor(writer, convertor, signature, resolver, body) {
         super(writer, signature, resolver, body);
@@ -224,12 +188,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         }
         return super.makeValueFromOption(value, destinationConvertor);
     }
-    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),
-        });
-    }
     writeMethodCall(receiver, method, params, nullable = false) {
         // ArkTS does not support - 'this.?'
         super.writeMethodCall(receiver, method, params, nullable && receiver !== "this");
@@ -271,7 +229,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         // The explicit cast forces ui2abc to call valueOf on an int, which fails the compilation
         // TODO Fix this cast
         if (bitness === 8)
-            return `(${value}).toChar()`;
+            return `(${value}).toByte()`;
         return `(${value}).toInt()`; // FIXME: is there int8 in ARKTS?
     }
     castToBoolean(value) { return `${value} ? true : false`; }

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

@@ -148,7 +148,7 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeCallIsObject(value: string): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     escapeKeyword(keyword: string): string;
-    makeStaticBlock(op: (writer: LanguageWriter) => void): void;
+    writeStaticEntitiesBlock(op: (writer: LanguageWriter) => void): void;
     pushNamespace(namespace: string, options: NamespaceOptions): void;
     popNamespace(options: {
         ident: boolean;

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

@@ -85,7 +85,7 @@ export class KotlinEnumWithGetter {
         let mangledName = removePoints(idl.getQualifiedName(this.enumEntity, 'namespace.name'));
         writer.writeClass(mangledName, () => {
             const enumType = idl.createReferenceType(this.enumEntity);
-            writer.makeStaticBlock(() => {
+            writer.writeStaticEntitiesBlock(() => {
                 members.forEach(it => {
                     writer.writeFieldDeclaration(it.name, enumType, [FieldModifier.PUBLIC, FieldModifier.STATIC, FieldModifier.FINAL], false, writer.makeString(`${mangledName}(${it.stringId ? `\"${it.stringId}\"` : it.numberId})`));
                 });
@@ -236,11 +236,11 @@ export class KotlinLanguageWriter extends LanguageWriter {
     maybeSemicolon() { return ""; }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? `${superClass}` : undefined;
-        let implementsClause = interfaces ? `${interfaces.join(' , ')}` : undefined;
+        let implementsClause = interfaces ? `${interfaces.join(', ')}` : undefined;
         let inheritancePart = [extendsClause, implementsClause]
             .filter(isDefined)
-            .join(' , ');
-        inheritancePart = inheritancePart.length != 0 ? ' : '.concat(inheritancePart) : '';
+            .join(', ');
+        inheritancePart = inheritancePart.length != 0 ? ': '.concat(inheritancePart) : '';
         this.printer.print(`public open class ${name}${inheritancePart} {`);
         this.pushIndent();
         op(this);
@@ -590,7 +590,7 @@ export class KotlinLanguageWriter extends LanguageWriter {
         throw new Error("Not implemented");
     }
     get supportedModifiers() {
-        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.OVERRIDE];
+        return [MethodModifier.PUBLIC, MethodModifier.PROTECTED, MethodModifier.PRIVATE, MethodModifier.OVERRIDE, MethodModifier.OPEN];
     }
     get supportedFieldModifiers() {
         return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.OVERRIDE];
@@ -619,12 +619,8 @@ export class KotlinLanguageWriter extends LanguageWriter {
     escapeKeyword(keyword) {
         return keyword;
     }
-    makeStaticBlock(op) {
-        this.printer.print('companion object {');
-        this.printer.pushIndent();
-        op(this);
-        this.popIndent();
-        this.printer.print('}');
+    writeStaticEntitiesBlock(op) {
+        this.writePrefixedBlock("companion object", op);
     }
     pushNamespace(namespace, options) { }
     popNamespace(options) { }

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

@@ -446,8 +446,15 @@ export class TSLanguageWriter extends LanguageWriter {
     }
     i32FromEnum(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        if (idl.isEnum(enumEntry) && idl.isStringEnum(enumEntry)) {
-            return this.makeString(`Object.values(${enumName}).indexOf(${value.asString()})`);
+        if (idl.isStringEnum(enumEntry)) {
+            let extractorStatement = this.makeString(`Object.values(${enumName}).indexOf(${value.asString()})`);
+            if (enumEntry.elements.some(it => idl.hasExtAttribute(it, idl.IDLExtendedAttributes.OriginalEnumMemberName))) {
+                extractorStatement = this.makeNaryOp('%', [
+                    extractorStatement,
+                    this.makeString(enumEntry.elements.length.toString())
+                ]);
+            }
+            return extractorStatement;
         }
         return this.makeString(`${value.asString()}.valueOf()`);
     }

package/build/lib/src/from-idl/parser.d.ts

@@ -31,7 +31,7 @@ interface Token {
     value: string;
     location: Location;
 }
-type ModifierToken = "static" | "readonly" | "async";
+type ModifierToken = "static" | "readonly" | "async" | "optional";
 type ModifiersContainer = {
     [Key in ModifierToken]?: Token;
 };

package/build/lib/src/from-idl/parser.js

@@ -69,7 +69,7 @@ const unsupportedDeclarations = new Set(["deleter", "getter", "includes", "inher
 const interfaceContent = new Set([idl.IDLKind.Constructor, idl.IDLKind.Const, idl.IDLKind.Property, idl.IDLKind.Method, idl.IDLKind.Callable]);
 const globalContent = new Set([idl.IDLKind.Namespace, idl.IDLKind.Interface, idl.IDLKind.Enum, idl.IDLKind.Method, idl.IDLKind.Typedef, idl.IDLKind.Callback, idl.IDLKind.Import, idl.IDLKind.Version, idl.IDLKind.Const]);
 const havingBlocks = new Set([idl.IDLKind.Namespace, idl.IDLKind.Interface, idl.IDLKind.Enum]);
-const modifierTokens = new Set(["static", "readonly", "async"]);
+const modifierTokens = new Set(["static", "readonly", "async", "optional"]);
 // Uncomment in case of parser debugging
 function trac(s) {
     // console.log(s)
@@ -402,7 +402,7 @@ export class Parser {
             }
             switch (this.curValue) {
                 case "attribute":
-                    this.assertPossibleModifiers("static", "readonly");
+                    this.assertPossibleModifiers("static", "readonly", "optional");
                     return this.parseAttribute();
                 case "callback":
                     return this.parseCallback();
@@ -737,7 +737,7 @@ export class Parser {
         const ext = this.consumeCurrentExtended();
         const isReadonly = !!this.currentModifiers.readonly;
         const isStatic = !!this.currentModifiers.static;
-        const isOptional = extractOptional(ext);
+        let isOptional = !!this.currentModifiers.optional || extractOptional(ext);
         this.skip("attribute");
         const type = this.parseType();
         const name = this.parseSingleIdentifier();

package/build/lib/src/idl/dump.js

@@ -128,8 +128,9 @@ export class IDLWriter {
     printProperty(idl) {
         const staticMod = idl.isStatic ? "static " : "";
         const readonlyMod = idl.isReadonly ? "readonly " : "";
+        const optional = idl.isOptional ? "optional " : "";
         return this.printExtendedAttributes(idl)
-            .print(`${staticMod}${readonlyMod}attribute ${nameWithType(idl)};`);
+            .print(`${staticMod}${readonlyMod}${optional}attribute ${nameWithType(idl)};`);
     }
     printExtendedAttributes(idl) {
         var _a;

package/build/lib/src/peer-generation/PeerLibrary.d.ts

@@ -10255,6 +10255,7 @@ export declare class PeerLibrary implements LibraryInterface {
     language: Language;
     interopNativeModule: NativeModuleType;
     readonly useMemoM3: boolean;
+    readonly useComponentNamedOverloads: boolean;
     private _cachedIdlLibrary?;
     asIDLLibrary(): IDLLibrary;
     get globals(): GlobalScopeDeclarations[];
@@ -10266,7 +10267,7 @@ export declare class PeerLibrary implements LibraryInterface {
     private resolver;
     readonly materializedClasses: Map<string, MaterializedClass>;
     get orderedMaterialized(): MaterializedClass[];
-    constructor(language: Language, interopNativeModule: NativeModuleType, useMemoM3?: boolean);
+    constructor(language: Language, interopNativeModule: NativeModuleType, useMemoM3?: boolean, useComponentNamedOverloads?: boolean);
     name: string;
     readonly customComponentMethods: string[];
     createLanguageWriter(language?: Language): LanguageWriter;

package/build/lib/src/peer-generation/PeerLibrary.js

@@ -91,10 +91,11 @@ export class PeerLibrary {
         return Array.from(this.materializedClasses.values()).filter(it => it.needBeGenerated)
             .sort((a, b) => accessorName(a.decl).localeCompare(accessorName(b.decl)));
     }
-    constructor(language, interopNativeModule, useMemoM3 = false) {
+    constructor(language, interopNativeModule, useMemoM3 = false, useComponentNamedOverloads = true) {
         this.language = language;
         this.interopNativeModule = interopNativeModule;
         this.useMemoM3 = useMemoM3;
+        this.useComponentNamedOverloads = useComponentNamedOverloads;
         this.layout = LayoutManager.Empty();
         this._files = [];
         this.auxFiles = [];

package/build/lib/src/transformers/FqnTransformer.js

@@ -10,14 +10,24 @@ class FqnTransformer extends IdlTransformer {
         this.resolver = resolver;
     }
     visit(node) {
-        var _a;
+        var _a, _b;
+        const defaultGenericReferenceAttribute = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(a => a.name === idl.IDLExtendedAttributes.TypeParametersDefaults);
+        if (defaultGenericReferenceAttribute && defaultGenericReferenceAttribute.typesValue) {
+            const fqVisited = defaultGenericReferenceAttribute.typesValue.map(type => {
+                const tmpType = idl.clone(type);
+                tmpType.parent = node;
+                return this.visit(tmpType);
+            });
+            defaultGenericReferenceAttribute.typesValue = fqVisited;
+            return this.visitEachChild(node);
+        }
         if (idl.isReferenceType(node)) {
             const resolved = this.resolver.resolveTypeReference(node);
             if (resolved === undefined) {
                 this.resolver.resolveTypeReference(node);
                 throw new Error("Can not expand FQN for " + idl.DebugUtils.debugPrintType(node));
             }
-            return idl.createReferenceType(idl.getFQName(resolved), (_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.visit(it)), idl.cloneNodeInitializer(node));
+            return idl.createReferenceType(idl.getFQName(resolved), (_b = node.typeArguments) === null || _b === void 0 ? void 0 : _b.map(it => this.visit(it)), idl.cloneNodeInitializer(node));
         }
         return this.visitEachChild(node);
     }

package/build/lib/src/transformers/GenericTransformer.js

@@ -80,7 +80,7 @@ class DefaultGenericsTransformer extends IdlTransformer {
         this.resolver = resolver;
     }
     visit(node) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         if (idl.isReferenceType(node)) {
             const decl = this.resolver.resolveTypeReference(node);
             if (!decl) {
@@ -91,14 +91,14 @@ class DefaultGenericsTransformer extends IdlTransformer {
                 return this.visitEachChild(node);
             }
             if (((_c = (_b = decl.typeParameters) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > ((_e = (_d = node.typeArguments) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0)) {
-                const defaults = (_h = (_g = (_f = decl.extendedAttributes) === null || _f === void 0 ? void 0 : _f.find(it => it.name === idl.IDLExtendedAttributes.TypeParametersDefaults)) === null || _g === void 0 ? void 0 : _g.typesValue) !== null && _h !== void 0 ? _h : [];
+                const defaults = (_j = (_h = (_g = (_f = decl.extendedAttributes) === null || _f === void 0 ? void 0 : _f.find(it => it.name === idl.IDLExtendedAttributes.TypeParametersDefaults)) === null || _g === void 0 ? void 0 : _g.typesValue) === null || _h === void 0 ? void 0 : _h.slice()) !== null && _j !== void 0 ? _j : [];
                 while (defaults.length < decl.typeParameters.length) {
                     defaults.unshift(undefined);
                 }
-                const typeArguments = Array.from((_j = node.typeArguments) !== null && _j !== void 0 ? _j : []);
+                const typeArguments = Array.from((_k = node.typeArguments) !== null && _k !== void 0 ? _k : []);
                 while (decl.typeParameters.length > typeArguments.length) {
                     if (defaults[typeArguments.length] === undefined) {
-                        const declarationDetails = `${idl.getFQName(decl)}<${((_k = decl.typeParameters) !== null && _k !== void 0 ? _k : [])
+                        const declarationDetails = `${idl.getFQName(decl)}<${((_l = decl.typeParameters) !== null && _l !== void 0 ? _l : [])
                             .map((it, index) => `${it}${defaults[index] ? '=' + defaults[index] : ''}`)
                             .join(', ')}>`;
                         const referenceDetails = `${node.name}<${typeArguments.map(it => idl.printType(it)).join(", ")}>`;
@@ -139,7 +139,7 @@ class GenericsTransformer extends IdlTransformer {
                 throw new Error(`Unsupported generics target ${resolved.kind}`);
             }
             const inplacedRef = idl.createReferenceType(idl.deriveQualifiedNameFrom(monomorphisedEntryName(resolved, ref.typeArguments, this.options), resolved), undefined, idl.cloneNodeInitializer(ref));
-            if (!this.resolver.resolveTypeReference(inplacedRef)) {
+            if (!this.resolver.resolveTypeReference(inplacedRef, { unresolvedOk: true })) {
                 const monomorphizedEntry = this.visit(this.monomorphizeEntry(resolved, ref.typeArguments));
                 this.producer({ anchor: idl.getFQName(resolved), produced: monomorphizedEntry });
             }

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

@@ -18,6 +18,7 @@ export declare function snakeCaseToCamelCase(input: string, tailToLowerCase?: bo
 export declare function toCamelCase(input: string): string;
 export declare function isUpperCase(s: string): boolean;
 export declare function camelCaseToUpperSnakeCase(input: string): string;
+export declare function camelCaseToLowerSnakeCase(input: string): string;
 export declare function snakeToLowCamelNode(node: idl.IDLEntry): string;
 export declare function renameDtsToPeer(fileName: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameDtsToComponent(fileName: string, language: Language, withFileExtension?: boolean): string;
@@ -25,6 +26,7 @@ export declare function renameDtsToInterfaces(fileName: string, language: Langua
 export declare function renameClassToBuilderClass(className: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameClassToMaterialized(className: string, language: Language, withFileExtension?: boolean): string;
 export declare function throwException(message: string): never;
+export declare function entryToFunctionName(_language: Language, declaration: idl.IDLEntry, prefix: string, postfix: string): string;
 /**
  * Add a prefix to an enum value which camel case name coincidence
  * with the the same upper case name for an another enum value

package/build/lib/src/util.js

@@ -122,6 +122,9 @@ export function camelCaseToUpperSnakeCase(input) {
         .map(s => toUpperSnakeCase(s))
         .join('_');
 }
+export function camelCaseToLowerSnakeCase(input) {
+    return camelCaseToUpperSnakeCase(input).toLowerCase();
+}
 export function snakeToLowCamelNode(node) {
     if (!node.fileName) {
         throw new Error("Invalid Convert");
@@ -191,6 +194,9 @@ export function renameClassToMaterialized(className, language, withFileExtension
 export function throwException(message) {
     throw new Error(message);
 }
+export function entryToFunctionName(_language, declaration, prefix, postfix) {
+    return `${prefix}${idl.getQualifiedName(declaration, "package.namespace.name").split('.').map(capitalize).join('')}${postfix}`;
+}
 /**
  * Add a prefix to an enum value which camel case name coincidence
  * with the the same upper case name for an another enum value

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@idlizer/core",
-    "version": "2.1.10-arktscgen-6",
+    "version": "2.1.10-arktscgen-9",
     "description": "",
     "types": "build/lib/src/index.d.ts",
     "exports": {
@@ -36,7 +36,7 @@
         "mocha": "^9.2.2",
         "ts-node": "^10.9.2",
         "typescript": "4.9.5",
-        "@types/node": "^18.0.0",
+        "@types/node": "^18.19.127",
         "rimraf": "^6.0.1"
     },
     "scripts": {