@idlizer/core 2.0.17 → 2.0.19

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

@@ -0,0 +1,173 @@
+/*
+ * 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';
+import { convertNode } from '../nameConvertor';
+export class TSTypeNameConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    convert(node) {
+        return convertNode(this, node);
+    }
+    convertNamespace(node) {
+        return node.name;
+    }
+    convertInterface(node) {
+        return node.name;
+    }
+    convertEnum(node) {
+        return node.name;
+    }
+    convertTypedef(node) {
+        return node.name;
+    }
+    convertCallback(node) {
+        return node.name;
+    }
+    convertMethod(node) {
+        return node.name;
+    }
+    convertConstant(node) {
+        return node.name;
+    }
+    convertOptional(type) {
+        return `${this.convert(type.type)} | undefined`;
+    }
+    convertUnion(type) {
+        return type.types.
+            map(it => {
+            if (false /* add check if it is function */) {
+                return `(${this.convert(it)})`;
+            }
+            return this.convert(it);
+        })
+            .join(' | ');
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isSequence(type)) {
+            switch (type.elementType[0]) {
+                case idl.IDLU8Type: return 'Uint8Array'; // should be changed to Array
+                case idl.IDLI32Type: return 'Int32Array'; // should be changed to Array
+                case idl.IDLF32Type: return 'KFloat32ArrayPtr'; // should be changed to Array
+                default: return `Array<${this.convert(type.elementType[0])}>`;
+            }
+        }
+        if (idl.IDLContainerUtils.isRecord(type)) {
+            return `Map<${this.convert(type.elementType[0])}, ${this.convert(type.elementType[1])}>`;
+        }
+        if (idl.IDLContainerUtils.isPromise(type)) {
+            return `Promise<${this.convert(type.elementType[0])}>`;
+        }
+        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    convertImport(type, importClause) {
+        return type.name;
+    }
+    convertTypeReference(type) {
+        var _a, _b;
+        let decl = this.resolver.resolveTypeReference(type);
+        if (decl) {
+            if (idl.isSyntheticEntry(decl)) {
+                if (idl.isCallback(decl)) {
+                    return this.mapCallback(decl);
+                }
+                const entity = idl.getExtAttribute(decl, idl.IDLExtendedAttributes.Entity);
+                if (entity) {
+                    const isTuple = entity === idl.IDLEntity.Tuple;
+                    return this.productType(decl, isTuple, !isTuple);
+                }
+            }
+        }
+        // FIXME: isEnumMember is not TYPE!
+        if (decl && idl.isEnumMember(decl) && decl.parent) {
+            // when `interface A { field?: MyEnum.Value1 }` is generated, it is not possible
+            // to deserialize A, because there is no such type information in declaration target
+            // (can not cast MyEnum to exact MyEnum.Value1)
+            decl = decl.parent;
+        }
+        let typeSpec = type.name;
+        let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it))) !== null && _b !== void 0 ? _b : [];
+        if (typeSpec === `Optional`)
+            return `${typeArgs} | undefined`;
+        if (typeSpec === `Function`)
+            return this.mapFunctionType(typeArgs);
+        const maybeTypeArguments = !(typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) ? '' : `<${typeArgs.join(', ')}>`;
+        if (decl) {
+            const path = idl.getNamespacesPathFor(decl).map(it => it.name);
+            path.push(decl.name);
+            return `${path.join(".")}${maybeTypeArguments}`;
+        }
+        return `${type.name}${maybeTypeArguments}`;
+    }
+    convertTypeParameter(type) {
+        return type.name;
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLUnknownType:
+            case idl.IDLCustomObjectType: return 'unknown';
+            case idl.IDLThisType: return 'this';
+            case idl.IDLAnyType: return 'any';
+            case idl.IDLUndefinedType: return 'undefined';
+            case idl.IDLPointerType: return 'KPointer';
+            case idl.IDLVoidType: return 'void';
+            case idl.IDLBooleanType: return 'boolean';
+            case idl.IDLI32Type:
+                return 'int32';
+            case idl.IDLI8Type:
+            case idl.IDLU8Type:
+            case idl.IDLI16Type:
+            case idl.IDLU16Type:
+            case idl.IDLU32Type:
+            case idl.IDLI64Type:
+            case idl.IDLU64Type:
+            case idl.IDLF32Type:
+            case idl.IDLF64Type:
+            case idl.IDLNumberType:
+                return 'number';
+            case idl.IDLBigintType:
+                return 'bigint';
+            case idl.IDLStringType:
+                return 'string';
+            case idl.IDLDate:
+                return 'Date';
+            case idl.IDLBufferType:
+                return `ArrayBuffer`;
+        }
+        throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    processTupleType(idlProperty) {
+        return idlProperty;
+    }
+    mapCallback(decl) {
+        const params = decl.parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}`);
+        return `((${params.join(", ")}) => ${this.convert(decl.returnType)})`;
+    }
+    productType(decl, isTuple, includeFieldNames) {
+        const name = `${isTuple ? "[" : "{"} ${decl.properties
+            .map(it => isTuple ? this.processTupleType(it) : it)
+            .map(it => {
+            const type = this.convert(it.type);
+            return it.isOptional
+                ? includeFieldNames ? `${it.name}?: ${type}` : `(${type})?`
+                : includeFieldNames ? `${it.name}: ${type}` : `${type}`;
+        }).join(", ")} ${isTuple ? "]" : "}"}`;
+        return name;
+    }
+    mapFunctionType(typeArgs) {
+        return `Function${typeArgs.length ? `<${typeArgs.join(",")}>` : ''}`;
+    }
+}
+//# sourceMappingURL=TSConvertors.js.map

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

@@ -315,7 +315,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         return new CppPointerPropertyAccessExpression(expression, name);
     }
     writePrintLog(message) {
-        this.print(`printf("${message}\n")`);
+        this.print(`printf("${message}\\n");`);
     }
     makeDefinedCheck(value) {
         return new CDefinedExpression(value);

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

@@ -1,5 +1,6 @@
 import * as idl from "./idl";
 import { Language } from "./Language";
+import { IdlNameConvertor } from "./LanguageWriters";
 import { ArgConvertor } from "./LanguageWriters/ArgConvertors";
 import { ReferenceResolver } from "./peer-generation/ReferenceResolver";
 export interface LibraryFileInterface {
@@ -11,6 +12,7 @@ export interface LibraryInterface extends ReferenceResolver {
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     getInteropName(node: idl.IDLNode): string;
+    createTypeNameConvertor(language: Language): IdlNameConvertor;
     createContinuationCallbackReference(continuationType: idl.IDLType): idl.IDLReferenceType;
     getCurrentContext(): string | undefined;
     /**

package/build/lib/src/config.js

@@ -1,3 +1,17 @@
+/*
+ * Copyright (c) 2025 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 EmptyGeneratorConfiguration {
     param(name) {
         throw new Error(`${name} is unknown`);

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

@@ -0,0 +1,2 @@
+export declare function deepMergeConfig<T extends object>(defaults: T, custom: Partial<T>): T;
+//# sourceMappingURL=configMerge.d.ts.map

package/build/lib/src/configMerge.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2025 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.
+ */
+function isObject(i) {
+    if (typeof i !== 'object')
+        return false;
+    if (Array.isArray(i))
+        return false;
+    return true;
+}
+export function deepMergeConfig(defaults, custom) {
+    if (custom === undefined)
+        return defaults;
+    const result = Object.assign({}, defaults);
+    for (const key in custom) {
+        if (Object.prototype.hasOwnProperty.call(custom, key)) {
+            const defaultValue = result[key];
+            const customValue = custom[key];
+            if (isObject(defaultValue) && isObject(customValue)) {
+                Object.assign(result, { [key]: deepMergeConfig(defaultValue, customValue) });
+            }
+            else {
+                if (isObject(defaultValue))
+                    throw new Error("Replacing default object value with custom non-object");
+                Object.assign(result, { [key]: customValue });
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=configMerge.js.map

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

@@ -1,5 +1,5 @@
 import { IDLEntry } from "../idl";
-export declare function fromIDL(inputDir: string, inputFile: string | undefined, outputDir: string, extension: string, verbose: boolean, transform: (name: string, content: string) => string): void;
+export declare function fromIDL(inputDirs: string | string[], inputFiles: string | string[] | undefined, outputDir: string, extension: string, verbose: boolean, transform: (name: string, content: string) => string): void;
 export declare function scanIDL(inputDir: string, inputFile: string | undefined): IDLEntry[][];
 export declare const licence = "/*\n * Copyright (c) 2024 Huawei Device Co., Ltd.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n";
 //# sourceMappingURL=common.d.ts.map

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

@@ -30,18 +30,27 @@ function getFilesRecursive(dirPath, arrayOfFiles = []) {
     });
     return arrayOfFiles;
 }
-export function fromIDL(inputDir, inputFile, outputDir, extension, verbose, transform) {
-    inputDir = path.resolve(inputDir);
-    const files = inputFile
-        ? [path.join(inputDir, inputFile)]
-        : getFilesRecursive(inputDir);
-    const results = files
-        .map((file) => transform(file, fs.readFileSync(file).toString()));
-    zip(files, results)
-        .forEach(([fileName, output]) => {
+export function fromIDL(inputDirs, inputFiles, outputDir, extension, verbose, transform) {
+    const resolvedInputDirs = Array.isArray(inputDirs) ? inputDirs.map(dir => path.resolve(dir)) : [path.resolve(inputDirs)];
+    const resolvedInputFiles = Array.isArray(inputFiles)
+        ? inputFiles.map(file => path.resolve(file))
+        : typeof inputFiles === 'string'
+            ? [path.resolve(inputFiles)]
+            : [];
+    let files = [];
+    if (resolvedInputFiles.length > 0) {
+        files = resolvedInputFiles;
+    }
+    else {
+        resolvedInputDirs.forEach(dir => {
+            files = files.concat(getFilesRecursive(dir));
+        });
+    }
+    const results = files.map(file => transform(file, fs.readFileSync(file).toString()));
+    zip(files, results).forEach(([fileName, output]) => {
         fs.mkdirSync(outputDir, { recursive: true });
-        console.log('producing', path.relative(inputDir, fileName));
-        const outFile = path.join(outputDir, path.relative(inputDir, fileName).replace(".idl", extension));
+        console.log('producing', path.relative(resolvedInputDirs[0], fileName));
+        const outFile = path.join(outputDir, path.relative(resolvedInputDirs[0], fileName).replace(".idl", extension));
         if (verbose)
             console.log(output);
         if (!fs.existsSync(path.dirname(outFile))) {

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

@@ -36,6 +36,7 @@ export declare enum IDLEntity {
 export declare enum IDLExtendedAttributes {
     Accessor = "Accessor",
     Async = "Async",
+    ArkTSType = "ArkTSType",
     CallSignature = "CallSignature",
     CJType = "CJType",
     CommonMethod = "CommonMethod",
@@ -54,14 +55,14 @@ export declare enum IDLExtendedAttributes {
     NativeModule = "NativeModule",
     Optional = "Optional",
     OriginalEnumMemberName = "OriginalEnumMemberName",
+    Predefined = "Predefined",
     Protected = "Protected",
     Synthetic = "Synthetic",
     TSType = "TSType",
     TypeArguments = "TypeArguments",
     TypeParameters = "TypeParameters",
     VerbatimDts = "VerbatimDts",
-    HandWrittenImplementation = "HandWrittenImplementation",
-    Predefined = "Predefined"
+    HandWrittenImplementation = "HandWrittenImplementation"
 }
 export declare enum IDLAccessorAttribute {
     Getter = "Getter",
@@ -296,6 +297,8 @@ export declare function createNamespace(name: string, extendedAttributes?: IDLEx
 export declare function linkNamespacesBack(node: IDLNode): void;
 export declare function getNamespacesPathFor(entry: IDLEntry): IDLNamespace[];
 export declare function isEqualByQualifedName(a?: IDLEntry, b?: IDLEntry): boolean;
+export declare function getNamespaceName(a: IDLEntry): string;
+export declare function getFQName(a: IDLEntry): string;
 export declare function createVersion(value: string[], extendedAttributes?: IDLExtendedAttribute[], fileName?: string): IDLVersion;
 export declare function fetchNamespaceFrom(pointOfView?: IDLNode): IDLNamespace | undefined;
 export declare function createReferenceType(name: string, typeArguments?: IDLType[], pointOfView?: IDLNode): IDLReferenceType;
@@ -304,7 +307,7 @@ export declare function entityToType(entity: IDLNode): IDLType;
 export declare function createContainerType(container: IDLContainerKind, element: IDLType[]): IDLContainerType;
 export declare function createUnionType(types: IDLType[], name?: string): IDLUnionType;
 export declare function createPackage(name: string): IDLPackage;
-export declare function createImport(name: string, importClause?: string[]): IDLImport;
+export declare function createImport(name: string, importClause?: string[], nodeInitializer?: IDLNodeInitializer): IDLImport;
 export declare function createEnum(name: string, elements: IDLEnumMember[], nodeInitializer: IDLNodeInitializer): IDLEnum;
 export declare function createEnumMember(name: string, parent: IDLEnum, type: IDLPrimitiveType, initializer: number | string | undefined, nodeInitializer?: IDLNodeInitializer): IDLEnumMember;
 export declare function createInterface(name: string, subkind: IDLInterfaceSubkind, inheritance?: IDLReferenceType[], constructors?: IDLConstructor[], constants?: IDLConstant[], properties?: IDLProperty[], methods?: IDLMethod[], callables?: IDLCallable[], typeParameters?: string[], nodeInitializer?: IDLNodeInitializer): IDLInterface;

package/build/lib/src/idl.js

@@ -56,6 +56,7 @@ export var IDLExtendedAttributes;
 (function (IDLExtendedAttributes) {
     IDLExtendedAttributes["Accessor"] = "Accessor";
     IDLExtendedAttributes["Async"] = "Async";
+    IDLExtendedAttributes["ArkTSType"] = "ArkTSType";
     IDLExtendedAttributes["CallSignature"] = "CallSignature";
     IDLExtendedAttributes["CJType"] = "CJType";
     IDLExtendedAttributes["CommonMethod"] = "CommonMethod";
@@ -74,6 +75,7 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["NativeModule"] = "NativeModule";
     IDLExtendedAttributes["Optional"] = "Optional";
     IDLExtendedAttributes["OriginalEnumMemberName"] = "OriginalEnumMemberName";
+    IDLExtendedAttributes["Predefined"] = "Predefined";
     IDLExtendedAttributes["Protected"] = "Protected";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
     IDLExtendedAttributes["TSType"] = "TSType";
@@ -81,7 +83,6 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
     IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
-    IDLExtendedAttributes["Predefined"] = "Predefined";
 })(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
 export var IDLAccessorAttribute;
 (function (IDLAccessorAttribute) {
@@ -377,6 +378,16 @@ export function isEqualByQualifedName(a, b) {
         return false;
     return isEqualByQualifedName(a.namespace, b.namespace);
 }
+export function getNamespaceName(a) {
+    return getNamespacesPathFor(a).map(it => it.name).join('.');
+}
+export function getFQName(a) {
+    let ns = getNamespaceName(a);
+    if (ns !== '') {
+        ns += '.';
+    }
+    return ns + a.name;
+}
 export function createVersion(value, extendedAttributes, fileName) {
     return {
         kind: IDLKind.Version,
@@ -455,15 +466,8 @@ export function createPackage(name) {
         _idlNamedNodeBrand: innerIdlSymbol,
     };
 }
-export function createImport(name, importClause) {
-    return {
-        kind: IDLKind.Import,
-        name,
-        importClause: importClause,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlEntryBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+export function createImport(name, importClause, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.Import, name, importClause: importClause }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 export function createEnum(name, elements, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Enum, name: name, elements: elements }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });

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

@@ -1,4 +1,4 @@
 import * as ts from "typescript";
 import { GenerateOptions, GenericVisitor } from "./options";
-export declare function generate<T>(inputDirs: string[], inputFile: string | undefined, outputDir: string, visitorFactory: (sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker) => GenericVisitor<T>, options: GenerateOptions<T>): void;
+export declare function generate<T>(inputDirs: string[], inputFiles: string[], outputDir: string, visitorFactory: (sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker) => GenericVisitor<T>, options: GenerateOptions<T>): void;
 //# sourceMappingURL=idlize.d.ts.map

package/build/lib/src/idlize.js

@@ -19,27 +19,69 @@ function readdir(dir) {
     return fs.readdirSync(dir)
         .map(elem => path.join(dir, elem));
 }
-export function generate(inputDirs, inputFile, outputDir, visitorFactory, options) {
+export function generate(inputDirs, inputFiles, outputDir, visitorFactory, options) {
     var _a, _b, _c;
-    let input = inputFile ? [
-        path.join(inputDirs[0], inputFile)
-    ] : inputDirs.flatMap(it => readdir(path.resolve(it)));
-    // Build a program using the set of root file names in fileNames
+    if (options.enableLog) {
+        console.log("Starting generation process...");
+    }
+    if (inputDirs.length === 0 && inputFiles.length === 0) {
+        console.error("Error: No input specified (no directories and no files).");
+        process.exit(1);
+    }
+    const resolvedInputDirs = inputDirs.map(dir => path.resolve(dir));
+    if (options.enableLog) {
+        console.log("Resolved input directories:", resolvedInputDirs);
+    }
+    let input = [];
+    if (resolvedInputDirs.length > 0) {
+        resolvedInputDirs.forEach(dir => {
+            if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
+                if (options.enableLog) {
+                    console.log(`Processing all .d.ts from directory: ${dir}`);
+                }
+                const files = readdir(dir).filter(file => file.endsWith(".d.ts"));
+                input = input.concat(files);
+            }
+            else {
+                console.warn(`Warning: Directory does not exist or is not a directory: ${dir}`);
+            }
+        });
+    }
+    if (inputFiles.length > 0) {
+        inputFiles.forEach(file => {
+            const fullPath = path.resolve(file);
+            if (fs.existsSync(fullPath)) {
+                if (options.enableLog) {
+                    console.log(`Including input file: ${fullPath}`);
+                }
+                input.push(fullPath);
+            }
+            else {
+                console.warn(`Warning: Input file does not exist: ${fullPath}`);
+            }
+        });
+    }
+    input = Array.from(new Set(input.map(p => path.resolve(p)))).sort();
     let program = ts.createProgram(input.concat([path.join(__dirname, "../stdlib.d.ts")]), options.compilerOptions);
-    // Get the checker, we will use it to find more about classes
+    if (options.enableLog) {
+        console.log("Initialized TypeScript program with input files:", input);
+    }
     if (outputDir && !fs.existsSync(outputDir))
         fs.mkdirSync(outputDir, { recursive: true });
     const typeChecker = program.getTypeChecker();
     (_a = options.onBegin) === null || _a === void 0 ? void 0 : _a.call(options, outputDir, typeChecker);
-    // Visit every sourceFile in the program
-    let cared = inputDirs.map(it => path.resolve(it));
     for (const sourceFile of program.getSourceFiles()) {
-        if (!cared.some(it => path.resolve(sourceFile.fileName).indexOf(it) >= 0)) {
-            // console.log("Ignore ", path.resolve(sourceFile.fileName) , "wrt", inputDirs)
+        const resolvedSourceFile = path.resolve(sourceFile.fileName);
+        const isInDir = resolvedInputDirs.some(dir => resolvedSourceFile.startsWith(dir));
+        const isExplicitFile = input.some(f => path.resolve(f) === resolvedSourceFile);
+        if (!isInDir && !isExplicitFile) {
+            if (options.enableLog) {
+                console.log(`Skipping file: ${resolvedSourceFile}`);
+            }
             continue;
         }
-        if (inputFile && path.basename(sourceFile.fileName) != inputFile) {
-            continue;
+        if (options.enableLog) {
+            console.log(`Processing file: ${resolvedSourceFile}`);
         }
         // Walk the tree to search for classes
         const visitor = visitorFactory(sourceFile, typeChecker);
@@ -47,6 +89,8 @@ export function generate(inputDirs, inputFile, outputDir, visitorFactory, option
         (_b = options.onSingleFile) === null || _b === void 0 ? void 0 : _b.call(options, output, outputDir, sourceFile);
     }
     (_c = options.onEnd) === null || _c === void 0 ? void 0 : _c.call(options, outputDir);
-    return;
+    if (options.enableLog) {
+        console.log("Generation completed.");
+    }
 }
 //# sourceMappingURL=idlize.js.map

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

@@ -1,4 +1,5 @@
 export * from "./config";
+export * from "./configMerge";
 export * from "./idl";
 export * from "./library";
 export * from "./idlize";
@@ -16,6 +17,10 @@ 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/writers/CJLanguageWriter";
 export * from "./LanguageWriters/writers/CLikeLanguageWriter";
 export * from "./LanguageWriters/writers/CppLanguageWriter";
@@ -23,7 +28,9 @@ export * from "./LanguageWriters/writers/JavaLanguageWriter";
 export * from "./LanguageWriters/writers/TsLanguageWriter";
 export * from "./LanguageWriters/writers/ETSLanguageWriter";
 export * from "./peer-generation/idl/IdlNameConvertor";
+export * from "./peer-generation/LayoutManager";
 export * from "./peer-generation/PrimitiveType";
+export * from "./peer-generation/PeerLibrary";
 export * from "./peer-generation/PeerFile";
 export * from "./peer-generation/PeerClass";
 export * from "./peer-generation/PeerMethod";

package/build/lib/src/index.js

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 export * from "./config";
+export * from "./configMerge";
 export * from "./idl";
 export * from "./library";
 export * from "./idlize";
@@ -30,6 +31,10 @@ 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/writers/CJLanguageWriter";
 export * from "./LanguageWriters/writers/CLikeLanguageWriter";
 export * from "./LanguageWriters/writers/CppLanguageWriter";
@@ -37,7 +42,9 @@ export * from "./LanguageWriters/writers/JavaLanguageWriter";
 export * from "./LanguageWriters/writers/TsLanguageWriter";
 export * from "./LanguageWriters/writers/ETSLanguageWriter";
 export * from "./peer-generation/idl/IdlNameConvertor";
+export * from "./peer-generation/LayoutManager";
 export * from "./peer-generation/PrimitiveType";
+export * from "./peer-generation/PeerLibrary";
 export * from "./peer-generation/PeerFile";
 export * from "./peer-generation/PeerClass";
 export * from "./peer-generation/PeerMethod";

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

@@ -4,6 +4,7 @@ export interface GenerateOptions<T> {
     onBegin?: (outDir: string, typeChecker: ts.TypeChecker) => void;
     onSingleFile?: (entries: T, outDir: string, inputFile: ts.SourceFile) => void;
     onEnd?: (outDir: string) => void;
+    enableLog?: boolean;
 }
 export interface GenericVisitor<T> {
     visitWholeFile(): T;

package/build/lib/src/peer-generation/LanguageWriters/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./nameConvertor";
+//# sourceMappingURL=index.d.ts.map

package/build/lib/src/peer-generation/LanguageWriters/index.js

@@ -0,0 +1,2 @@
+export * from "./nameConvertor";
+//# sourceMappingURL=index.js.map

package/build/lib/src/peer-generation/LanguageWriters/nameConvertor.d.ts

@@ -0,0 +1,25 @@
+import * as idl from '../../idl';
+export interface IdlNameConvertor {
+    convert(node: idl.IDLNode): string;
+}
+export interface TypeConvertor<T> {
+    convertOptional(type: idl.IDLOptionalType): T;
+    convertUnion(type: idl.IDLUnionType): T;
+    convertContainer(type: idl.IDLContainerType): T;
+    convertImport(type: idl.IDLReferenceType, importClause: string): T;
+    convertTypeReference(type: idl.IDLReferenceType): T;
+    convertTypeParameter(type: idl.IDLTypeParameterType): T;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): T;
+}
+export declare function convertType<T>(convertor: TypeConvertor<T>, type: idl.IDLType): T;
+export interface DeclarationConvertor<T> {
+    convertInterface(node: idl.IDLInterface): T;
+    convertEnum(node: idl.IDLEnum): T;
+    convertTypedef(node: idl.IDLTypedef): T;
+    convertCallback(node: idl.IDLCallback): T;
+}
+export declare function convertDeclaration<T>(convertor: DeclarationConvertor<T>, decl: idl.IDLEntry): T;
+export interface NodeConvertor<T> extends TypeConvertor<T>, DeclarationConvertor<T> {
+}
+export declare function convertNode<T>(convertor: NodeConvertor<T>, node: idl.IDLNode): T;
+//# sourceMappingURL=nameConvertor.d.ts.map