@idlizer/core 2.1.0 → 2.1.5

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

@@ -14,9 +14,10 @@
  */
 import { warn } from 'console';
 import * as idl from '../idl';
+import { resolveNamedNode } from '../resolveNamedNode';
 import { Language } from '../Language';
 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, BigIntToU64Convertor, } from "../LanguageWriters/ArgConvertors";
+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, BigIntToU64Convertor, ObjectConvertor, } from "../LanguageWriters/ArgConvertors";
 import { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
@@ -29,6 +30,8 @@ import { LayoutManager } from './LayoutManager';
 import { lib, query } from '../library';
 import { isMaterialized } from './isMaterialized';
 import { isInIdlizeInternal } from '../idlize';
+import { isInCurrentModule } from './modules';
+import { generatorConfiguration } from '../config';
 export const lenses = {
     globals: lib.lens(lib.select.files())
         .pipe(lib.select.nodes())
@@ -42,6 +45,8 @@ export const lenses = {
             };
             const next = queue.pop();
             next.forEach(node => {
+                if (!isInCurrentModule(node))
+                    return;
                 if (idl.isNamespace(node)) {
                     queue.push(node.members);
                 }
@@ -65,11 +70,13 @@ export class PeerLibrary {
             return this._cachedIdlLibrary;
         }
         this._cachedIdlLibrary = {
-            files: this.files.map(file => file.file)
+            files: this.files.map(file => file)
         };
         return this._cachedIdlLibrary;
     }
-    get globals() { return query(this.asIDLLibrary(), lenses.globals); }
+    get globals() {
+        return query(this.asIDLLibrary(), lenses.globals);
+    }
     initSyntheticEntries(file) {
         this._syntheticFile = file;
     }
@@ -82,18 +89,20 @@ export class PeerLibrary {
     get materializedToGenerate() {
         return Array.from(this.materializedClasses.values()).filter(it => it.needBeGenerated);
     }
-    constructor(language, libraryPackages) {
+    constructor(language, useMemoM3 = false) {
         this.language = language;
-        this.libraryPackages = libraryPackages;
+        this.useMemoM3 = useMemoM3;
         this.layout = LayoutManager.Empty();
         this._syntheticFile = idl.createFile([]);
         this.files = [];
+        this.auxFiles = [];
         this.builderClasses = new Map();
         this.materializedClasses = new Map();
         this.name = "";
         this.customComponentMethods = [];
         this.targetNameConvertorInstance = this.createTypeNameConvertor(this.language);
         this.interopNameConvertorInstance = new CppNameConvertor(this);
+        this._useFallback = true;
     }
     createLanguageWriter(language) {
         return createLanguageWriter(language !== null && language !== void 0 ? language : this.language, this);
@@ -138,80 +147,121 @@ export class PeerLibrary {
         this.context = context;
     }
     findFileByOriginalFilename(filename) {
-        return this.files.find(it => it.originalFilename === filename);
+        return this.files.find(it => it.fileName === filename);
     }
     mapType(type) {
         return this.targetNameConvertorInstance.convert(type);
     }
-    resolveTypeReference(type) {
-        return this.resolveTypeReferenceScoped(type);
+    enableCache() {
+        this.referenceCache = new Map();
+    }
+    resolveTypeReference(type, singleStep) {
+        var _a, _b;
+        if ((_a = this.referenceCache) === null || _a === void 0 ? void 0 : _a.has(type))
+            return this.referenceCache.get(type);
+        let result = this.resolveNamedNode(type.name.split("."), type.parent);
+        if (!singleStep) {
+            const seen = new Set;
+            while (result) {
+                let nextResult = undefined;
+                if (idl.isImport(result))
+                    nextResult = this.resolveImport(result);
+                else if (idl.isReferenceType(result))
+                    nextResult = this.resolveNamedNode(result.name.split("."));
+                else if (idl.isTypedef(result) && idl.isReferenceType(result.type))
+                    nextResult = this.resolveNamedNode(result.type.name.split("."));
+                if (!nextResult)
+                    break;
+                if (seen.has(nextResult)) {
+                    console.warn(`Cyclic referenceType: ${type.name}, seen: [${[...seen.values()].map(idl.getFQName).join(", ")}]`);
+                    break;
+                }
+                seen.add(nextResult);
+                result = nextResult;
+            }
+        }
+        if (result && (idl.isImport(result) || idl.isNamespace(result)))
+            result = undefined;
+        if (result)
+            (_b = this.referenceCache) === null || _b === void 0 ? void 0 : _b.set(type, result);
+        return result;
+    }
+    disableFallback() {
+        this._useFallback = false;
     }
-    resolveTypeReferenceScoped(type, pointOfView, rootEntries) {
-        const entry = this._syntheticFile.entries.find(it => it.name === type.name);
+    resolveNamedNode(target, pov = undefined) {
+        const qualifiedName = target.join(".");
+        const entry = this._syntheticFile.entries.find(it => it.name === qualifiedName);
         if (entry)
             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 => isInIdlizeInternal(it));
-            const found = predefined.find(it => it.name === qualifiedName[0]);
+        if (1 === target.length) {
+            const predefined = this.files.flatMap(it => it.entries).filter(isInIdlizeInternal);
+            const found = predefined.find(it => it.name === target.at(-1));
             if (found)
                 return found;
         }
-        let doWork = true;
-        while (doWork) {
-            doWork = !!pointOfViewNamespace;
-            let entries = pointOfViewNamespace
-                ? [...pointOfViewNamespace.members]
-                : [...rootEntries];
-            for (let qualifiedNamePart = 0; qualifiedNamePart < qualifiedName.length; ++qualifiedNamePart) {
-                const candidates = entries.filter(it => it.name === qualifiedName[qualifiedNamePart]);
-                if (!candidates.length)
-                    break;
-                if (qualifiedNamePart === qualifiedName.length - 1) {
-                    const target = candidates.length == 1
-                        ? candidates[0]
-                        : candidates.find(it => !idl.hasExtAttribute(it, idl.IDLExtendedAttributes.Import)); // probably the wrong logic here
-                    if (target && idl.isImport(target)) // Temporary disable Import declarations
-                        return undefined;
-                    return target;
-                }
-                entries = [];
-                for (const candidate of candidates) {
-                    if (idl.isNamespace(candidate))
-                        entries.push(...candidate.members);
-                    else if (idl.isEnum(candidate))
-                        entries.push(...candidate.elements);
-                    else if (idl.isInterface(candidate))
-                        entries.push(...candidate.constants, ...candidate.properties, ...candidate.methods);
-                }
+        const corpus = this.files.concat(this.auxFiles);
+        let result = resolveNamedNode(target, pov, corpus);
+        if (result && idl.isEntry(result))
+            return result;
+        if (1 == target.length) {
+            const stdScopes = generatorConfiguration().globalPackages.map(it => it.split('.'));
+            for (const stdScope of stdScopes) {
+                result = resolveNamedNode([...stdScope, ...target], undefined, corpus);
+                if (result && idl.isEntry(result))
+                    return result;
             }
-            pointOfViewNamespace = idl.fetchNamespaceFrom(pointOfViewNamespace === null || pointOfViewNamespace === void 0 ? void 0 : pointOfViewNamespace.parent);
         }
         // TODO: remove the next block after namespaces out of quarantine
-        if (!pointOfView) {
+        if (this._useFallback) {
+            const povAsReadableString = pov
+                ? `'${idl.getFQName(pov)}'`
+                : "[root]";
+            // retry from root
+            pov = undefined;
             const resolveds = [];
+            for (let file of this.files) {
+                result = resolveNamedNode([...file.packageClause, ...target], pov, corpus);
+                if (result && idl.isEntry(result)) {
+                    // too much spam
+                    // console.warn(`WARNING: Type reference '${qualifiedName}' is not resolved from ${povAsReadableString} but resolved from some package '${file.packageClause().join(".")}'`)
+                    resolveds.push(result);
+                }
+            }
+            // and from each namespace
             const traverseNamespaces = (entry) => {
                 if (entry && idl.isNamespace(entry) && entry.members.length) {
-                    //console.log(`Try alien namespace '${idl.getNamespacesPathFor(entry.members[0]).map(obj => obj.name).join(".")}' to resolve name '${type.name}'`)
-                    const resolved = this.resolveTypeReferenceScoped(type, entry, rootEntries);
-                    if (resolved)
+                    const resolved = resolveNamedNode([...idl.getNamespacesPathFor(entry).map(it => it.name), ...target], pov, corpus);
+                    if (resolved) {
+                        console.warn(`WARNING: Name '${qualifiedName}' is not resolved from ${povAsReadableString} but resolved from some namespace: '${idl.getNamespacesPathFor(resolved).map(obj => obj.name).join(".")}'`);
                         resolveds.push(resolved);
+                    }
                     entry.members.forEach(traverseNamespaces);
                 }
             };
             this.files.forEach(file => file.entries.forEach(traverseNamespaces));
-            if (resolveds.length)
-                console.log(`WARNING: Type reference '${type.name}' is not resolved without own namespace/pointOfView but resolved within some other namespace: '${idl.getNamespacesPathFor(resolveds[0]).map(obj => obj.name).join(".")}'`);
+            for (const resolved of resolveds)
+                if (idl.isEntry(resolved))
+                    return resolved;
         } // end of block to remove
-        return undefined; // empty result
+        return undefined;
     }
-    hasInLibrary(entry) {
-        var _a, _b;
-        return !((_a = this.libraryPackages) === null || _a === void 0 ? void 0 : _a.length) || ((_b = this.libraryPackages) === null || _b === void 0 ? void 0 : _b.includes(idl.getPackageName(entry)));
+    resolveImport(target) {
+        let result = this.resolveNamedNode(target.clause);
+        if (result) {
+            if (idl.isReferenceType(result))
+                return this.resolveTypeReference(result);
+            if (idl.isImport(result)) {
+                if (result == target) {
+                    console.log("Self-targeted Import?");
+                    return undefined;
+                }
+                return this.resolveImport(result);
+            }
+            if (idl.isEntry(result))
+                return result;
+        }
+        return undefined;
     }
     typeConvertor(param, type, isOptionalParam = false) {
         if (isOptionalParam) {
@@ -234,6 +284,7 @@ export class PeerLibrary {
                 case idl.IDLF32Type: return new NumericConvertor(param, type);
                 case idl.IDLF64Type: return new NumericConvertor(param, type);
                 case idl.IDLBigintType: return new BigIntToU64Convertor(param);
+                case idl.IDLSerializerBuffer: new PointerConvertor(param);
                 case idl.IDLPointerType: return new PointerConvertor(param);
                 case idl.IDLBufferType: return new BufferConvertor(param);
                 case idl.IDLBooleanType: return new BooleanConvertor(param);
@@ -242,16 +293,16 @@ export class PeerLibrary {
                 case idl.IDLUndefinedType: return new UndefinedConvertor(param);
                 case idl.IDLVoidType: return new VoidConvertor(param);
                 case idl.IDLUnknownType:
-                case idl.IDLAnyType: return new CustomTypeConvertor(param, "Any", false, "Object");
+                case idl.IDLAnyType: return new ObjectConvertor(param, idl.IDLAnyType);
                 case idl.IDLDate: return new DateConvertor(param);
+                case idl.IDLFunctionType: return new FunctionConvertor(this, 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) {
+            // TODO: this types are not references! NativeModulePrinter must be fixed
+            switch (type.name.replaceAll('%TEXT%:', '')) { // this is really bad stub, to fix legacy references
                 case 'KBoolean': return new BooleanConvertor(param);
                 case 'KInt': return new NumericConvertor(param, idl.IDLI32Type);
                 case 'KFloat': return new NumericConvertor(param, idl.IDLF32Type);
@@ -261,7 +312,12 @@ export class PeerLibrary {
                 case 'number': return new NumberConvertor(param);
                 case 'KPointer': return new PointerConvertor(param);
             }
+            if (generatorConfiguration().forceResource.includes(type.name)) {
+                return new ObjectConvertor(param, type);
+            }
             const decl = this.resolveTypeReference(type);
+            if (decl && isImportAttr(decl) || !decl && isImportAttr(type))
+                return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
             return this.declarationConvertor(param, type, decl);
         }
         if (idl.isUnionType(type)) {
@@ -280,15 +336,28 @@ export class PeerLibrary {
         throw new Error(`Cannot convert: ${type.kind}`);
     }
     declarationConvertor(param, type, declaration) {
+        if (generatorConfiguration().forceResource.includes(type.name)) {
+            return new ObjectConvertor(param, type);
+        }
         let customConv = this.customConvertor(param, type.name, type);
         if (customConv)
             return customConv;
-        if (!declaration)
+        if (!declaration) {
             return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), false, this.targetNameConvertorInstance.convert(type)); // assume some predefined type
+        }
         const declarationName = declaration.name;
         if (isImportAttr(declaration)) {
             return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
         }
+        if (idl.isImport(declaration)) {
+            const target = this.resolveImport(declaration);
+            if (target && idl.isEntry(target))
+                return this.declarationConvertor(param, type, target);
+            else {
+                warn(`Unable to resolve Import ${declaration.clause.join(".")} as ${declaration.name}`);
+                return new CustomTypeConvertor(param, declaration.name, false, declaration.name);
+            }
+        }
         if (idl.isEnum(declaration)) {
             return new EnumConvertor(param, declaration);
         }
@@ -327,11 +396,11 @@ export class PeerLibrary {
     customConvertor(param, typeName, type) {
         switch (typeName) {
             case `Object`:
-                return new CustomTypeConvertor(param, "Object", false, "Object");
+                return new ObjectConvertor(param, idl.IDLObjectType);
             case `Date`:
                 return new DateConvertor(param);
             case `Function`:
-                return new FunctionConvertor(this, param, type);
+                return new FunctionConvertor(this, param);
             case `Record`:
                 return new CustomTypeConvertor(param, "Record", false, "Record<string, string>");
             case `Optional`:
@@ -355,18 +424,12 @@ export class PeerLibrary {
             case "object":
             case "Object": return ArkCustomObject;
         }
-        if (isImportAttr(type)) {
-            return ArkCustomObject;
-        }
         if (idl.isReferenceType(type)) {
             // TODO: remove all this!
-            if (type.name === 'Dimension' || type.name === 'Length') {
-                return ArkLength;
-            }
             if (type.name === 'Date') {
                 return ArkDate;
             }
-            if (type.name === 'AnimationRange' || type.name === 'ContentModifier') {
+            if (type.name === 'AnimationRange') {
                 return ArkCustomObject;
             }
             if (type.name === 'Function') {
@@ -387,6 +450,9 @@ export class PeerLibrary {
                 : idl.isTypedef(decl) ? this.toDeclaration(decl.type)
                     : decl;
         }
+        if (isImportAttr(type)) {
+            return ArkCustomObject;
+        }
         return type;
     }
     setFileLayout(strategy) {
@@ -396,7 +462,6 @@ export class PeerLibrary {
 export const ArkInt32 = idl.IDLI32Type;
 export const ArkInt64 = idl.IDLI64Type;
 export const ArkFunction = idl.IDLFunctionType;
-export const ArkLength = idl.IDLLengthType;
 export const ArkDate = idl.IDLDate;
 export const ArkCustomObject = idl.IDLCustomObjectType;
 export function cleanPrefix(name, prefix) {

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

@@ -1,6 +1,6 @@
 import * as idl from '../idl';
 export interface ReferenceResolver {
-    resolveTypeReference(type: idl.IDLReferenceType, pointOfView?: idl.IDLEntry, rootEntries?: idl.IDLEntry[]): idl.IDLEntry | undefined;
+    resolveTypeReference(type: idl.IDLReferenceType, terminalImports?: boolean): idl.IDLEntry | undefined;
     toDeclaration(type: idl.IDLNode): idl.IDLNode;
 }
 export declare function createEmptyReferenceResolver(): ReferenceResolver;

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

@@ -25,9 +25,9 @@ export function createEmptyReferenceResolver() {
 /** Please do not store any global instances */
 export function createAlternativeReferenceResolver(mainResolver, alternatives) {
     return {
-        resolveTypeReference(type, pointOfView, rootEntries) {
+        resolveTypeReference(type, terminalImports) {
             var _a;
-            return (_a = mainResolver.resolveTypeReference(type, pointOfView, rootEntries)) !== null && _a !== void 0 ? _a : alternatives.get(type.name);
+            return (_a = mainResolver.resolveTypeReference(type, terminalImports)) !== null && _a !== void 0 ? _a : alternatives.get(type.name);
         },
         toDeclaration(type) {
             return mainResolver.toDeclaration(type);

package/build/lib/src/peer-generation/idl/IdlNameConvertor.d.ts

@@ -2,6 +2,7 @@ import * as idl from "../../idl";
 import { DeclarationConvertor } from "../../LanguageWriters/nameConvertor";
 import { Language } from "../../Language";
 export declare class DeclarationNameConvertor implements DeclarationConvertor<string> {
+    convertImport(decl: idl.IDLImport): string;
     convertInterface(decl: idl.IDLInterface): string;
     convertEnum(decl: idl.IDLEnum): string;
     convertTypedef(decl: idl.IDLTypedef): string;

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

@@ -15,6 +15,10 @@
 import * as idl from "../../idl";
 import { Language } from "../../Language";
 export class DeclarationNameConvertor {
+    convertImport(decl) {
+        console.warn("Imports are not implemented yet");
+        return decl.name;
+    }
     convertInterface(decl) {
         return decl.name;
     }
@@ -50,10 +54,10 @@ export class TSFeatureNameConvertor extends DeclarationNameConvertor {
 TSFeatureNameConvertor.I = new TSFeatureNameConvertor();
 export class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
     convertInterface(decl) {
-        return idl.getFQName(decl);
+        return idl.getQualifiedName(decl, "namespace.name");
     }
     convertEnum(decl) {
-        return idl.getFQName(decl);
+        return idl.getQualifiedName(decl, "namespace.name");
     }
 }
 ETSDeclarationNameConvertor.I = new ETSDeclarationNameConvertor();

package/build/lib/src/peer-generation/idl/common.d.ts

@@ -1,9 +1,10 @@
 import * as idl from "../../idl";
 import { Language } from "../../Language";
 export declare function generateSyntheticIdlNodeName(type: idl.IDLType): string;
-export declare function qualifiedName(decl: idl.IDLNode, languageOrDelimiter: Language | string): string;
+export declare function qualifiedName(decl: idl.IDLNode, languageOrDelimiter: Language | string, pattern: idl.QNPattern): string;
 export declare function collapseTypes(types: idl.IDLType[], name?: string): idl.IDLType;
 export declare function generifiedTypeName(refType: idl.IDLReferenceType | undefined, refName?: string): string | undefined;
+export declare function sanitizeGenerics(genericDeclarationString: string): string;
 export declare function generateSyntheticUnionName(types: idl.IDLType[]): string;
 export declare function generateSyntheticFunctionName(parameters: idl.IDLParameter[], returnType: idl.IDLType, isAsync?: boolean): string;
 export declare function isImportAttr(decl: idl.IDLNode): boolean;

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

@@ -33,7 +33,7 @@ export function generateSyntheticIdlNodeName(type) {
         return `Opt_${generateSyntheticIdlNodeName(type.type)}`;
     throw `Can not compute type name of ${idl.IDLKind[type.kind]}`;
 }
-export function qualifiedName(decl, languageOrDelimiter) {
+export function qualifiedName(decl, languageOrDelimiter, pattern) {
     if (!idl.isNamedNode(decl))
         throw new Error("internal error, name required for no-named node");
     const delimiter = typeof languageOrDelimiter === "string"
@@ -41,7 +41,7 @@ export function qualifiedName(decl, languageOrDelimiter) {
         : (languageOrDelimiter === Language.CPP ? '_' : '.');
     if (!idl.isEntry(decl))
         throw new Error(`Expected to have an IDLEntry, got ${idl.IDLKind[decl.kind]}`);
-    return idl.getFQName(decl).split(".").join(delimiter);
+    return idl.getQualifiedName(decl, pattern).split(".").join(delimiter);
 }
 export function collapseTypes(types, name) {
     const seenNames = new Set();
@@ -61,6 +61,17 @@ export function generifiedTypeName(refType, refName) {
     const typeArgs = (_a = refType.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it)).join(",");
     return `${refName ? refName : refType.name}${typeArgs ? `<${typeArgs}>` : ``}`;
 }
+export function sanitizeGenerics(genericDeclarationString) {
+    const eqIdx = genericDeclarationString.indexOf('=');
+    if (eqIdx !== -1) {
+        genericDeclarationString = genericDeclarationString.substring(0, eqIdx);
+    }
+    const extendsIdx = genericDeclarationString.indexOf('extends');
+    if (extendsIdx !== -1) {
+        genericDeclarationString = genericDeclarationString.substring(0, extendsIdx);
+    }
+    return genericDeclarationString.trim();
+}
 export function generateSyntheticUnionName(types) {
     return `Union_${types.map(it => generateSyntheticIdlNodeName(it)).join("_").replaceAll(".", "_")}`;
 }

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

@@ -0,0 +1,5 @@
+import { ReferenceResolver } from './ReferenceResolver';
+import { IDLType } from "../idl";
+export declare function isEnumType(type: IDLType, resolver: ReferenceResolver): boolean;
+export declare function isStringEnumType(type: IDLType, resolver: ReferenceResolver): boolean;
+//# sourceMappingURL=isEnumType.d.ts.map

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

@@ -0,0 +1,29 @@
+/*
+ * 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.
+ */
+import { isReferenceType, isEnum, isStringEnum } from "../idl";
+export function isEnumType(type, resolver) {
+    return toEnum(type, resolver) != undefined;
+}
+export function isStringEnumType(type, resolver) {
+    const enumNode = toEnum(type, resolver);
+    return enumNode ? isStringEnum(enumNode) : false;
+}
+function toEnum(type, resolver) {
+    if (!isReferenceType(type))
+        return undefined;
+    const resolved = resolver.resolveTypeReference(type);
+    return resolved && isEnum(resolved) ? resolved : undefined;
+}
+//# sourceMappingURL=isEnumType.js.map

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

@@ -16,20 +16,27 @@ import { generatorConfiguration } from '../config';
 import * as idl from '../idl';
 import { isBuilderClass } from './BuilderClass';
 export function isMaterialized(declaration, resolver) {
+    var _a;
     if (!idl.isInterfaceSubkind(declaration) && !idl.isClassSubkind(declaration))
         return false;
     if (idl.isHandwritten(declaration) || isBuilderClass(declaration))
         return false;
-    for (const forceMaterialized of generatorConfiguration().forceMaterialized) {
-        if (declaration.name == forceMaterialized)
-            return true;
-    }
-    if (generatorConfiguration().forceCallback.includes(declaration.name)) {
+    if (generatorConfiguration().forceResource.includes(declaration.name)) {
         return false;
     }
-    for (const ignore of generatorConfiguration().ignoreMaterialized) {
-        if (declaration.name.endsWith(ignore))
+    if (generatorConfiguration().forceMaterialized.includes(declaration.name)) {
+        return true;
+    }
+    for (const ignore of ["Attribute", "Method", "Interface"]) {
+        if (declaration.name.endsWith(ignore)) {
             return false;
+        }
+    }
+    if (((_a = generatorConfiguration().forceCallback.get(declaration.name)) === null || _a === void 0 ? void 0 : _a.length) === 0) {
+        return false;
+    }
+    if (generatorConfiguration().ignoreMaterialized.includes(declaration.name)) {
+        return false;
     }
     // A materialized class is a class or an interface with methods
     // excluding components and related classes
@@ -46,11 +53,21 @@ export function isMaterialized(declaration, resolver) {
     }
     return false;
 }
+function isSelfReturnMethod(method, entry, resolver) {
+    if (!idl.isReferenceType(method.returnType)) {
+        return false;
+    }
+    const found = resolver.resolveTypeReference(method.returnType);
+    if (!found) {
+        return false;
+    }
+    return idl.getFQName(found) === idl.getFQName(entry);
+}
 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))
+        if (!declaration.methods.every(it => it.isStatic && !isSelfReturnMethod(it, declaration, resolver)))
             return false;
         if (idl.hasSuperType(declaration)) {
             const superType = resolver.resolveTypeReference(idl.getSuperType(declaration));

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

@@ -0,0 +1,10 @@
+import { ModuleConfiguration } from "../config";
+import * as idl from "../idl";
+export declare function isInModule(node: idl.IDLNode, module: ModuleConfiguration): boolean;
+export declare function isInModule(packageName: string, module: ModuleConfiguration): boolean;
+export declare function getModuleFor(node: idl.IDLNode): ModuleConfiguration;
+export declare function getModuleFor(packageName: string): ModuleConfiguration;
+export declare function currentModule(): ModuleConfiguration;
+export declare function isInCurrentModule(node: idl.IDLNode): boolean;
+export declare function isInCurrentModule(packageName: string): boolean;
+//# sourceMappingURL=modules.d.ts.map

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

@@ -0,0 +1,38 @@
+import { generatorConfiguration } from "../config";
+import * as idl from "../idl";
+export function isInModule(nodeOrPackage, module) {
+    if (typeof nodeOrPackage === 'object')
+        return isInModule(idl.getPackageName(nodeOrPackage), module);
+    return module.packages.some(modulePackage => nodeOrPackage.startsWith(modulePackage));
+}
+export function getModuleFor(nodeOrPackage) {
+    if (typeof nodeOrPackage === "object")
+        return getModuleFor(idl.getPackageName(nodeOrPackage));
+    const packageName = nodeOrPackage;
+    const config = generatorConfiguration();
+    const applicableModules = [...config.modules.values()].filter(module => isInModule(packageName, module));
+    if (applicableModules.length === 0) {
+        if (nodeOrPackage === '') {
+            console.error("WARNING: use current module for empty package");
+            return currentModule();
+        }
+        throw new Error(`Package ${packageName} is not listed in any module`);
+    }
+    if (applicableModules.length > 1)
+        throw new Error(`Package ${packageName} listed in ${applicableModules.length} packages: ${applicableModules.map(it => it.name).join(", ")}`);
+    return applicableModules[0];
+}
+export function currentModule() {
+    const conf = generatorConfiguration();
+    const result = conf.modules.get(conf.moduleName);
+    if (!result)
+        throw new Error(`Can not determine current module configuration ${conf.moduleName}`);
+    return result;
+}
+export function isInCurrentModule(nodeOrPackage) {
+    if (typeof nodeOrPackage === 'string')
+        return isInModule(nodeOrPackage, currentModule());
+    else
+        return isInModule(nodeOrPackage, currentModule());
+}
+//# sourceMappingURL=modules.js.map

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

@@ -1,5 +1,5 @@
 import { TypeConvertor } from "../LanguageWriters";
-import { IDLContainerType, IDLOptionalType, IDLPrimitiveType, IDLReferenceType, IDLType, IDLTypeParameterType, IDLUnionType } from '../idl';
+import { IDLImport, IDLContainerType, IDLOptionalType, IDLPrimitiveType, IDLReferenceType, IDLType, IDLTypeParameterType, IDLUnionType } from '../idl';
 import { LanguageExpression, LanguageWriter } from "../LanguageWriters/LanguageWriter";
 import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
 import { LibraryInterface } from "../LibraryInterface";
@@ -7,11 +7,12 @@ import { ReferenceResolver } from "./ReferenceResolver";
 export declare class UnionFlattener implements TypeConvertor<IDLType[]> {
     private resolver;
     constructor(resolver: ReferenceResolver);
+    convertImport(type: IDLImport): IDLType[];
     convertUnion(type: IDLUnionType): IDLType[];
     convertTypeReference(type: IDLReferenceType): IDLType[];
     convertOptional(type: IDLOptionalType): IDLType[];
     convertContainer(type: IDLContainerType): IDLType[];
-    convertImport(type: IDLReferenceType, importClause: string): IDLType[];
+    convertTypeReferenceAsImport(type: IDLReferenceType, importClause: string): IDLType[];
     convertPrimitiveType(type: IDLPrimitiveType): IDLType[];
     convertTypeParameter(type: IDLTypeParameterType): IDLType[];
 }