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

package/lib/index.js

@@ -778,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;
@@ -2032,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) {
@@ -2184,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;
     }
@@ -2371,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`, []);
     }
@@ -2382,7 +2393,7 @@ class LanguageWriter {
     makeCallIsObject(value) {
         return this.makeString(`typeof ${value} === "object"`);
     }
-    makeStaticBlock(op) {
+    writeStaticEntitiesBlock(op) {
         op(this);
     }
     instanceOf(value, type) {
@@ -2712,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;
@@ -3026,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();
@@ -3347,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();
@@ -5216,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 = "";
@@ -7197,6 +7216,9 @@ class Config {
     static get constPostfix() {
         return `Const`;
     }
+    static get ptrPostfix() {
+        return `Ptr`;
+    }
     static get nodeTypeAttribute() {
         return `Es2pandaAstNodeType`;
     }
@@ -7410,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;
@@ -7432,7 +7455,7 @@ function splitCreateOrUpdate(fullName) {
 }
 function mangleIfKeyword(name) {
     if (InteropConstructions.keywords.includes(name)) {
-        return `_${name}`;
+        return `_${name}_`;
     }
     return name;
 }
@@ -7487,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;
 }
@@ -7624,19 +7647,16 @@ function flatParentsImpl(ref, resolveReference) {
     }
     return result; // with self
 }
-/**
- * A fully qualified of a type that reference points to.
- * @note 'ir' namespace is ignored and treated as global namespace.
- */
-function makeFullyQualifiedName(ref, resolveReference) {
-    const decl = resolveReference(ref);
-    if (!decl) {
-        return ref.name;
+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(decl)
+    return getNamespacesPathFor(node)
         .filter(n => n.name !== Config.irNamespace)
         .map(n => n.name)
-        .concat(decl.name)
+        .concat(dropPrefix(node.name, Config.dataClassPrefix))
         .join('.');
 }
 /**
@@ -7714,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
@@ -7778,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);
@@ -7825,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);
@@ -7832,6 +7866,9 @@ class SingleFilePrinter extends AbstractVisitor {
         if (isEnum(node)) {
             this.printEnum(node);
         }
+        if (isTypedef(node)) {
+            this.printTypedef(node);
+        }
         this.visitChildren(node);
     }
     prologue() { }
@@ -7851,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");
@@ -7882,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);
@@ -7938,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) {
@@ -8177,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);
         });
@@ -8269,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");
@@ -8286,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) {
@@ -8304,6 +8525,9 @@ class EnumsPrinter extends SingleFilePrinter {
             };
         }), { isExport: true });
     }
+    printTypedef(node) {
+        this.writer.writeTypeDeclaration(createTypedef(fixEnumPrefix(node.name), node.type, node.typeParameters));
+    }
 }
 
 /*
@@ -8540,6 +8764,9 @@ class PeersConstructions {
     static get arrayOfPointersToArrayOfPeers() {
         return `unpackNodeArray`;
     }
+    static get arrayOfPointersToArrayOfObjects() {
+        return `unpackNativeObjectArray`;
+    }
     static get receiveString() {
         return `unpackString`;
     }
@@ -8665,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");
@@ -8756,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`);
     }
@@ -8798,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) {
@@ -8861,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");
@@ -9091,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) {
@@ -9100,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);
@@ -9198,6 +9332,9 @@ 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));
@@ -9210,56 +9347,6 @@ function convertAndImport(importer, converter, type, config) {
     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 {
-    constructor(typechecker, fullQualified = false) {
-        super(typechecker);
-        this.fullQualified = fullQualified;
-    }
-    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)}`;
-            }
-        }
-        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");
@@ -9290,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 });
             })];
     }
@@ -9307,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('.', 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),
@@ -9341,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)
@@ -9473,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))))));
     }
@@ -9505,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, [
@@ -9513,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;