@idlizer/core 2.0.41 → 2.1.0

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

@@ -1,27 +1,27 @@
 import { stringOrNone } from "./util";
 export declare enum IDLKind {
-    Interface = 0,
-    Import = 1,
-    Callback = 2,
-    Const = 3,
-    Property = 4,
-    Parameter = 5,
-    Method = 6,
-    Callable = 7,
-    Constructor = 8,
-    Enum = 9,
-    EnumMember = 10,
-    Typedef = 11,
-    PrimitiveType = 12,
-    ContainerType = 13,
-    UnspecifiedGenericType = 14,
-    ReferenceType = 15,
-    UnionType = 16,
-    TypeParameterType = 17,
-    OptionalType = 18,
-    Version = 19,
-    Namespace = 20,
-    File = 21
+    Interface = "Interface",
+    Import = "Import",
+    Callback = "Callback",
+    Const = "Const",
+    Property = "Property",
+    Parameter = "Parameter",
+    Method = "Method",
+    Callable = "Callable",
+    Constructor = "Constructor",
+    Enum = "Enum",
+    EnumMember = "EnumMember",
+    Typedef = "Typedef",
+    PrimitiveType = "PrimitiveType",
+    ContainerType = "ContainerType",
+    UnspecifiedGenericType = "UnspecifiedGenericType",
+    ReferenceType = "ReferenceType",
+    UnionType = "UnionType",
+    TypeParameterType = "TypeParameterType",
+    OptionalType = "OptionalType",
+    Version = "Version",
+    Namespace = "Namespace",
+    File = "File"
 }
 export declare enum IDLEntity {
     Class = "Class",
@@ -35,13 +35,10 @@ export declare enum IDLEntity {
 export declare enum IDLExtendedAttributes {
     Accessor = "Accessor",
     Async = "Async",
-    ArkTSType = "ArkTSType",
     CallSignature = "CallSignature",
-    CJType = "CJType",
     CommonMethod = "CommonMethod",
     Component = "Component",
     ComponentInterface = "ComponentInterface",
-    CPPType = "CPPType",
     Deprecated = "Deprecated",
     Documentation = "Documentation",
     DtsName = "DtsName",
@@ -57,7 +54,6 @@ export declare enum IDLExtendedAttributes {
     Protected = "Protected",
     Synthetic = "Synthetic",
     Throws = "Throws",
-    TSType = "TSType",
     TypeArguments = "TypeArguments",
     TypeParameters = "TypeParameters",
     VerbatimDts = "VerbatimDts",
@@ -300,6 +296,7 @@ export declare function getFileFor(entry: IDLNode): IDLFile | undefined;
 export declare function isEqualByQualifedName(a?: IDLEntry, b?: IDLEntry): boolean;
 export declare function getPackageClause(entry: IDLFile | IDLEntry): string[];
 export declare function getPackageName(entry: IDLFile | IDLEntry): string;
+export declare function isInPackage(entry: IDLEntry | IDLFile, packageName: string, exactMatch?: boolean): 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;

package/build/lib/src/idl.js

@@ -18,28 +18,28 @@ import { generateSyntheticIdlNodeName } from "./peer-generation/idl/common";
 import { IDLKeywords } from "./languageSpecificKeywords";
 export var IDLKind;
 (function (IDLKind) {
-    IDLKind[IDLKind["Interface"] = 0] = "Interface";
-    IDLKind[IDLKind["Import"] = 1] = "Import";
-    IDLKind[IDLKind["Callback"] = 2] = "Callback";
-    IDLKind[IDLKind["Const"] = 3] = "Const";
-    IDLKind[IDLKind["Property"] = 4] = "Property";
-    IDLKind[IDLKind["Parameter"] = 5] = "Parameter";
-    IDLKind[IDLKind["Method"] = 6] = "Method";
-    IDLKind[IDLKind["Callable"] = 7] = "Callable";
-    IDLKind[IDLKind["Constructor"] = 8] = "Constructor";
-    IDLKind[IDLKind["Enum"] = 9] = "Enum";
-    IDLKind[IDLKind["EnumMember"] = 10] = "EnumMember";
-    IDLKind[IDLKind["Typedef"] = 11] = "Typedef";
-    IDLKind[IDLKind["PrimitiveType"] = 12] = "PrimitiveType";
-    IDLKind[IDLKind["ContainerType"] = 13] = "ContainerType";
-    IDLKind[IDLKind["UnspecifiedGenericType"] = 14] = "UnspecifiedGenericType";
-    IDLKind[IDLKind["ReferenceType"] = 15] = "ReferenceType";
-    IDLKind[IDLKind["UnionType"] = 16] = "UnionType";
-    IDLKind[IDLKind["TypeParameterType"] = 17] = "TypeParameterType";
-    IDLKind[IDLKind["OptionalType"] = 18] = "OptionalType";
-    IDLKind[IDLKind["Version"] = 19] = "Version";
-    IDLKind[IDLKind["Namespace"] = 20] = "Namespace";
-    IDLKind[IDLKind["File"] = 21] = "File";
+    IDLKind["Interface"] = "Interface";
+    IDLKind["Import"] = "Import";
+    IDLKind["Callback"] = "Callback";
+    IDLKind["Const"] = "Const";
+    IDLKind["Property"] = "Property";
+    IDLKind["Parameter"] = "Parameter";
+    IDLKind["Method"] = "Method";
+    IDLKind["Callable"] = "Callable";
+    IDLKind["Constructor"] = "Constructor";
+    IDLKind["Enum"] = "Enum";
+    IDLKind["EnumMember"] = "EnumMember";
+    IDLKind["Typedef"] = "Typedef";
+    IDLKind["PrimitiveType"] = "PrimitiveType";
+    IDLKind["ContainerType"] = "ContainerType";
+    IDLKind["UnspecifiedGenericType"] = "UnspecifiedGenericType";
+    IDLKind["ReferenceType"] = "ReferenceType";
+    IDLKind["UnionType"] = "UnionType";
+    IDLKind["TypeParameterType"] = "TypeParameterType";
+    IDLKind["OptionalType"] = "OptionalType";
+    IDLKind["Version"] = "Version";
+    IDLKind["Namespace"] = "Namespace";
+    IDLKind["File"] = "File";
 })(IDLKind || (IDLKind = {}));
 export var IDLEntity;
 (function (IDLEntity) {
@@ -55,13 +55,10 @@ export var IDLExtendedAttributes;
 (function (IDLExtendedAttributes) {
     IDLExtendedAttributes["Accessor"] = "Accessor";
     IDLExtendedAttributes["Async"] = "Async";
-    IDLExtendedAttributes["ArkTSType"] = "ArkTSType";
     IDLExtendedAttributes["CallSignature"] = "CallSignature";
-    IDLExtendedAttributes["CJType"] = "CJType";
     IDLExtendedAttributes["CommonMethod"] = "CommonMethod";
     IDLExtendedAttributes["Component"] = "Component";
     IDLExtendedAttributes["ComponentInterface"] = "ComponentInterface";
-    IDLExtendedAttributes["CPPType"] = "CPPType";
     IDLExtendedAttributes["Deprecated"] = "Deprecated";
     IDLExtendedAttributes["Documentation"] = "Documentation";
     IDLExtendedAttributes["DtsName"] = "DtsName";
@@ -77,7 +74,6 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["Protected"] = "Protected";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
     IDLExtendedAttributes["Throws"] = "Throws";
-    IDLExtendedAttributes["TSType"] = "TSType";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
@@ -398,6 +394,12 @@ export function getPackageClause(entry) {
 export function getPackageName(entry) {
     return getPackageClause(entry).join(".");
 }
+export function isInPackage(entry, packageName, exactMatch = false) {
+    const entryPackageName = getPackageName(entry);
+    return exactMatch
+        ? entryPackageName === packageName
+        : entryPackageName.startsWith(packageName);
+}
 export function getNamespaceName(a) {
     return getNamespacesPathFor(a).map(it => it.name).join('.');
 }
@@ -945,12 +947,12 @@ export function forEachFunction(node, cb) {
 }
 export function asPromise(type) {
     if (!type)
-        return;
+        return undefined;
     if (!isContainerType(type))
-        return;
+        return undefined;
     const container = type;
     if (!IDLContainerUtils.isPromise(container))
-        return;
+        return undefined;
     return container;
 }
 export function transformMethodsAsync2ReturnPromise(entry) {

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

@@ -1,5 +1,10 @@
 import * as ts from "typescript";
+import * as idl from "./idl";
 import { GenerateOptions } from "./options";
+export declare function scanDirectory(dir: string, fileFilter: (file: string) => boolean, recursive?: boolean): string[];
+export declare function scanInputDirs(inputDirs: string[]): string[];
+export declare function scanInputDirs(inputDirs: string[], fileExtension: string): string[];
+export declare function scanInputDirs(inputDirs: string[], fileFilter: (file: string) => boolean, recursive: boolean): string[];
 export interface GenerateVisitor<T> {
     visitPhase1(): T;
     visitPhase2?(siblings: {
@@ -10,5 +15,9 @@ export interface GenerateVisitor<T> {
         };
     }): T;
 }
-export declare function generate<T>(inputDirs: string[], inputFiles: string[], outputDir: string, visitorFactory: (sourceFile: ts.SourceFile, program: ts.Program, compilerHost: ts.CompilerHost) => GenerateVisitor<T>, options: GenerateOptions<T>): void;
+export declare function generate<T>(inputFiles: string[], outputDir: string, visitorFactory: (sourceFile: ts.SourceFile, program: ts.Program, compilerHost: ts.CompilerHost) => GenerateVisitor<T>, options: GenerateOptions<T>): void;
+export declare function isInIdlize(entry: idl.IDLEntry | idl.IDLFile): boolean;
+export declare function isInIdlizeInterop(entry: idl.IDLEntry | idl.IDLFile): boolean;
+export declare function isInIdlizeInternal(entry: idl.IDLEntry | idl.IDLFile): boolean;
+export declare function isInIdlizeStdlib(entry: idl.IDLEntry | idl.IDLFile): boolean;
 //# sourceMappingURL=idlize.d.ts.map

package/build/lib/src/idlize.js

@@ -15,38 +15,55 @@
 import * as ts from "typescript";
 import * as fs from "fs";
 import * as path from "path";
-function readdir(dir) {
-    return fs.readdirSync(dir)
-        .map(elem => path.join(dir, elem));
+import * as idl from "./idl";
+export function scanDirectory(dir, fileFilter, recursive = false) {
+    const dirsToVisit = [path.resolve(dir)];
+    const result = [];
+    while (dirsToVisit.length > 0) {
+        let dir = dirsToVisit.pop();
+        let dirents = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of dirents) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isFile()) {
+                if (fileFilter(fullPath)) {
+                    result.push(fullPath);
+                }
+            }
+            else if (recursive && entry.isDirectory()) {
+                dirsToVisit.push(fullPath);
+            }
+        }
+    }
+    return result;
+}
+export function scanInputDirs(inputDirs, fileFilter = undefined, recursive = false) {
+    if (typeof fileFilter === 'undefined')
+        return scanInputDirs(inputDirs, (_) => true, recursive);
+    if (typeof fileFilter === 'string')
+        return scanInputDirs(inputDirs, (file) => file.endsWith(fileFilter), recursive);
+    const resolvedInputDirs = inputDirs.map(dir => path.resolve(dir));
+    console.log("Resolved input directories:", resolvedInputDirs);
+    return resolvedInputDirs.flatMap(dir => {
+        if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
+            console.log(`Processing all .d.ts from directory: ${dir}`);
+            return scanDirectory(dir, fileFilter, recursive);
+        }
+        else {
+            console.warn(`Warning: Directory does not exist or is not a directory: ${dir}`);
+            return [];
+        }
+    });
 }
-export function generate(inputDirs, inputFiles, outputDir, visitorFactory, options) {
+export function generate(inputFiles, outputDir, visitorFactory, options) {
     var _a, _b, _c;
     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).");
+    if (inputFiles.length === 0) {
+        console.error("Error: No input files specified.");
         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);
@@ -74,9 +91,8 @@ export function generate(inputDirs, inputFiles, outputDir, visitorFactory, optio
     const dtsFileName2Visitor = {};
     for (const sourceFile of program.getSourceFiles()) {
         const resolvedSourceFileName = path.resolve(sourceFile.fileName);
-        const isInDir = resolvedInputDirs.some(dir => resolvedSourceFileName.startsWith(dir));
         const isExplicitFile = input.some(f => path.resolve(f) === resolvedSourceFileName);
-        if (!isInDir && !isExplicitFile) {
+        if (!isExplicitFile) {
             if (options.enableLog) {
                 console.log(`Skipping file: ${resolvedSourceFileName}`);
             }
@@ -108,4 +124,16 @@ export function generate(inputDirs, inputFiles, outputDir, visitorFactory, optio
         console.log("Generation completed.");
     }
 }
+export function isInIdlize(entry) {
+    return idl.isInPackage(entry, "idlize");
+}
+export function isInIdlizeInterop(entry) {
+    return idl.isInPackage(entry, "idlize.internal.interop");
+}
+export function isInIdlizeInternal(entry) {
+    return idl.isInPackage(entry, "idlize.internal");
+}
+export function isInIdlizeStdlib(entry) {
+    return idl.isInPackage(entry, "idlize.stdlib");
+}
 //# sourceMappingURL=idlize.js.map

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

@@ -43,7 +43,9 @@ export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
+export * from "./from-idl/IDLLinter";
 export { fromIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
 export { toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { D, ConfigTypeInfer, ConfigSchema } from './configDescriber';
 //# sourceMappingURL=index.d.ts.map

package/build/lib/src/index.js

@@ -57,7 +57,9 @@ export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
+export * from "./from-idl/IDLLinter";
 export { fromIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
 export { toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { D } from './configDescriber';
 //# sourceMappingURL=index.js.map

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

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

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

@@ -37,6 +37,7 @@ export declare class MaterializedClass implements PeerClassBase {
     readonly decl: idl.IDLInterface;
     readonly className: string;
     readonly isInterface: boolean;
+    readonly isStaticMaterialized: boolean;
     readonly superClass: idl.IDLReferenceType | undefined;
     readonly interfaces: idl.IDLReferenceType[] | undefined;
     readonly generics: string[] | undefined;
@@ -46,7 +47,7 @@ export declare class MaterializedClass implements PeerClassBase {
     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 | undefined, // undefined when used for global functions
+    constructor(decl: idl.IDLInterface, className: string, isInterface: boolean, isStaticMaterialized: 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;

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

@@ -96,12 +96,13 @@ export function copyMaterializedMethod(method, overrides) {
     return copied;
 }
 export class MaterializedClass {
-    constructor(decl, className, isInterface, superClass, interfaces, generics, fields, ctor, // undefined when used for global functions
+    constructor(decl, className, isInterface, isStaticMaterialized, 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;
+        this.isStaticMaterialized = isStaticMaterialized;
         this.superClass = superClass;
         this.interfaces = interfaces;
         this.generics = generics;
@@ -131,7 +132,7 @@ export class MaterializedClass {
     }
 }
 export function createDestroyPeerMethod(clazz) {
-    if (clazz.isGlobalScope()) {
+    if (clazz.isGlobalScope() || clazz.isStaticMaterialized) {
         return undefined;
     }
     return new MaterializedMethod(clazz.className, clazz.getImplementationName(), [], idl.IDLVoidType, false, new Method('destroyPeer', new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.className)], ['peer'])));

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

@@ -3,9 +3,8 @@ import { PeerClass } from "./PeerClass";
 import { LibraryFileInterface } from '../LibraryInterface';
 export declare class PeerFile implements LibraryFileInterface {
     readonly file: idl.IDLFile;
-    readonly isPredefined: boolean;
     readonly peers: Map<string, PeerClass>;
-    constructor(file: idl.IDLFile, isPredefined?: boolean);
+    constructor(file: idl.IDLFile);
     packageName(): string;
     packageClause(): string[];
     get peersToGenerate(): PeerClass[];

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

@@ -13,9 +13,8 @@
  * limitations under the License.
  */
 export class PeerFile {
-    constructor(file, isPredefined = false) {
+    constructor(file) {
         this.file = file;
-        this.isPredefined = isPredefined;
         this.peers = new Map();
     }
     packageName() {

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

@@ -10266,7 +10266,6 @@ export declare class PeerLibrary implements LibraryInterface {
     get buildersToGenerate(): BuilderClass[];
     readonly materializedClasses: Map<string, MaterializedClass>;
     get materializedToGenerate(): MaterializedClass[];
-    readonly predefinedDeclarations: idl.IDLInterface[];
     constructor(language: Language, libraryPackages: string[] | undefined);
     name: string;
     readonly customComponentMethods: string[];

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

@@ -28,6 +28,7 @@ import { generateSyntheticFunctionName, isImportAttr } from './idl/common';
 import { LayoutManager } from './LayoutManager';
 import { lib, query } from '../library';
 import { isMaterialized } from './isMaterialized';
+import { isInIdlizeInternal } from '../idlize';
 export const lenses = {
     globals: lib.lens(lib.select.files())
         .pipe(lib.select.nodes())
@@ -89,7 +90,6 @@ export class PeerLibrary {
         this.files = [];
         this.builderClasses = new Map();
         this.materializedClasses = new Map();
-        this.predefinedDeclarations = [];
         this.name = "";
         this.customComponentMethods = [];
         this.targetNameConvertorInstance = this.createTypeNameConvertor(this.language);
@@ -152,10 +152,11 @@ export class PeerLibrary {
             return entry;
         const qualifiedName = type.name.split(".");
         let pointOfViewNamespace = idl.fetchNamespaceFrom(type.parent);
+        // TODO: Choose what to do if `rootEntries.some(it => idl.isNamespace(it))`
+        // One of possible options - `rootEntries = rootEntries.flatMap(it => idl.isNamespace(it) ? it.members : it)` - cause error
         rootEntries !== null && rootEntries !== void 0 ? rootEntries : (rootEntries = this.files.flatMap(it => it.entries));
         if (1 === qualifiedName.length) {
-            const predefined = rootEntries.filter(it => idl.hasExtAttribute(it, idl.IDLExtendedAttributes.Predefined));
-            predefined.push(...this.predefinedDeclarations);
+            const predefined = rootEntries.filter(it => isInIdlizeInternal(it));
             const found = predefined.find(it => it.name === qualifiedName[0]);
             if (found)
                 return found;
@@ -242,12 +243,24 @@ export class PeerLibrary {
                 case idl.IDLVoidType: return new VoidConvertor(param);
                 case idl.IDLUnknownType:
                 case idl.IDLAnyType: return new CustomTypeConvertor(param, "Any", false, "Object");
+                case idl.IDLDate: return new DateConvertor(param);
                 default: throw new Error(`Unconverted primitive ${idl.DebugUtils.debugPrintType(type)}`);
             }
         }
         if (idl.isReferenceType(type)) {
             if (isImportAttr(type))
                 return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
+            // TODO: special cases for interop types.
+            switch (type.name) {
+                case 'KBoolean': return new BooleanConvertor(param);
+                case 'KInt': return new NumericConvertor(param, idl.IDLI32Type);
+                case 'KFloat': return new NumericConvertor(param, idl.IDLF32Type);
+                case 'KLong': return new NumericConvertor(param, idl.IDLI64Type);
+                case 'KDouble': return new NumericConvertor(param, idl.IDLF64Type);
+                case 'KStringPtr': return new StringConvertor(param);
+                case 'number': return new NumberConvertor(param);
+                case 'KPointer': return new PointerConvertor(param);
+            }
             const decl = this.resolveTypeReference(type);
             return this.declarationConvertor(param, type, decl);
         }

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

@@ -1,19 +1,6 @@
-/*
- * 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 { generatorTypePrefix } from "../config";
 import { asPromise } from "../idl";
+import { isVMContextMethod } from "../LanguageWriters/ArgConvertors";
 import { mangleMethodName, MethodModifier } from "../LanguageWriters/LanguageWriter";
 import { capitalize, isDefined } from "../util";
 import { PrimitiveTypesInstance } from "./PrimitiveType";
@@ -71,7 +58,6 @@ export class PeerMethod {
         return !((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.STATIC));
     }
     generateAPIParameters(converter) {
-        var _a;
         const args = this.argAndOutConvertors.map(it => {
             let isPointer = it.isPointerType();
             return `${isPointer ? "const " : ""}${converter.convert(it.nativeType())}${isPointer ? "*" : ""} ${it.param}`;
@@ -81,7 +67,7 @@ export class PeerMethod {
             args.unshift(`${receiver.argType} ${receiver.argName}`);
         if (!!asPromise(this.method.signature.returnType))
             args.unshift(`${generatorTypePrefix()}AsyncWorkerPtr asyncWorker`);
-        if (!!asPromise(this.method.signature.returnType) || ((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS)))
+        if (isVMContextMethod(this.method))
             args.unshift(`${generatorTypePrefix()}VMContext vmContext`);
         return args;
     }

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

@@ -19,7 +19,7 @@ export function generateSyntheticIdlNodeName(type) {
     if (idl.isPrimitiveType(type))
         return capitalize(type.name);
     if (idl.isContainerType(type)) {
-        const typeArgs = type.elementType.map(it => generateSyntheticIdlNodeName(it)).join("_");
+        const typeArgs = type.elementType.map(it => generateSyntheticIdlNodeName(it)).join("_").replaceAll(".", "_");
         switch (type.containerKind) {
             case "sequence": return "Array_" + typeArgs;
             case "record": return "Map_" + typeArgs;
@@ -62,7 +62,7 @@ export function generifiedTypeName(refType, refName) {
     return `${refName ? refName : refType.name}${typeArgs ? `<${typeArgs}>` : ``}`;
 }
 export function generateSyntheticUnionName(types) {
-    return `Union_${types.map(it => generateSyntheticIdlNodeName(it)).join("_")}`;
+    return `Union_${types.map(it => generateSyntheticIdlNodeName(it)).join("_").replaceAll(".", "_")}`;
 }
 export function generateSyntheticFunctionName(parameters, returnType, isAsync = false) {
     let prefix = isAsync ? "AsyncCallback" : "Callback";

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

@@ -1,5 +1,6 @@
 import * as idl from '../idl';
 import { ReferenceResolver } from './ReferenceResolver';
 export declare function isMaterialized(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
+export declare function isStaticMaterialized(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
 export declare function isMaterializedType(type: idl.IDLType, resolver: ReferenceResolver): boolean;
 //# sourceMappingURL=isMaterialized.d.ts.map

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

@@ -24,6 +24,9 @@ export function isMaterialized(declaration, resolver) {
         if (declaration.name == forceMaterialized)
             return true;
     }
+    if (generatorConfiguration().forceCallback.includes(declaration.name)) {
+        return false;
+    }
     for (const ignore of generatorConfiguration().ignoreMaterialized) {
         if (declaration.name.endsWith(ignore))
             return false;
@@ -43,6 +46,24 @@ export function isMaterialized(declaration, resolver) {
     }
     return false;
 }
+export function isStaticMaterialized(declaration, resolver) {
+    if (isMaterialized(declaration, resolver)) {
+        if (declaration.properties.length || declaration.constructors.length)
+            return false;
+        if (!declaration.methods.every(it => it.isStatic))
+            return false;
+        if (idl.hasSuperType(declaration)) {
+            const superType = resolver.resolveTypeReference(idl.getSuperType(declaration));
+            if (!superType || !idl.isInterface(superType)) {
+                console.log(`Unable to resolve ${idl.getSuperType(declaration).name} type, consider ${declaration.name} to be not materialized`);
+                return false;
+            }
+            return isStaticMaterialized(superType, resolver);
+        }
+        return true;
+    }
+    return false;
+}
 export function isMaterializedType(type, resolver) {
     if (!idl.isReferenceType(type))
         return false;

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

@@ -82,4 +82,5 @@ export declare class Lazy<T> {
 }
 export declare function lazy<T>(factory: () => T): Lazy<T>;
 export declare function isInNamespace(node: idl.IDLEntry): boolean;
+export declare function rightmostIndexOf<T>(array: T[], predicate: (value: T) => boolean): number;
 //# sourceMappingURL=util.d.ts.map

package/build/lib/src/util.js

@@ -639,4 +639,13 @@ export function lazy(factory) {
 export function isInNamespace(node) {
     return idl.getNamespacesPathFor(node).length > 0;
 }
+export function rightmostIndexOf(array, predicate) {
+    let result = -1;
+    array.forEach((it, index) => {
+        if (predicate(it)) {
+            result = index;
+        }
+    });
+    return result;
+}
 //# sourceMappingURL=util.js.map

package/package.json

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