@idlizer/core 2.0.19 → 2.0.21

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

@@ -19,7 +19,7 @@ import { RuntimeType } from "./common";
 import { generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
-import { InteropNameConvertor } from "./InteropConvertor";
+import { InteropNameConvertor } from "./convertors/InteropConvertors";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { CppInteropConvertor } from "./convertors/CppConvertors";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";

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

@@ -273,6 +273,7 @@ export declare abstract class LanguageWriter {
     writeStatement(stmt: LanguageStatement): void;
     writeStatements(...statements: LanguageStatement[]): void;
     writeExpressionStatement(smth: LanguageExpression): void;
+    writeExpressionStatements(...statements: LanguageExpression[]): void;
     writeStaticBlock(op: (writer: this) => void): void;
     makeRef(type: idl.IDLType, _options?: MakeRefOptions): idl.IDLType;
     makeThis(): LanguageExpression;

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

@@ -437,6 +437,9 @@ export class LanguageWriter {
     writeExpressionStatement(smth) {
         this.writeStatement(new ExpressionStatement(smth));
     }
+    writeExpressionStatements(...statements) {
+        statements.forEach(it => this.writeExpressionStatement(it));
+    }
     writeStaticBlock(op) {
         this.print("static {");
         this.pushIndent();

package/build/lib/src/LanguageWriters/convertors/CJConvertors.d.ts

@@ -1,6 +1,7 @@
 import * as idl from '../../idl';
 import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
 import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+import { InteropArgConvertor } from './InteropConvertors';
 export declare class CJTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
     protected resolver: ReferenceResolver;
     constructor(resolver: ReferenceResolver);
@@ -27,4 +28,7 @@ export declare class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvert
     convert(type: idl.IDLNode): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
+export declare class CJInteropArgConvertor extends InteropArgConvertor {
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+}
 //# sourceMappingURL=CJConvertors.d.ts.map

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

@@ -14,6 +14,7 @@
  */
 import * as idl from '../../idl';
 import { convertNode, convertType } from '../nameConvertor';
+import { InteropArgConvertor } from './InteropConvertors';
 export class CJTypeNameConvertor {
     constructor(resolver) {
         this.resolver = resolver;
@@ -105,7 +106,7 @@ export class CJTypeNameConvertor {
             case idl.IDLF64Type: return 'Float64';
             case idl.IDLPointerType: return 'UInt64';
             case idl.IDLVoidType: return 'Unit';
-            case idl.IDLBufferType: return 'ArrayList<UInt8>';
+            case idl.IDLBufferType: return 'Array<UInt8>';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
@@ -151,4 +152,13 @@ export class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvertor {
         return super.convertPrimitiveType(type);
     }
 }
+export class CJInteropArgConvertor extends InteropArgConvertor {
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLNumberType: return "Float64";
+            case idl.IDLLengthType: return "Ark_Length";
+        }
+        return super.convertPrimitiveType(type);
+    }
+}
 //# sourceMappingURL=CJConvertors.js.map

package/build/lib/src/LanguageWriters/convertors/CppConvertors.d.ts

@@ -1,8 +1,14 @@
 import * as idl from '../../idl';
 import { IdlNameConvertor } from "../nameConvertor";
-import { InteropConvertor } from '../InteropConvertor';
+import { InteropConvertor } from './InteropConvertors';
+import { InteropArgConvertor } from './InteropConvertors';
 export declare class CppInteropConvertor extends InteropConvertor implements IdlNameConvertor {
     private unwrap;
     convert(node: idl.IDLNode): string;
 }
+export declare class CppInteropArgConvertor extends InteropArgConvertor {
+    static INSTANCE: CppInteropArgConvertor;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+}
 //# sourceMappingURL=CppConvertors.d.ts.map

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

@@ -14,7 +14,9 @@
  */
 import * as idl from '../../idl';
 import { generatorConfiguration } from "../../config";
-import { InteropConvertor } from '../InteropConvertor';
+import { InteropConvertor } from './InteropConvertors';
+import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
+import { InteropArgConvertor } from './InteropConvertors';
 export class CppInteropConvertor extends InteropConvertor {
     unwrap(type, result) {
         const conf = generatorConfiguration();
@@ -34,4 +36,23 @@ export class CppInteropConvertor extends InteropConvertor {
         return this.unwrap(node, this.convertNode(node));
     }
 }
+export class CppInteropArgConvertor extends InteropArgConvertor {
+    convertOptional(type) {
+        return PrimitiveTypesInstance.NativePointer.getText();
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLBooleanType: return PrimitiveTypesInstance.Boolean.getText();
+            case idl.IDLI32Type: return PrimitiveTypesInstance.Int32.getText();
+            case idl.IDLNumberType: return "KInteropNumber";
+            case idl.IDLBufferType: return "Ark_Buffer";
+            case idl.IDLLengthType: return "KLength";
+            case idl.IDLFunctionType: return PrimitiveTypesInstance.Int32.getText();
+            case idl.IDLDate: return PrimitiveTypesInstance.Int64.getText();
+            case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
+        }
+        return super.convertPrimitiveType(type);
+    }
+}
+CppInteropArgConvertor.INSTANCE = new CppInteropArgConvertor();
 //# sourceMappingURL=CppConvertors.js.map

package/build/lib/src/LanguageWriters/convertors/InteropConvertors.d.ts

@@ -0,0 +1,58 @@
+import * as idl from '../../idl';
+import { PeerMethod } from '../../peer-generation/PeerMethod';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { IdlNameConvertor, NodeConvertor, TypeConvertor } from '../nameConvertor';
+export interface ConvertResult {
+    text: string;
+    noPrefix: boolean;
+}
+export declare class InteropConvertor implements NodeConvertor<ConvertResult> {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    private make;
+    convertNode(node: idl.IDLNode): ConvertResult;
+    convertNamespace(node: idl.IDLNamespace): ConvertResult;
+    convertInterface(node: idl.IDLInterface): ConvertResult;
+    convertEnum(node: idl.IDLEnum): ConvertResult;
+    convertTypedef(node: idl.IDLTypedef): ConvertResult;
+    convertCallback(node: idl.IDLCallback): ConvertResult;
+    convertMethod(node: idl.IDLMethod): ConvertResult;
+    convertConstant(node: idl.IDLConstant): ConvertResult;
+    convertOptional(type: idl.IDLOptionalType): ConvertResult;
+    convertUnion(type: idl.IDLUnionType): ConvertResult;
+    convertContainer(type: idl.IDLContainerType): ConvertResult;
+    convertImport(type: idl.IDLReferenceType, _: string): ConvertResult;
+    convertTypeReference(type: idl.IDLReferenceType): ConvertResult;
+    convertTypeParameter(type: idl.IDLTypeParameterType): ConvertResult;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
+    private enumName;
+    private computeTargetTypeLiteralName;
+}
+export declare class InteropNameConvertor implements IdlNameConvertor {
+    protected resolver: ReferenceResolver;
+    private readonly interopConvertor;
+    constructor(resolver: ReferenceResolver);
+    convert(node: idl.IDLNode): string;
+}
+export declare class InteropReturnTypeConvertor implements TypeConvertor<string> {
+    isVoid(method: PeerMethod): boolean;
+    convert(type: idl.IDLType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+}
+export declare class InteropArgConvertor implements TypeConvertor<string> {
+    convert(type: idl.IDLType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+}
+//# sourceMappingURL=InteropConvertors.d.ts.map

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

@@ -0,0 +1,275 @@
+/*
+ * 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.
+ */
+import { generatorConfiguration } from '../../config';
+import * as idl from '../../idl';
+import { qualifiedName } from '../../peer-generation/idl/common';
+import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
+import { capitalize } from '../../util';
+import { maybeTransformManagedCallback } from '../ArgConvertors';
+import { convertNode, convertType } from '../nameConvertor';
+export class InteropConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    make(text, noPrefix = false) {
+        return { text, noPrefix };
+    }
+    convertNode(node) {
+        return convertNode(this, node);
+    }
+    convertNamespace(node) {
+        throw new Error("Internal error: namespaces are not allowed on the interop layer");
+    }
+    convertInterface(node) {
+        switch (node.subkind) {
+            case idl.IDLInterfaceSubkind.AnonymousInterface:
+                return node.name
+                    ? this.make(node.name)
+                    : this.make(this.computeTargetTypeLiteralName(node), true);
+            case idl.IDLInterfaceSubkind.Interface:
+            case idl.IDLInterfaceSubkind.Class:
+                if (idl.hasExtAttribute(node, idl.IDLExtendedAttributes.Predefined)) {
+                    return this.make(node.name, true);
+                }
+                return this.make(node.name);
+            case idl.IDLInterfaceSubkind.Tuple:
+                return node.name
+                    ? this.make(node.name)
+                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
+        }
+    }
+    convertEnum(node) {
+        return this.make(this.enumName(node));
+    }
+    convertTypedef(node) {
+        return this.make(node.name);
+    }
+    convertCallback(node) {
+        return this.make(generatorConfiguration().param("LibraryPrefix") + node.name, true);
+    }
+    convertMethod(node) {
+        return this.make(node.name);
+    }
+    convertConstant(node) {
+        return this.make(node.name);
+    }
+    /////////////////////////////////////////////////////////////////////////////////////////
+    convertOptional(type) {
+        return this.convertNode(type.type);
+    }
+    convertUnion(type) {
+        return this.make(type.name, false);
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isPromise(type)) {
+            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`);
+        }
+        if (idl.IDLContainerUtils.isSequence(type)) {
+            if (type.elementType[0] === idl.IDLU8Type) {
+                return this.make(`uint8_t*`, true);
+            }
+            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, true);
+        }
+        if (idl.IDLContainerUtils.isRecord(type)) {
+            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, true);
+        }
+        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    convertImport(type, _) {
+        return this.make(idl.IDLCustomObjectType.name);
+    }
+    convertTypeReference(type) {
+        var _a;
+        const refName = type.name;
+        switch (refName) {
+            case "object":
+            case "Object":
+                return this.make('CustomObject');
+        }
+        if (generatorConfiguration().paramArray("knownParameterized").includes(refName)) {
+            return this.make('CustomObject');
+        }
+        let decl = this.resolver.toDeclaration(type);
+        if (idl.isCallback(decl)) {
+            decl = (_a = maybeTransformManagedCallback(decl)) !== null && _a !== void 0 ? _a : decl;
+        }
+        if (idl.isType(decl)) {
+            if (idl.isReferenceType(decl)) {
+                return this.make(`${capitalize(decl.name)}`);
+            }
+            return this.convertNode(decl);
+        }
+        let res = this.convertNode(decl);
+        if (type.name === "Optional")
+            res = this.make("Opt_" + res.text, true);
+        return res;
+    }
+    convertTypeParameter(type) {
+        return this.make('CustomObject');
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLVoidType: return this.make('void', true);
+            case idl.IDLI8Type: return this.make(`Int8`);
+            case idl.IDLU8Type: return this.make(`UInt8`);
+            case idl.IDLI16Type: return this.make(`Int16`);
+            case idl.IDLU16Type: return this.make(`UInt16`);
+            case idl.IDLI32Type: return this.make(`Int32`);
+            case idl.IDLU32Type: return this.make(`UInt32`);
+            case idl.IDLI64Type: return this.make(`Int64`);
+            case idl.IDLU64Type: return this.make(`UInt64`);
+            case idl.IDLF32Type: return this.make(`Float32`);
+            case idl.IDLF64Type: return this.make(`Float64`);
+            case idl.IDLNumberType: return this.make(`Number`);
+            case idl.IDLStringType: return this.make(`String`);
+            case idl.IDLBooleanType: return this.make(`Boolean`);
+            case idl.IDLPointerType: return this.make('NativePointer');
+            case idl.IDLUnknownType:
+            case idl.IDLCustomObjectType:
+            case idl.IDLAnyType: return this.make(`CustomObject`);
+            case idl.IDLUndefinedType: return this.make(`Undefined`);
+            case idl.IDLLengthType: return this.make(`Length`);
+            case idl.IDLFunctionType: return this.make(`Function`);
+            case idl.IDLDate: return this.make(`Date`);
+            case idl.IDLBufferType: return this.make('Buffer');
+            case idl.IDLPointerType: return this.make('Pointer');
+        }
+        throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    enumName(target) {
+        return qualifiedName(target, "_");
+    }
+    computeTargetTypeLiteralName(decl) {
+        const map = new Map();
+        for (const prop of decl.properties) {
+            const type = this.convertNode(prop.type);
+            const values = map.has(type.text) ? map.get(type.text) : [];
+            values.push(prop.name);
+            map.set(type.text, values);
+        }
+        const names = Array.from(map.keys()).map(key => `${key}_${map.get(key).join('_')}`);
+        return `Literal_${names.join('_')}`;
+    }
+}
+export class InteropNameConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+        this.interopConvertor = new InteropConvertor(resolver);
+    }
+    convert(node) {
+        return this.interopConvertor.convertNode(node).text;
+    }
+}
+export class InteropReturnTypeConvertor {
+    isVoid(method) {
+        return this.convert(method.returnType) === idl.IDLVoidType.name;
+    }
+    convert(type) {
+        return convertType(this, type);
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isSequence(type) || idl.IDLContainerUtils.isPromise(type)) {
+            // TODO return array by some way
+            return "void";
+        }
+        else
+            return PrimitiveTypesInstance.NativePointer.getText();
+    }
+    convertImport(type, importClause) {
+        throw new Error(`Cannot pass import type ${type.name} through interop`);
+    }
+    convertOptional(type) {
+        return this.convert(type.type);
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLI8Type:
+            case idl.IDLU8Type:
+            case idl.IDLI16Type:
+            case idl.IDLU16Type:
+            case idl.IDLI32Type:
+            case idl.IDLU32Type:
+            case idl.IDLI64Type:
+            case idl.IDLU64Type:
+            case idl.IDLF16Type:
+            case idl.IDLF32Type:
+            case idl.IDLF64Type:
+            case idl.IDLNumberType: return PrimitiveTypesInstance.Int32.getText();
+            case idl.IDLBooleanType: return PrimitiveTypesInstance.Boolean.getText();
+            case idl.IDLAnyType:
+            case idl.IDLBufferType:
+            case idl.IDLStringType:
+            case idl.IDLThisType:
+            case idl.IDLUndefinedType:
+            case idl.IDLUnknownType:
+            case idl.IDLVoidType: return idl.IDLVoidType.name;
+            case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
+        }
+        throw new Error(`Cannot pass primitive type ${type.name} through interop`);
+    }
+    convertTypeParameter(type) {
+        return idl.IDLVoidType.name;
+    }
+    convertTypeReference(type) {
+        if (type.name.endsWith("Attribute"))
+            return idl.IDLVoidType.name;
+        return PrimitiveTypesInstance.NativePointer.getText();
+    }
+    convertUnion(type) {
+        return PrimitiveTypesInstance.NativePointer.getText();
+    }
+}
+export class InteropArgConvertor {
+    convert(type) {
+        return convertType(this, type);
+    }
+    convertContainer(type) {
+        throw new Error(`Cannot pass container types through interop`);
+    }
+    convertImport(type, importClause) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
+    convertOptional(type) {
+        return "KNativePointer";
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLI32Type: return "KInt";
+            case idl.IDLF32Type: return "KFloat";
+            case idl.IDLNumberType: return 'number';
+            case idl.IDLBigintType: return 'bigint';
+            case idl.IDLBooleanType:
+            case idl.IDLFunctionType: return 'KInt';
+            case idl.IDLStringType: return 'KStringPtr';
+            case idl.IDLBufferType: return `ArrayBuffer`;
+            case idl.IDLLengthType: return 'Length';
+            case idl.IDLDate: return 'KLong';
+            case idl.IDLUndefinedType:
+            case idl.IDLVoidType: return PrimitiveTypesInstance.NativePointer.getText();
+            case idl.IDLPointerType: return "KPointer"; //PrimitiveType.NativePointer.getText()
+        }
+        throw new Error(`Cannot pass primitive type ${type.name} through interop`);
+    }
+    convertTypeParameter(type) {
+        throw new Error("Cannot pass type parameters through interop");
+    }
+    convertTypeReference(type) {
+        throw new Error(`Cannot pass type references through interop`);
+    }
+    convertUnion(type) {
+        throw new Error("Cannot pass union types through interop");
+    }
+}
+//# sourceMappingURL=InteropConvertors.js.map

package/build/lib/src/LanguageWriters/convertors/JavaConvertors.d.ts

@@ -1,6 +1,7 @@
 import * as idl from '../../idl';
 import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
 import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+import { InteropArgConvertor } from './InteropConvertors';
 export declare class JavaTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
     private resolver;
     constructor(resolver: ReferenceResolver);
@@ -28,5 +29,8 @@ declare class JavaIdlNodeToSolidStringConvertor extends JavaTypeNameConvertor {
     protected solidConvertor: import("../../util").Lazy<this>;
     convertContainer(type: idl.IDLContainerType): string;
 }
+export declare class JavaInteropArgConvertor extends InteropArgConvertor {
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+}
 export {};
 //# sourceMappingURL=JavaConvertors.d.ts.map

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

@@ -15,6 +15,7 @@
 import * as idl from '../../idl';
 import { lazy } from '../../util';
 import { convertNode, convertType } from '../nameConvertor';
+import { InteropArgConvertor } from './InteropConvertors';
 function convertJavaOptional(type) {
     switch (type) {
         case 'boolean': return 'Opt_Boolean';
@@ -172,4 +173,14 @@ class JavaIdlNodeToSolidStringConvertor extends JavaTypeNameConvertor {
         throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
     }
 }
+export class JavaInteropArgConvertor extends InteropArgConvertor {
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLNumberType: return "double";
+            case idl.IDLLengthType: return "String";
+            case idl.IDLBooleanType: return "boolean";
+        }
+        return super.convertPrimitiveType(type);
+    }
+}
 //# sourceMappingURL=JavaConvertors.js.map

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

@@ -126,6 +126,8 @@ export class TSTypeNameConvertor {
             case idl.IDLBooleanType: return 'boolean';
             case idl.IDLI32Type:
                 return 'int32';
+            case idl.IDLF32Type:
+                return 'float32';
             case idl.IDLI8Type:
             case idl.IDLU8Type:
             case idl.IDLI16Type:
@@ -133,7 +135,6 @@ export class TSTypeNameConvertor {
             case idl.IDLU32Type:
             case idl.IDLI64Type:
             case idl.IDLU64Type:
-            case idl.IDLF32Type:
             case idl.IDLF64Type:
             case idl.IDLNumberType:
                 return 'number';

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

@@ -1,3 +1,8 @@
+import { Language } from "../Language";
+import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+import { InteropArgConvertor } from "./convertors/InteropConvertors";
+import { LanguageWriter } from "./LanguageWriter";
 export * from "./nameConvertor";
-export * from "./InteropConvertor";
+export declare function createLanguageWriter(language: Language, resolver?: ReferenceResolver): LanguageWriter;
+export declare function createInteropArgConvertor(language: Language): InteropArgConvertor;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,3 +1,40 @@
+import { IndentedPrinter } from "../IndentedPrinter";
+import { Language } from "../Language";
+import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
+import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
+import { CJIDLTypeToForeignStringConvertor, CJInteropArgConvertor, CJTypeNameConvertor } from "./convertors/CJConvertors";
+import { CppInteropArgConvertor, CppInteropConvertor } from "./convertors/CppConvertors";
+import { ETSTypeNameConvertor } from "./convertors/ETSConvertors";
+import { InteropArgConvertor } from "./convertors/InteropConvertors";
+import { JavaInteropArgConvertor, JavaTypeNameConvertor } from "./convertors/JavaConvertors";
+import { TSTypeNameConvertor } from "./convertors/TSConvertors";
+import { CJLanguageWriter } from "./writers/CJLanguageWriter";
+import { CppLanguageWriter } from "./writers/CppLanguageWriter";
+import { ETSLanguageWriter } from "./writers/ETSLanguageWriter";
+import { JavaLanguageWriter } from "./writers/JavaLanguageWriter";
+import { TSLanguageWriter } from "./writers/TsLanguageWriter";
 export * from "./nameConvertor";
-export * from "./InteropConvertor";
+export function createLanguageWriter(language, resolver) {
+    resolver !== null && resolver !== void 0 ? resolver : (resolver = EmptyReferenceResolver);
+    const printer = new IndentedPrinter();
+    switch (language) {
+        case Language.TS: return new TSLanguageWriter(printer, resolver, new TSTypeNameConvertor(resolver));
+        case Language.ARKTS: return new ETSLanguageWriter(printer, resolver, new ETSTypeNameConvertor(resolver), new CppInteropConvertor(resolver));
+        case Language.JAVA: return new JavaLanguageWriter(printer, resolver, new JavaTypeNameConvertor(resolver));
+        case Language.CPP: return new CppLanguageWriter(printer, resolver, new CppInteropConvertor(resolver), PrimitiveTypesInstance);
+        case Language.CJ: return new CJLanguageWriter(printer, resolver, new CJTypeNameConvertor(resolver), new CJIDLTypeToForeignStringConvertor(resolver));
+        default: throw new Error(`Language ${language.toString()} is not supported`);
+    }
+}
+export function createInteropArgConvertor(language) {
+    switch (language) {
+        case Language.TS:
+        case Language.ARKTS: return new InteropArgConvertor();
+        case Language.CPP: return CppInteropArgConvertor.INSTANCE;
+        case Language.JAVA: return new JavaInteropArgConvertor();
+        case Language.CJ: return new CJInteropArgConvertor();
+    }
+    throw new Error(`InteropArgConvertor for language ${language} not implemented`);
+}
+const EmptyReferenceResolver = createEmptyReferenceResolver();
 //# sourceMappingURL=index.js.map

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

@@ -329,7 +329,7 @@ export class CJLanguageWriter extends LanguageWriter {
         const init = initExpr != undefined ? ` = ${initExpr.asString()}` : ``;
         name = this.escapeKeyword(name);
         let prefix = this.makeFieldModifiersList(modifiers);
-        this.printer.print(`${prefix ? prefix.concat(" ") : ""}var ${name}: ${this.getNodeName(type)}${init}`);
+        this.printer.print(`${prefix ? prefix.concat(" ") : ""}var ${name}: ${this.getNodeName(idl.maybeOptional(type, optional))}${init}`);
     }
     writeMethodDeclaration(name, signature, modifiers) {
         this.writeDeclaration(name, signature, modifiers);
@@ -395,6 +395,7 @@ export class CJLanguageWriter extends LanguageWriter {
     }
     writeNativeMethodDeclaration(name, signature) {
         let signture = `${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.typeForeignConvertor.convert(it)}`).join(", ")}`;
+        name = name.startsWith('_') ? name.slice(1) : name;
         this.print(`func ${name}(${signture}): ${this.typeForeignConvertor.convert(signature.returnType)}`);
     }
     makeEnumCast(enumName, _unsafe, _convertor) {

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

@@ -37,7 +37,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
     getNodeName(type: idl.IDLNode): string;
-    writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean): void;
+    writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isAbstract?: boolean): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], isDeclared?: boolean): void;
     writeFunctionDeclaration(name: string, signature: MethodSignature): void;
     writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;

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

@@ -135,11 +135,13 @@ export class TSLanguageWriter extends LanguageWriter {
     getNodeName(type) {
         return this.typeConvertor.convert(type);
     }
-    writeClass(name, op, superClass, interfaces, generics, isDeclared) {
+    writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? ` extends ${superClass}` : '';
         let implementsClause = interfaces ? ` implements ${interfaces.join(",")}` : '';
-        const genericsClause = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : '';
-        this.printer.print(`export${isDeclared ? " declare" : ""} class ${name}${genericsClause}${extendsClause}${implementsClause} {`);
+        let genericsClause = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : '';
+        let declaredClause = isDeclared ? ` declare` : '';
+        let abstractClause = isAbstract ? ` abstract` : '';
+        this.printer.print(`export${declaredClause}${abstractClause} class ${name}${genericsClause}${extendsClause}${implementsClause} {`);
         this.pushIndent();
         op(this);
         this.popIndent();
@@ -165,7 +167,8 @@ export class TSLanguageWriter extends LanguageWriter {
     }
     generateFunctionDeclaration(name, signature) {
         const args = signature.args.map((it, index) => `${signature.argName(index)}${idl.isOptionalType(it) ? '?' : ''}: ${this.getNodeName(it)}`);
-        return `export function ${name}(${args.join(", ")})`;
+        const returnType = this.getNodeName(signature.returnType);
+        return `export function ${name}(${args.join(", ")}): ${returnType}`;
     }
     writeEnum(name, members) {
         this.printer.print(`export enum ${name} {`);

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

@@ -2,6 +2,12 @@ export interface GeneratorConfiguration {
     param<T>(name: string): T;
     paramArray<T>(name: string): T[];
 }
+export declare class BaseGeneratorConfiguration implements GeneratorConfiguration {
+    protected params: Record<string, any>;
+    constructor(params?: Record<string, any>);
+    param<T>(name: string): T;
+    paramArray<T>(name: string): T[];
+}
 export declare function setDefaultConfiguration(config: GeneratorConfiguration): void;
 export declare function generatorConfiguration(): GeneratorConfiguration;
 export declare function generatorTypePrefix(): string;

package/build/lib/src/config.js

@@ -12,15 +12,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class EmptyGeneratorConfiguration {
+export class BaseGeneratorConfiguration {
+    constructor(params = {}) {
+        this.params = {};
+        Object.assign(this.params, params);
+    }
     param(name) {
+        if (name in this.params) {
+            return this.params[name];
+        }
         throw new Error(`${name} is unknown`);
     }
     paramArray(name) {
-        throw new Error(`array ${name} is unknown`);
+        if (name in this.params) {
+            return this.params[name];
+        }
+        throw new Error(`${name} is unknown`);
     }
 }
-let currentConfig = new EmptyGeneratorConfiguration();
+let currentConfig = new BaseGeneratorConfiguration();
 export function setDefaultConfiguration(config) {
     currentConfig = config;
 }

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

@@ -1,6 +1,7 @@
 export * from "./config";
 export * from "./configMerge";
 export * from "./idl";
+export * from "./visitor";
 export * from "./library";
 export * from "./idlize";
 export * from "./inheritance";
@@ -15,18 +16,19 @@ export * from "./LanguageWriters/LanguageWriter";
 export * from "./LanguageWriters/ArgConvertors";
 export * from "./LanguageWriters/common";
 export * from "./LanguageWriters/nameConvertor";
-export * from "./LanguageWriters/InteropConvertor";
 export * from "./LanguageWriters/convertors/CppConvertors";
 export * from "./LanguageWriters/convertors/TSConvertors";
 export * from "./LanguageWriters/convertors/ETSConvertors";
 export * from "./LanguageWriters/convertors/JavaConvertors";
 export * from "./LanguageWriters/convertors/CJConvertors";
+export * from "./LanguageWriters/convertors/InteropConvertors";
 export * from "./LanguageWriters/writers/CJLanguageWriter";
 export * from "./LanguageWriters/writers/CLikeLanguageWriter";
 export * from "./LanguageWriters/writers/CppLanguageWriter";
 export * from "./LanguageWriters/writers/JavaLanguageWriter";
 export * from "./LanguageWriters/writers/TsLanguageWriter";
 export * from "./LanguageWriters/writers/ETSLanguageWriter";
+export * from "./LanguageWriters/nameConvertor";
 export * from "./peer-generation/idl/IdlNameConvertor";
 export * from "./peer-generation/LayoutManager";
 export * from "./peer-generation/PrimitiveType";

package/build/lib/src/index.js

@@ -15,6 +15,7 @@
 export * from "./config";
 export * from "./configMerge";
 export * from "./idl";
+export * from "./visitor";
 export * from "./library";
 export * from "./idlize";
 export * from "./inheritance";
@@ -29,18 +30,19 @@ export * from "./LanguageWriters/LanguageWriter";
 export * from "./LanguageWriters/ArgConvertors";
 export * from "./LanguageWriters/common";
 export * from "./LanguageWriters/nameConvertor";
-export * from "./LanguageWriters/InteropConvertor";
 export * from "./LanguageWriters/convertors/CppConvertors";
 export * from "./LanguageWriters/convertors/TSConvertors";
 export * from "./LanguageWriters/convertors/ETSConvertors";
 export * from "./LanguageWriters/convertors/JavaConvertors";
 export * from "./LanguageWriters/convertors/CJConvertors";
+export * from "./LanguageWriters/convertors/InteropConvertors";
 export * from "./LanguageWriters/writers/CJLanguageWriter";
 export * from "./LanguageWriters/writers/CLikeLanguageWriter";
 export * from "./LanguageWriters/writers/CppLanguageWriter";
 export * from "./LanguageWriters/writers/JavaLanguageWriter";
 export * from "./LanguageWriters/writers/TsLanguageWriter";
 export * from "./LanguageWriters/writers/ETSLanguageWriter";
+export * from "./LanguageWriters/nameConvertor";
 export * from "./peer-generation/idl/IdlNameConvertor";
 export * from "./peer-generation/LayoutManager";
 export * from "./peer-generation/PrimitiveType";

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

@@ -1,15 +1,15 @@
-import { IDLNode } from "../idl";
+import { IDLEntry } from "../idl";
 export declare enum LayoutNodeRole {
     PEER = 0,
     INTERFACE = 1
 }
 export interface LayoutManagerStrategy {
-    resolve(node: IDLNode, role: LayoutNodeRole): string;
+    resolve(node: IDLEntry, role: LayoutNodeRole): string;
 }
 export declare class LayoutManager {
     private strategy;
     constructor(strategy: LayoutManagerStrategy);
-    resolve(node: IDLNode, role: LayoutNodeRole): string;
+    resolve(node: IDLEntry, role: LayoutNodeRole): string;
     static Empty(): LayoutManager;
 }
 //# sourceMappingURL=LayoutManager.d.ts.map

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

@@ -42,12 +42,14 @@ export declare class MaterializedClass implements PeerClassBase {
     readonly interfaces: idl.IDLReferenceType[] | undefined;
     readonly generics: string[] | undefined;
     readonly fields: MaterializedField[];
-    readonly ctor: MaterializedMethod;
-    readonly finalizer: MaterializedMethod;
+    readonly ctor: MaterializedMethod | undefined;
+    readonly finalizer: MaterializedMethod | undefined;
     readonly methods: MaterializedMethod[];
     readonly needBeGenerated: boolean;
     readonly taggedMethods: idl.IDLMethod[];
-    constructor(decl: idl.IDLInterface, className: string, isInterface: boolean, superClass: idl.IDLReferenceType | undefined, interfaces: idl.IDLReferenceType[] | undefined, generics: string[] | undefined, fields: MaterializedField[], ctor: MaterializedMethod, finalizer: MaterializedMethod, methods: MaterializedMethod[], needBeGenerated?: boolean, taggedMethods?: idl.IDLMethod[]);
+    constructor(decl: idl.IDLInterface, className: string, isInterface: boolean, superClass: idl.IDLReferenceType | undefined, interfaces: idl.IDLReferenceType[] | undefined, generics: string[] | undefined, fields: MaterializedField[], ctor: MaterializedMethod | undefined, // undefined when used for global functions
+    finalizer: MaterializedMethod | undefined, // undefined when used for global functions
+    methods: MaterializedMethod[], needBeGenerated?: boolean, taggedMethods?: idl.IDLMethod[]);
     getComponentName(): string;
     getImplementationName(): string;
     generatedName(isCallSignature: boolean): string;

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

@@ -134,7 +134,9 @@ export function copyMaterializedMethod(method, overrides) {
     return copied;
 }
 export class MaterializedClass {
-    constructor(decl, className, isInterface, superClass, interfaces, generics, fields, ctor, finalizer, methods, needBeGenerated = true, taggedMethods = []) {
+    constructor(decl, className, isInterface, superClass, interfaces, generics, fields, ctor, // undefined when used for global functions
+    finalizer, // undefined when used for global functions
+    methods, needBeGenerated = true, taggedMethods = []) {
         this.decl = decl;
         this.className = className;
         this.isInterface = isInterface;

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

@@ -1,5 +1,6 @@
 import * as idl from '../idl';
 import { Language } from '../Language';
+import { LanguageWriter } from '../LanguageWriters/LanguageWriter';
 import { IdlNameConvertor } from '../LanguageWriters';
 import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
 import { LibraryInterface } from '../LibraryInterface';
@@ -24,6 +25,7 @@ export declare class PeerLibrary implements LibraryInterface {
     constructor(language: Language);
     name: string;
     readonly customComponentMethods: string[];
+    createLanguageWriter(language?: Language): LanguageWriter;
     createTypeNameConvertor(language: Language): IdlNameConvertor;
     protected readonly targetNameConvertorInstance: IdlNameConvertor;
     private readonly interopNameConvertorInstance;

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

@@ -15,13 +15,15 @@
 import { warn } from 'console';
 import * as idl from '../idl';
 import { Language } from '../Language';
-import { InteropNameConvertor } from '../LanguageWriters';
+import { createLanguageWriter } from '../LanguageWriters';
 import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ClassConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, } from "../LanguageWriters/ArgConvertors";
+import { InteropNameConvertor } from '../LanguageWriters/convertors/InteropConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppInteropConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { ETSTypeNameConvertor } from '../LanguageWriters/convertors/ETSConvertors';
 import { JavaTypeNameConvertor } from '../LanguageWriters/convertors/JavaConvertors';
 import { TSTypeNameConvertor } from '../LanguageWriters/convertors/TSConvertors';
+import { isBuilderClass } from './BuilderClass';
 import { generateSyntheticFunctionName, isImportAttr } from './idl/common';
 import { isMaterialized } from './Materialized';
 import { LayoutManager } from './LayoutManager';
@@ -53,6 +55,9 @@ export class PeerLibrary {
         this.targetNameConvertorInstance = this.createTypeNameConvertor(this.language);
         this.interopNameConvertorInstance = new InteropNameConvertor(this);
     }
+    createLanguageWriter(language) {
+        return createLanguageWriter(language !== null && language !== void 0 ? language : this.language, this);
+    }
     createTypeNameConvertor(language) {
         switch (language) {
             case Language.TS: return new TSTypeNameConvertor(this);
@@ -243,11 +248,13 @@ export class PeerLibrary {
             if (isMaterialized(declaration, this)) {
                 return new MaterializedClassConvertor(param, declaration);
             }
+            if (isBuilderClass(declaration)) {
+                return new ClassConvertor(this, declarationName, param, declaration);
+            }
             switch (declaration.subkind) {
                 case idl.IDLInterfaceSubkind.Interface:
-                    return new InterfaceConvertor(this, declarationName, param, declaration);
                 case idl.IDLInterfaceSubkind.Class:
-                    return new ClassConvertor(this, declarationName, param, declaration);
+                    return new InterfaceConvertor(this, declarationName, param, declaration);
                 case idl.IDLInterfaceSubkind.AnonymousInterface:
                     return new AggregateConvertor(this, param, type, declaration);
                 case idl.IDLInterfaceSubkind.Tuple:

package/build/lib/src/peer-generation/idl/IdlNameConvertor.js

@@ -41,7 +41,10 @@ export class DeclarationNameConvertor {
 DeclarationNameConvertor.I = new DeclarationNameConvertor();
 export class TSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl) {
-        return `${idl.getNamespacesPathFor(decl).join('')}${decl.name}`;
+        const namespace = idl.getNamespacesPathFor(decl).map(it => it.name);
+        if (namespace.length > 0)
+            return namespace[0];
+        return decl.name;
     }
 }
 TSFeatureNameConvertor.I = new TSFeatureNameConvertor();

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

@@ -0,0 +1,43 @@
+import * as idl from './idl';
+import { ReferenceResolver } from './peer-generation/ReferenceResolver';
+export interface IDLConverter<T> {
+    visitOptional(type: idl.IDLOptionalType): T;
+    visitUnion(type: idl.IDLUnionType): T;
+    visitContainer(type: idl.IDLContainerType): T;
+    visitImport(type: idl.IDLReferenceType, importClause: string): T;
+    visitTypeReference(type: idl.IDLReferenceType): T;
+    visitTypeParameter(type: idl.IDLTypeParameterType): T;
+    visitPrimitiveType(type: idl.IDLPrimitiveType): T;
+    visitNamespace(node: idl.IDLNamespace): T;
+    visitInterface(node: idl.IDLInterface): T;
+    visitEnum(node: idl.IDLEnum): T;
+    visitTypedef(node: idl.IDLTypedef): T;
+    visitCallback(node: idl.IDLCallback): T;
+    visitMethod(node: idl.IDLMethod): T;
+    visitProperty(node: idl.IDLProperty): T;
+    visitConstant(node: idl.IDLConstant): T;
+}
+export declare function walkIDL<T>(convertor: IDLConverter<T>, node: idl.IDLNode): T;
+export declare class IDLDependencyCollector implements IDLConverter<idl.IDLNode[]> {
+    private readonly resolver;
+    constructor(resolver: ReferenceResolver);
+    visitOptional(type: idl.IDLOptionalType): idl.IDLNode[];
+    visitUnion(type: idl.IDLUnionType): idl.IDLNode[];
+    visitContainer(type: idl.IDLContainerType): idl.IDLNode[];
+    visitImport(type: idl.IDLReferenceType): idl.IDLNode[];
+    visitTypeReference(type: idl.IDLReferenceType): idl.IDLNode[];
+    visitTypeParameter(): idl.IDLNode[];
+    visitPrimitiveType(): idl.IDLNode[];
+    visitNamespace(decl: idl.IDLNamespace): idl.IDLNode[];
+    visitInterface(decl: idl.IDLInterface): idl.IDLNode[];
+    protected visitSupertype(type: idl.IDLType | idl.IDLInterface): idl.IDLNode[];
+    visitEnum(): idl.IDLNode[];
+    visitTypedef(decl: idl.IDLTypedef): idl.IDLNode[];
+    visitCallback(decl: idl.IDLCallback): idl.IDLNode[];
+    visitMethod(decl: idl.IDLMethod): idl.IDLNode[];
+    visitProperty(node: idl.IDLProperty): idl.IDLNode[];
+    visitConstant(decl: idl.IDLConstant): idl.IDLNode[];
+    walk(node?: idl.IDLNode): idl.IDLNode[];
+}
+export declare function collectDependencies(resolver: ReferenceResolver, node: idl.IDLNode): idl.IDLNode[];
+//# sourceMappingURL=visitor.d.ts.map

package/build/lib/src/visitor.js

@@ -0,0 +1,143 @@
+/*
+ * 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.
+ */
+import * as idl from './idl';
+export function walkIDL(convertor, node) {
+    if (idl.isNamespace(node))
+        return convertor.visitNamespace(node);
+    if (idl.isInterface(node))
+        return convertor.visitInterface(node);
+    if (idl.isEnum(node))
+        return convertor.visitEnum(node);
+    if (idl.isEnumMember(node))
+        return convertor.visitEnum(node.parent);
+    if (idl.isTypedef(node))
+        return convertor.visitTypedef(node);
+    if (idl.isCallback(node))
+        return convertor.visitCallback(node);
+    if (idl.isMethod(node))
+        return convertor.visitMethod(node);
+    if (idl.isProperty(node))
+        return convertor.visitProperty(node);
+    if (idl.isConstant(node))
+        return convertor.visitConstant(node);
+    if (idl.isOptionalType(node))
+        return convertor.visitOptional(node);
+    if (idl.isUnionType(node))
+        return convertor.visitUnion(node);
+    if (idl.isContainerType(node))
+        return convertor.visitContainer(node);
+    if (idl.isReferenceType(node)) {
+        const importAttr = idl.getExtAttribute(node, idl.IDLExtendedAttributes.Import);
+        return importAttr
+            ? convertor.visitImport(node, importAttr)
+            : convertor.visitTypeReference(node);
+    }
+    if (idl.isTypeParameterType(node))
+        return convertor.visitTypeParameter(node);
+    if (idl.isPrimitiveType(node))
+        return convertor.visitPrimitiveType(node);
+    throw new Error(`Unknown kind ${idl.IDLKind[node.kind]}`);
+}
+////////////////////////////////////////////////////////////////////////////
+export class IDLDependencyCollector {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    visitOptional(type) {
+        return this.walk(type.type);
+    }
+    visitUnion(type) {
+        return type.types.flatMap(ty => this.walk(ty));
+    }
+    visitContainer(type) {
+        return type.elementType.flatMap(ty => this.walk(ty));
+    }
+    visitImport(type) {
+        const maybeDecl = this.resolver.resolveTypeReference(type);
+        return maybeDecl ? [maybeDecl] : [];
+    }
+    visitTypeReference(type) {
+        const decl = this.resolver.resolveTypeReference(type);
+        const result = !decl ? []
+            : idl.isEnumMember(decl) ? [decl.parent] : [decl];
+        if (type.typeArguments) {
+            result.push(...type.typeArguments.flatMap(it => this.walk(it)));
+        }
+        return result;
+    }
+    visitTypeParameter() {
+        return [];
+    }
+    visitPrimitiveType() {
+        return [];
+    }
+    visitNamespace(decl) {
+        return decl.members.flatMap(it => this.walk(it));
+    }
+    visitInterface(decl) {
+        return [
+            ...decl.inheritance
+                .filter(it => it !== idl.IDLTopType)
+                .flatMap(it => this.visitSupertype(it)),
+            ...decl.properties
+                .filter(it => !it.isStatic)
+                .flatMap(it => this.walk(it.type)),
+            ...[...decl.constructors, ...decl.callables, ...decl.methods]
+                .flatMap(it => [
+                ...it.parameters.flatMap(param => this.walk(param.type)),
+                ...this.walk(it.returnType)
+            ])
+        ];
+    }
+    visitSupertype(type) {
+        if (idl.isInterface(type)) {
+            return this.walk(idl.createReferenceType(type.name, undefined, type));
+        }
+        return this.walk(type);
+    }
+    visitEnum() {
+        return [];
+    }
+    visitTypedef(decl) {
+        return this.walk(decl.type);
+    }
+    visitCallback(decl) {
+        return [
+            ...decl.parameters.flatMap(it => this.walk(it.type)),
+            ...this.walk(decl.returnType),
+        ];
+    }
+    visitMethod(decl) {
+        return [
+            ...decl.parameters.flatMap(it => this.walk(it.type)),
+            ...this.walk(decl.returnType),
+        ];
+    }
+    visitProperty(node) {
+        return this.walk(node.type);
+    }
+    visitConstant(decl) {
+        return this.walk(decl.type);
+    }
+    walk(node) {
+        if (node === undefined)
+            return [];
+        return walkIDL(this, node);
+    }
+}
+export function collectDependencies(resolver, node) {
+    return walkIDL(new IDLDependencyCollector(resolver), node);
+}
+//# sourceMappingURL=visitor.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.0.19",
+  "version": "2.0.21",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,7 +34,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.4.6",
+    "@koalaui/interop": "1.4.8",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },