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

package/lib/index.js

@@ -261,6 +261,9 @@ function isReferenceType(type) {
 function isEnum(type) {
     return type.kind == IDLKind.Enum;
 }
+function isEnumMember(type) {
+    return type.kind == IDLKind.EnumMember;
+}
 function isUnionType(type) {
     return type.kind == IDLKind.UnionType;
 }
@@ -775,8 +778,9 @@ 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;
@@ -1566,11 +1570,144 @@ function convertType(convertor, type) {
         return convertor.convertPrimitiveType(type);
     throw new Error(`Unknown type ${IDLKind[type.kind]}`);
 }
+function convertDeclaration(convertor, decl) {
+    if (isImport(decl))
+        return convertor.convertImport(decl);
+    if (isNamespace(decl))
+        return convertor.convertNamespace(decl);
+    if (isInterface(decl))
+        return convertor.convertInterface(decl);
+    if (isEnum(decl))
+        return convertor.convertEnum(decl);
+    if (isEnumMember(decl))
+        return convertor.convertEnum(decl.parent);
+    if (isTypedef(decl))
+        return convertor.convertTypedef(decl);
+    if (isCallback(decl))
+        return convertor.convertCallback(decl);
+    if (isMethod(decl))
+        return convertor.convertMethod(decl);
+    if (isConstant(decl))
+        return convertor.convertConstant(decl);
+    throw new Error(`Unknown declaration type ${decl.kind ? IDLKind[decl.kind] : "(undefined kind)"}`);
+}
 function withInsideInstanceof(isInsideInstanceof, op) {
     const result = op();
     return result;
 }
 
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class DeclarationNameConvertor {
+    convertImport(decl) {
+        console.warn("Imports are not implemented yet");
+        return decl.name;
+    }
+    convertInterface(decl) {
+        return decl.name;
+    }
+    convertEnum(decl) {
+        return `${getNamespacesPathFor(decl).join('')}${decl.name}`;
+    }
+    convertTypedef(decl) {
+        return decl.name;
+    }
+    convertCallback(decl) {
+        var _a;
+        return (_a = decl.name) !== null && _a !== void 0 ? _a : "MISSING CALLBACK NAME";
+    }
+    convertNamespace(node) {
+        return node.name;
+    }
+    convertMethod(node) {
+        return node.name;
+    }
+    convertConstant(node) {
+        return node.name;
+    }
+}
+DeclarationNameConvertor.I = new DeclarationNameConvertor();
+class TSFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        const namespace = getNamespacesPathFor(decl).map(it => it.name);
+        if (namespace.length > 0)
+            return namespace[0];
+        return decl.name;
+    }
+}
+TSFeatureNameConvertor.I = new TSFeatureNameConvertor();
+class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return getQualifiedName(decl, "namespace.name");
+    }
+    convertEnum(decl) {
+        return getQualifiedName(decl, "namespace.name");
+    }
+}
+ETSDeclarationNameConvertor.I = new ETSDeclarationNameConvertor();
+class CJDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return decl.name;
+    }
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+CJDeclarationNameConvertor.I = new CJDeclarationNameConvertor();
+class KotlinDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return removePoints(getQualifiedName(decl, "namespace.name"));
+    }
+    convertEnum(decl) {
+        return removePoints(getQualifiedName(decl, "namespace.name"));
+    }
+}
+KotlinDeclarationNameConvertor.I = new KotlinDeclarationNameConvertor();
+class ETSFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        const namespace = getNamespacesPathFor(decl).map(it => it.name);
+        if (namespace.length > 0)
+            return namespace[0];
+        return decl.name;
+    }
+}
+ETSFeatureNameConvertor.I = new ETSFeatureNameConvertor();
+class CJFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+CJFeatureNameConvertor.I = new CJFeatureNameConvertor();
+class KotlinFeatureNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return removePoints(getQualifiedName(decl, "namespace.name"));
+    }
+    convertEnum(decl) {
+        return removePoints(getQualifiedName(decl, "namespace.name"));
+    }
+}
+KotlinFeatureNameConvertor.I = new KotlinFeatureNameConvertor();
+function createDeclarationNameConvertor(language) {
+    switch (language) {
+        case Language.ARKTS: return ETSDeclarationNameConvertor.I;
+        case Language.CPP:
+        case Language.TS: return DeclarationNameConvertor.I;
+        case Language.CJ:        case Language.KOTLIN:        default: throw new Error(`Language ${language.toString()} is not supported`);
+    }
+}
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -1796,28 +1933,33 @@ 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 = getExtAttribute(member, 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 = getExtAttribute(member, 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 => hasExtAttribute(it, IDLExtendedAttributes.OriginalEnumMemberName))) {
+            members = members.concat(correctStyleNames);
+        }
+        writer.writeEnum(enumName, members, { isExport: this.options.isExport, isDeclare: this.options.isDeclare });
     }
 }
 class ReturnStatement {
@@ -1891,6 +2033,7 @@ 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 = {}));
 var ClassModifier;
 (function (ClassModifier) {
@@ -2043,13 +2186,16 @@ 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;
     }
@@ -2230,6 +2376,12 @@ 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`, []);
     }
@@ -2241,7 +2393,7 @@ class LanguageWriter {
     makeCallIsObject(value) {
         return this.makeString(`typeof ${value} === "object"`);
     }
-    makeStaticBlock(op) {
+    writeStaticEntitiesBlock(op) {
         op(this);
     }
     instanceOf(value, type) {
@@ -2571,7 +2723,7 @@ const unsupportedDeclarations = new Set(["deleter", "getter", "includes", "inher
 const interfaceContent = new Set([IDLKind.Constructor, IDLKind.Const, IDLKind.Property, IDLKind.Method, IDLKind.Callable]);
 const globalContent = new Set([IDLKind.Namespace, IDLKind.Interface, IDLKind.Enum, IDLKind.Method, IDLKind.Typedef, IDLKind.Callback, IDLKind.Import, IDLKind.Version, IDLKind.Const]);
 const havingBlocks = new Set([IDLKind.Namespace, IDLKind.Interface, IDLKind.Enum]);
-const modifierTokens = new Set(["static", "readonly", "async"]);
+const modifierTokens = new Set(["static", "readonly", "async", "optional"]);
 class Parser {
     constructor(fileName, content) {
         var _a, _b;
@@ -2885,7 +3037,7 @@ class Parser {
             }
             switch (this.curValue) {
                 case "attribute":
-                    this.assertPossibleModifiers("static", "readonly");
+                    this.assertPossibleModifiers("static", "readonly", "optional");
                     return this.parseAttribute();
                 case "callback":
                     return this.parseCallback();
@@ -3206,7 +3358,7 @@ 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();
@@ -5024,8 +5176,15 @@ class TSLanguageWriter extends LanguageWriter {
     }
     i32FromEnum(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        if (isEnum(enumEntry) && isStringEnum(enumEntry)) {
-            return this.makeString(`Object.values(${enumName}).indexOf(${value.asString()})`);
+        if (isStringEnum(enumEntry)) {
+            let extractorStatement = this.makeString(`Object.values(${enumName}).indexOf(${value.asString()})`);
+            if (enumEntry.elements.some(it => hasExtAttribute(it, IDLExtendedAttributes.OriginalEnumMemberName))) {
+                extractorStatement = this.makeNaryOp('%', [
+                    extractorStatement,
+                    this.makeString(enumEntry.elements.length.toString())
+                ]);
+            }
+            return extractorStatement;
         }
         return this.makeString(`${value.asString()}.valueOf()`);
     }
@@ -5068,6 +5227,14 @@ function isDefined(value) {
 function capitalize(string) {
     return string.charAt(0).toUpperCase() + string.slice(1);
 }
+function dropLast(text, chars) {
+    return text.substring(0, text.length - chars);
+}
+function dropSuffix(text, suffix) {
+    if (!text.endsWith(suffix))
+        return text;
+    return dropLast(text, suffix.length);
+}
 function indentedBy(input, indentedBy) {
     if (input.length > 0 || input.endsWith('\n')) {
         let space = "";
@@ -5103,6 +5270,9 @@ function rightmostIndexOf(array, predicate) {
     });
     return result;
 }
+function removePoints(s) {
+    return s.split(/[\.\-]/g).join('_');
+}
 
 /*
  * Copyright (c) 2025 Huawei Device Co., Ltd.
@@ -7046,6 +7216,9 @@ class Config {
     static get constPostfix() {
         return `Const`;
     }
+    static get ptrPostfix() {
+        return `Ptr`;
+    }
     static get nodeTypeAttribute() {
         return `Es2pandaAstNodeType`;
     }
@@ -7115,10 +7288,10 @@ class BridgesConstructions {
         return `result`;
     }
     static stringConstructor(name) {
-        return `StageArena::strdup(${name})`;
+        return `StageArena::Strdup(${name})`;
     }
     static sequenceConstructor(first, length) {
-        return `StageArena::cloneVector(${first}, ${length})`;
+        return `StageArena::CloneVector(${first}, ${length})`;
     }
     static referenceTypeCast(type) {
         return `reinterpret_cast<${type}>`;
@@ -7259,6 +7432,7 @@ function dropPrefix(value, toDrop) {
  */
 function peerMethod(name) {
     name = dropPostfix(name, Config.constPostfix);
+    name = dropPostfix(name, Config.ptrPostfix);
     name = dropPrefix(name, Config.uselessPrefix);
     name = pascalToCamel(name);
     return name;
@@ -7281,7 +7455,7 @@ function splitCreateOrUpdate(fullName) {
 }
 function mangleIfKeyword(name) {
     if (InteropConstructions.keywords.includes(name)) {
-        return `_${name}`;
+        return `_${name}_`;
     }
     return name;
 }
@@ -7336,7 +7510,7 @@ function isImplInterface(name) {
 function fixEnumPrefix(name) {
     if (name.startsWith(`es2panda_`)) {
         name = dropPrefix(name, `es2panda_`);
-        name = `Es2panda${name}`;
+        name = `Es2panda${capitalize(name)}`;
     }
     return name;
 }
@@ -7391,6 +7565,10 @@ function nodeNamespace(node) {
     var _a;
     return (_a = getNamespacesPathFor(node)[0]) === null || _a === void 0 ? void 0 : _a.name;
 }
+/**
+ * Returns a fully qualified name for a node with no exceptions.
+ * @note Primarily used to pass a name to Config' options.
+*/
 function fqName(node) {
     return getQualifiedName(node, "namespace.name");
 }
@@ -7469,6 +7647,23 @@ function flatParentsImpl(ref, resolveReference) {
     }
     return result; // with self
 }
+function makeFullyQualifiedName(node, resolveReference) {
+    if (isReferenceType(node)) {
+        const decl = resolveReference(node);
+        // No throw bc a lot of handwritten code may appear.
+        return decl ? makeFullyQualifiedName(decl) : node.name;
+    }
+    return getNamespacesPathFor(node)
+        .filter(n => n.name !== Config.irNamespace)
+        .map(n => n.name)
+        .concat(dropPrefix(node.name, Config.dataClassPrefix))
+        .join('.');
+}
+/**
+ * If namespaces of the reference and resolved declaration
+ * are the same, non-qualified name is returned. Otherwise, a fully qualified.
+ * @note 'ir' namespace is ignored and treated as global namespace.
+ */
 function makeEnoughQualifiedName(ref, resolveReference) {
     const decl = resolveReference(ref);
     if (!decl) {
@@ -7539,6 +7734,12 @@ class Typechecker {
         }
         return entry;
     }
+    resolveRecursive(ref) {
+        const decl = this.resolveReference(ref);
+        return decl && isTypedef(decl) && isReferenceType(decl.type)
+            ? this.resolveRecursive(decl.type)
+            : decl;
+    }
     flatParents(ref) {
         const resolveReference = (ref, pov) => 
         // TODO: idlize/core version, change to ours after testing
@@ -7603,7 +7804,14 @@ class Typechecker {
         return declaration !== undefined && isTarget(declaration);
     }
     isConstReturnValue(node) {
-        if (isPrimitiveType(node.returnType) || this.isReferenceTo(node.returnType, isEnum)) {
+        const isPrimitive = (returnType) => {
+            var _a;
+            const type = isReferenceType(returnType)
+                ? (_a = this.resolveReference(returnType)) !== null && _a !== void 0 ? _a : throwException(`Unresolved type ${returnType.name}`)
+                : returnType;
+            return isPrimitiveType(type) || isEnum(type) || (isTypedef(type) && isPrimitive(type.type));
+        };
+        if (isPrimitive(node.returnType)) {
             return false;
         }
         return node.name.endsWith(Config.constPostfix);
@@ -7650,6 +7858,7 @@ class SingleFilePrinter extends AbstractVisitor {
         this.typechecker = new Typechecker(this.idl);
     }
     printEnum(node) { }
+    printTypedef(node) { }
     visit(node) {
         if (isInterface(node) && !this.filterInterface(node)) {
             this.printInterface(node);
@@ -7657,6 +7866,9 @@ class SingleFilePrinter extends AbstractVisitor {
         if (isEnum(node)) {
             this.printEnum(node);
         }
+        if (isTypedef(node)) {
+            this.printTypedef(node);
+        }
         this.visitChildren(node);
     }
     prologue() { }
@@ -7676,6 +7888,89 @@ class SingleFilePrinter extends AbstractVisitor {
     }
 }
 
+class Filter {
+    static makeMethod(name, returnType, parameters, modifiers, isNullable) {
+        const params = Filter.filterParameters(parameters);
+        return makeMethod(name, params.map(p => ({
+            name: p.name,
+            type: this.makeOptionalType(p, isNullable),
+            isOptional: p.isOptional
+        })), this.makeOptionalType(returnType, isNullable), modifiers);
+    }
+    static makeOptionalType(param, isNullable) {
+        const type = isParameter(param) ? param.type : param;
+        return isNullable(param) ? createOptionalType(type) : type;
+    }
+    static isNullableType(type, typechecker) {
+        return isReferenceType(type) &&
+            (typechecker.isPeer(type) || type.name === Config.astNodeCommonAncestor);
+    }
+    static filterMoreSpecific(methods) {
+        const ifaceName = methods.length && methods[0].parent && isInterface(methods[0].parent) ? methods[0].parent.name : '';
+        const compat = ['ETSTuple', 'ExportNamedDeclaration'];
+        const noCopyCtor = methods
+            .filter(m => !(m.parameters.length === 2 && isContext(m.parameters[0]) && m.parameters[1].name === 'other'));
+        if (compat.includes(ifaceName)) {
+            return methods;
+        }
+        // This is a simplified algo of UniversalCreateTransformer
+        return noCopyCtor.length ? [
+            noCopyCtor.reduce((prev, curr) => curr.parameters.length > prev.parameters.length ? curr : prev, noCopyCtor[0])
+        ] : noCopyCtor;
+    }
+    static filterParameters(params) {
+        return Filter.removeArrayLengthParam(Filter.removeContextParam(params));
+    }
+    static filterMethods(methods) {
+        const names = new Set(methods.map(m => m.name));
+        const others = methods
+            .filter(method => {
+            const bareName = dropSuffix(dropSuffix(method.name, Config.constPostfix), Config.ptrPostfix);
+            // no suffix -> ptr -> const
+            return bareName === method.name ||
+                (method.name.endsWith(Config.ptrPostfix) && !names.has(bareName)) ||
+                (method.name.endsWith(Config.constPostfix) &&
+                    !names.has(bareName) && !names.has(`${bareName}${Config.ptrPostfix}`));
+        });
+        return others;
+    }
+    static isOptional(param, typechecker) {
+        return isReferenceType(param.type) &&
+            (typechecker.isPeer(param.type) || param.type.name === Config.astNodeCommonAncestor);
+    }
+    static isArrayLengthParam(param) {
+        return isPrimitiveType(param.type) &&
+            ['u32', 'i32', 'u64', 'i64'].includes(param.type.name) &&
+            ['Len', 'Count', 'Num', 'argc'].some(m => param.name.endsWith(m));
+    }
+    static findArrayLengthParam(parameters, startIndex = 0) {
+        let seqInd = parameters.findIndex((p, index) => index >= startIndex && isSequence(p.type));
+        while (seqInd !== -1) {
+            if (seqInd > 0 && this.isArrayLengthParam(parameters[seqInd - 1])) {
+                return seqInd - 1;
+            }
+            if (seqInd + 1 < parameters.length && this.isArrayLengthParam(parameters[seqInd + 1])) {
+                return seqInd + 1;
+            }
+            seqInd = parameters.findIndex((p, index) => index >= (startIndex + seqInd + 1) && isSequence(p.type));
+        }
+        return -1;
+    }
+    static removeArrayLengthParam(parameters) {
+        const params = [...parameters];
+        let index = this.findArrayLengthParam(params);
+        while (index !== -1) {
+            params.splice(index, 1);
+            index = this.findArrayLengthParam(params, index);
+        }
+        return params;
+    }
+    static removeContextParam(parameters) {
+        const first = parameters.at(0);
+        return first && isContext(first) ? parameters.slice(1) : [...parameters];
+    }
+}
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -7707,7 +8002,8 @@ class InteropPrinter extends AbstractVisitor {
         this.visitChildren(node);
     }
     visitInterface(node) {
-        node.methods.forEach(it => this.visitMethod(node, it));
+        Filter.filterMethods(node.methods)
+            .forEach(it => this.visitMethod(node, it));
     }
     visitMethod(iface, node) {
         this.printMethod(iface, node);
@@ -7763,9 +8059,13 @@ class BaseTypeConvertor {
         return this.convertTypeReference(type);
     }
     convertTypeReference(type) {
-        if (this.typechecker.isReferenceTo(type, isEnum)) {
+        const declaration = this.typechecker.resolveReference(type);
+        if (declaration && isEnum(declaration)) {
             return this.conversions.enum(type);
         }
+        else if (declaration && isTypedef(declaration)) {
+            return this.convertType(declaration.type);
+        }
         return this.conversions.reference(type);
     }
     convertOptional(type) {
@@ -8002,9 +8302,11 @@ class BridgesPrinter extends InteropPrinter {
             return;
         const [methodName, signature] = BridgesPrinter.makeFunctionDeclaration(iface, node, this.returnTypeConvertor);
         this.writer.writeFunctionImplementation(BridgesConstructions.implFunction(methodName), signature, (_) => {
+            var _a;
             let pandaMethodName = BridgesConstructions.callMethod(methodName);
             if (this.config.irHack.isIrHackInterface(iface.name)) {
-                pandaMethodName = pandaMethodName.replace(iface.name, `${iface.name}Ir`);
+                const nsName = (_a = nodeNamespace(iface)) !== null && _a !== void 0 ? _a : 'ir';
+                pandaMethodName = pandaMethodName.replace(iface.name, `${iface.name}${capitalize(nsName)}`);
             }
             this.printBody(node, signature, pandaMethodName);
         });
@@ -8094,6 +8396,90 @@ function id(value) {
     return value;
 }
 
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TopLevelTypeConvertor extends BaseTypeConvertor {
+    constructor(typechecker, heirConversions) {
+        super(typechecker, Object.assign(Object.assign({}, heirConversions), {
+            i8: heirConversions.number,
+            iu8: heirConversions.number,
+            i16: heirConversions.number,
+            i32: heirConversions.number,
+            iu32: heirConversions.number,
+            i64: heirConversions.number,
+            iu64: heirConversions.number,
+            f32: heirConversions.number,
+            f64: heirConversions.number,
+            void: heirConversions.void,
+            boolean: heirConversions.boolean,
+            pointer: heirConversions.pointer,
+            undefined: heirConversions.undefined
+        }));
+    }
+}
+
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class _LibraryTypeConvertor extends TopLevelTypeConvertor {
+    constructor(typechecker) {
+        super(typechecker, {
+            enum: (type) => type.name,
+            reference: (type) => type.name,
+            sequence: (type) => `readonly ${this.convertType(innerType(type))}[]`,
+            optional: (type) => `${this.convertType(type.type)} | undefined`,
+            string: (type) => `string`,
+            number: (type) => `number`,
+            void: (type) => `void`,
+            boolean: (type) => `boolean`,
+            pointer: (type) => `KNativePointer`,
+            undefined: (type) => `undefined`
+        });
+    }
+}
+class LibraryTypeConvertor extends _LibraryTypeConvertor {
+    constructor(typechecker, fullQualified = false) {
+        super(typechecker);
+        this.fullQualified = fullQualified;
+    }
+    convertTypeReference(type) {
+        const node = this.typechecker.resolveReference(type);
+        if (node && (isEnum(node) || isTypedef(node))) {
+            if (node.name.startsWith(Config.dataClassPrefix)) {
+                // TODO: support enums in namespace?
+                return fixEnumPrefix(node.name);
+            }
+        }
+        const resolver = this.typechecker.resolveReference.bind(this.typechecker);
+        return this.fullQualified
+            ? makeFullyQualifiedName(type, resolver)
+            : makeEnoughQualifiedName(type, resolver);
+    }
+}
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -8111,7 +8497,17 @@ function id(value) {
 class EnumsPrinter extends SingleFilePrinter {
     constructor() {
         super(...arguments);
-        this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => { throwException(`Unexpected call to covert type`); } });
+        this.converter = new LibraryTypeConvertor(this.typechecker);
+        this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), {
+            convert: (node) => {
+                if (isUnionType(node)) {
+                    // TODO: core implementation, it is better tor use the
+                    // whole converters from core.
+                    return node.types.map(type => this.converter.convertType(type)).join(' | ');
+                }
+                return this.converter.convertType(node);
+            }
+        });
     }
     printInterface(node) { }
     filterInterface(node) {
@@ -8129,6 +8525,9 @@ class EnumsPrinter extends SingleFilePrinter {
             };
         }), { isExport: true });
     }
+    printTypedef(node) {
+        this.writer.writeTypeDeclaration(createTypedef(fixEnumPrefix(node.name), node.type, node.typeParameters));
+    }
 }
 
 /*
@@ -8365,6 +8764,9 @@ class PeersConstructions {
     static get arrayOfPointersToArrayOfPeers() {
         return `unpackNodeArray`;
     }
+    static get arrayOfPointersToArrayOfObjects() {
+        return `unpackNativeObjectArray`;
+    }
     static get receiveString() {
         return `unpackString`;
     }
@@ -8436,8 +8838,7 @@ class PeersConstructions {
  * limitations under the License.
  */
 class Importer {
-    constructor(typechecker, dir, self) {
-        this.typechecker = typechecker;
+    constructor(dir, self) {
         this.dir = dir;
         this.writer = createDefaultTypescriptWriter();
         this.seen = new Set([
@@ -8448,11 +8849,11 @@ class Importer {
             this.seen.add(self);
         }
     }
-    withPeerImport(ref, context) {
-        const name = makeEnoughQualifiedName(ref, this.typechecker.resolveReference.bind(this.typechecker));
+    withPeerImport(name) {
         const fq = name.split('.');
         // import namespace name for fq names
-        return this.withPeerImport2(fq.length > 1 ? fq.slice(0, -1).join('.') : name);
+        this.withPeerImport2(fq.length > 1 ? fq.slice(0, -1).join('.') : name);
+        return name;
     }
     withPeerImport2(it) {
         if (this.seen.has(it)) {
@@ -8491,40 +8892,6 @@ class Importer {
     }
 }
 
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class TopLevelTypeConvertor extends BaseTypeConvertor {
-    constructor(typechecker, heirConversions) {
-        super(typechecker, Object.assign(Object.assign({}, heirConversions), {
-            i8: heirConversions.number,
-            iu8: heirConversions.number,
-            i16: heirConversions.number,
-            i32: heirConversions.number,
-            iu32: heirConversions.number,
-            i64: heirConversions.number,
-            iu64: heirConversions.number,
-            f32: heirConversions.number,
-            f64: heirConversions.number,
-            void: heirConversions.void,
-            boolean: heirConversions.boolean,
-            pointer: heirConversions.pointer,
-            undefined: heirConversions.undefined
-        }));
-    }
-}
-
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -8582,8 +8949,10 @@ class BindingParameterTypeConvertor extends TopLevelTypeConvertor {
 function unpackWrapper(type, typechecker) {
     const isAstNode = (ref) => (isReferenceType(ref) || isInterface(ref)) && typechecker.isHeir(ref, Config.astNodeCommonAncestor);
     if (isContainerType(type)) {
-        if (IDLContainerUtils.isSequence(type)) {
-            return PeersConstructions.arrayOfPointersToArrayOfPeers;
+        if (IDLContainerUtils.isSequence(type) && isReferenceType(type.elementType[0])) {
+            return isAstNode(type.elementType[0])
+                ? PeersConstructions.arrayOfPointersToArrayOfPeers
+                : PeersConstructions.arrayOfPointersToArrayOfObjects;
         }
         throwException(`unexpected container of non-sequence type`);
     }
@@ -8624,6 +8993,11 @@ function typeHintArgument(type, typechecker, importer) {
     }
     return undefined;
 }
+function hasFactoryArgument(wrapper) {
+    return [
+        PeersConstructions.arrayOfPointersToArrayOfObjects,
+    ].includes(wrapper);
+}
 
 class CommonGenerator {
     static resolveProperty(property, iface, typechecker) {
@@ -8687,83 +9061,6 @@ class CommonGenerator {
     }
 }
 
-class Filter {
-    static makeMethod(name, returnType, parameters, modifiers, isNullable) {
-        const params = Filter.filterParameters(parameters);
-        return makeMethod(name, params.map(p => ({
-            name: p.name,
-            type: this.makeOptionalType(p, isNullable),
-            isOptional: p.isOptional
-        })), this.makeOptionalType(returnType, isNullable), modifiers);
-    }
-    static makeOptionalType(param, isNullable) {
-        const type = isParameter(param) ? param.type : param;
-        return isNullable(param) ? createOptionalType(type) : type;
-    }
-    static isNullableType(type, typechecker) {
-        return isReferenceType(type) &&
-            (typechecker.isPeer(type) || type.name === Config.astNodeCommonAncestor);
-    }
-    static filterMoreSpecific(methods) {
-        const ifaceName = methods.length && methods[0].parent && isInterface(methods[0].parent) ? methods[0].parent.name : '';
-        const compat = ['ETSTuple', 'ExportNamedDeclaration'];
-        const noCopyCtor = methods
-            .filter(m => !(m.parameters.length === 2 && isContext(m.parameters[0]) && m.parameters[1].name === 'other'));
-        if (compat.includes(ifaceName)) {
-            return methods;
-        }
-        // This is a simplified algo of UniversalCreateTransformer
-        return noCopyCtor.length ? [
-            noCopyCtor.reduce((prev, curr) => curr.parameters.length > prev.parameters.length ? curr : prev, noCopyCtor[0])
-        ] : noCopyCtor;
-    }
-    static filterParameters(params) {
-        return Filter.removeArrayLengthParam(Filter.removeContextParam(params));
-    }
-    static filterMethods(methods) {
-        const names = new Set(methods.map(m => m.name));
-        const others = methods
-            .filter(method => !method.name.endsWith(Config.constPostfix) ||
-            !names.has(method.name.slice(0, -Config.constPostfix.length)));
-        return others;
-    }
-    static isOptional(param, typechecker) {
-        return isReferenceType(param.type) &&
-            (typechecker.isPeer(param.type) || param.type.name === Config.astNodeCommonAncestor);
-    }
-    static isArrayLengthParam(param) {
-        return isPrimitiveType(param.type) &&
-            ['u32', 'i32', 'u64', 'i64'].includes(param.type.name) &&
-            ['Len', 'Count', 'Num', 'argc'].some(m => param.name.endsWith(m));
-    }
-    static findArrayLengthParam(parameters, startIndex = 0) {
-        let seqInd = parameters.findIndex((p, index) => index >= startIndex && isSequence(p.type));
-        while (seqInd !== -1) {
-            if (seqInd > 0 && this.isArrayLengthParam(parameters[seqInd - 1])) {
-                return seqInd - 1;
-            }
-            if (seqInd + 1 < parameters.length && this.isArrayLengthParam(parameters[seqInd + 1])) {
-                return seqInd + 1;
-            }
-            seqInd = parameters.findIndex((p, index) => index >= (startIndex + seqInd + 1) && isSequence(p.type));
-        }
-        return -1;
-    }
-    static removeArrayLengthParam(parameters) {
-        const params = [...parameters];
-        let index = this.findArrayLengthParam(params);
-        while (index !== -1) {
-            params.splice(index, 1);
-            index = this.findArrayLengthParam(params, index);
-        }
-        return params;
-    }
-    static removeContextParam(parameters) {
-        const first = parameters.at(0);
-        return first && isContext(first) ? parameters.slice(1) : [...parameters];
-    }
-}
-
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -8799,9 +9096,10 @@ class PeerPrinter {
     printPeer(iface, writer) {
         var _a;
         const _parent = (_a = iface.inheritance[0]) !== null && _a !== void 0 ? _a : createReferenceType(Config.defaultAncestor);
+        const parentName = makeEnoughQualifiedName(_parent, this.typechecker.resolveReference.bind(this.typechecker));
         this.importer.addSeen(PeersConstructions.peerName(iface.name));
         writer.writeClass(PeersConstructions.peerName(iface.name), // XXX: Change peer name to iface.name
-        (writer) => this.printBody(iface, writer), this.importer.withPeerImport(_parent));
+        (writer) => this.printBody(iface, writer), this.importer.withPeerImport(parentName));
     }
     printBody(iface, writer) {
         this.printConstructor(iface, writer);
@@ -8916,6 +9214,9 @@ class PeerPrinter {
         const innerType = innerTypeCommon(returnType);
         if (wrapper) {
             const args = [nativeCall];
+            if (hasFactoryArgument(wrapper) && isReferenceType(innerType)) {
+                args.push(this.makeNativeObjectFactory(innerType, writer));
+            }
             if (hasTypeHintArgument(wrapper)) {
                 const hint = typeHintArgument(innerType, this.typechecker, this.importer);
                 if (hint) {
@@ -8925,8 +9226,16 @@ class PeerPrinter {
             return writer.makeFunctionCall(wrapper, args);
         }
         const convertName = (ref) => makeEnoughQualifiedName(ref, this.typechecker.resolveReference.bind(this.typechecker));
-        return isOptionalType(returnType) && isReferenceType(innerType) ?
-            writer.makeNewObject(convertName(innerType), [nativeCall]) : nativeCall;
+        const resolvedType = isReferenceType(innerType) ? this.typechecker.resolveRecursive(innerType) : innerType;
+        return isReferenceType(innerType) && resolvedType && isInterface(resolvedType)
+            ? writer.makeNewObject(convertName(innerType), [nativeCall]) : nativeCall;
+    }
+    makeNativeObjectFactory(type, writer) {
+        const args = [{ name: 'peer', type: IDLPointerType }];
+        const stmts = [
+            writer.makeReturn(writer.makeNewObject(makeEnoughQualifiedName(type, this.typechecker.resolveReference.bind(this.typechecker)), args.map(a => writer.makeString(a.name))))
+        ];
+        return writer.makeLambda(NamedMethodSignature.make(type, args), stmts);
     }
     printCreateOrUpdate(iface, node, writer) {
         const extraParameters = CommonGenerator.makeExtraParameters(iface, this.config, this.typechecker);
@@ -9023,61 +9332,21 @@ function convertAndImport(importer, converter, type, config) {
         if (node && isEnum(node)) {
             importer.withEnumImport(result);
         }
+        else if (node && isTypedef(node)) {
+            importer.withEnumImport(result); // typedefs print as enums
+        }
         else if (node && isInterface(node) && converter.typechecker.isPeer(node)) {
             if (config.ignore.hasReexportReplacement(fqName(node))) {
                 importer.withReexportImport(dropPrefix(type.name, Config.dataClassPrefix));
             }
             else {
-                importer.withPeerImport(type);
+                importer.withPeerImport(result);
             }
         }
     }
     return result;
 }
 
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class _LibraryTypeConvertor extends TopLevelTypeConvertor {
-    constructor(typechecker) {
-        super(typechecker, {
-            enum: (type) => type.name,
-            reference: (type) => type.name,
-            sequence: (type) => `readonly ${this.convertType(innerType(type))}[]`,
-            optional: (type) => `${this.convertType(type.type)} | undefined`,
-            string: (type) => `string`,
-            number: (type) => `number`,
-            void: (type) => `void`,
-            boolean: (type) => `boolean`,
-            pointer: (type) => `KNativePointer`,
-            undefined: (type) => `undefined`
-        });
-    }
-}
-class LibraryTypeConvertor extends _LibraryTypeConvertor {
-    convertTypeReference(type) {
-        const node = this.typechecker.resolveReference(type);
-        if (node && isEnum(node)) {
-            if (node.name.startsWith(Config.dataClassPrefix)) {
-                // TODO: support enums in namespace?
-                return `Es2panda${node.name.slice(Config.dataClassPrefix.length)}`;
-            }
-        }
-        return makeEnoughQualifiedName(type, this.typechecker.resolveReference.bind(this.typechecker));
-    }
-}
-
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -9108,9 +9377,13 @@ class AllPeersPrinter extends MultiFilePrinter {
         if (members.length === 0) {
             return [];
         }
-        return [this.printFile(ns.name, [ns.name], (printer, writer) => {
+        return [this.printFile(ns.name, [ns.name], (printer, writer, importer) => {
+                ns.members // Is ns.* a typo or it really needed?
+                    .filter(isInterface)
+                    .forEach(iface => importer.addSeen(iface.name)); // Do not import classes from this namespace
                 writer.pushNamespace(ns.name, { ident: false });
-                members.forEach(m => printer.printInterface(m, writer));
+                this.sortInterfaces(members)
+                    .forEach(m => printer.printInterface(m, writer));
                 writer.popNamespace({ ident: false });
             })];
     }
@@ -9125,13 +9398,16 @@ class AllPeersPrinter extends MultiFilePrinter {
                 writer.popNamespace({ ident: false });
             });
         }
-        return this.printFile(iface.name, ['*'], (printer, writer) => printer.printInterface(iface, writer));
+        return this.printFile(iface.name, ['*'], (printer, writer, importer) => {
+            importer.addSeen(PeersConstructions.peerName(iface.name));
+            printer.printInterface(iface, writer);
+        });
     }
     printFile(name, exports, cb) {
-        const importer = new Importer(this.typechecker, '.', name);
+        const importer = new Importer('.', name);
         const writer = this.makeWriter(importer);
         const printer = new PeerPrinter(this.config, this.typechecker, importer);
-        cb(printer, writer);
+        cb(printer, writer, importer);
         return {
             exports: exports,
             fileName: PeersConstructions.fileName(name),
@@ -9159,6 +9435,22 @@ class AllPeersPrinter extends MultiFilePrinter {
         };
         return visitInterfaces(this.idl);
     }
+    /**
+     * Sort interfaces in order of inheritance.
+     */
+    sortInterfaces(ifaces) {
+        const sorted = [];
+        ifaces.forEach((iface) => {
+            const parents = this.typechecker.flatParents(iface);
+            parents.reverse().forEach(p => {
+                const index = sorted.findIndex(ps => p.name === ps.name);
+                if (index === -1) {
+                    sorted.push(p);
+                }
+            });
+        });
+        return sorted;
+    }
     makeWriter(importer) {
         const converter = {
             convert: (node) => convertAndImport(importer, new LibraryTypeConvertor(this.typechecker), node, this.config)
@@ -9244,8 +9536,8 @@ class FactoryPrinter extends SingleFilePrinter {
     constructor(config, idl) {
         super(idl);
         this.config = config;
-        this.importer = new Importer(this.typechecker, `peers`);
-        this.converter = new LibraryTypeConvertor(this.typechecker);
+        this.importer = new Importer(`peers`);
+        this.converter = new LibraryTypeConvertor(this.typechecker, true /* fq names */);
         this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), {
             convert: (node) => convertAndImport(this.importer, this.converter, node, this.config)
         });
@@ -9291,7 +9583,7 @@ class FactoryPrinter extends SingleFilePrinter {
             type: Filter.makeOptionalType(p.type, isNullable),
             isOptional: p.isOptional
         })), createReferenceType(node.name));
-        this.writer.writeMethodImplementation(new Method(PeersConstructions.universalCreate(node.name), signature), () => this.writer.writeStatement(this.writer.makeReturn(this.writer.makeFunctionCall(this.callUniversalCreate(node, universalName), signature.argNames
+        this.writer.writeMethodImplementation(new Method(PeersConstructions.universalCreate(node.name), signature), () => this.writer.writeStatement(this.writer.makeReturn(this.writer.makeStaticMethodCall(makeFullyQualifiedName(node), PeersConstructions.createOrUpdate(node.name, universalName), signature.argNames
             .map(mangleIfKeyword)
             .map(it => this.writer.makeString(it))))));
     }
@@ -9323,7 +9615,7 @@ class FactoryPrinter extends SingleFilePrinter {
             if (parameters.length) {
                 writer.writeStatement(writer.makeCondition(expr(isSameAll), writer.makeReturn(expr(FactoryConstructions.original))));
             }
-            const createCall = writer.makeFunctionCall(this.callUniversalCreate(node, universalName), parameters
+            const createCall = writer.makeStaticMethodCall(makeFullyQualifiedName(node), PeersConstructions.createOrUpdate(node.name, universalName), parameters
                 .concat(extraParameters)
                 .map(p => expr(mangleIfKeyword(p.name))));
             writer.writeStatement(writer.makeReturn(writer.makeFunctionCall(FactoryConstructions.updateNodeByNode, [
@@ -9331,9 +9623,6 @@ class FactoryPrinter extends SingleFilePrinter {
             ])));
         });
     }
-    callUniversalCreate(node, name) {
-        return PeersConstructions.callPeerMethod(node.name, PeersConstructions.createOrUpdate(node.name, name));
-    }
     gettersForParams(params, methods) {
         const toTypeName = (type) => {
             const rawType = isOptionalType(type) ? type.type : type;
@@ -9530,7 +9819,7 @@ class DynamicEmitter {
         this.generatorVersion = `Unknown`;
         this.logDir = `./out/log-idl`;
         this.logCount = 0;
-        this.bridgesPrinter = new SingleFileEmitter((idl) => new BridgesPrinter(this.config, idl).print(), `libarkts/generated/native/bridges.cc`, `bridges.cc`, true);
+        this.bridgesPrinter = new SingleFileEmitter((idl) => new BridgesPrinter(this.config, idl).print(), `libarkts/generated/native/bridges.cpp`, `bridges.cpp`, true);
         this.bindingsPrinter = new SingleFileEmitter((idl) => new BindingsPrinter(idl).print(), `libarkts/generated/Es2pandaNativeModule.ts`, `Es2pandaNativeModule.ts`, true);
         this.enumsPrinter = new SingleFileEmitter((idl) => new EnumsPrinter(idl).print(), `libarkts/generated/Es2pandaEnums.ts`, `Es2pandaEnums.ts`, true);
         this.indexPrinter = new SingleFileEmitter((idl) => new IndexPrinter(this.config, idl).print(), // overriden below