@idlizer/core 2.1.10-arktscgen-5 → 2.1.10-arktscgen-7

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

@@ -0,0 +1,11 @@
+export type InputPaths = {
+    baseDirs: string[];
+    inputDirs: string[];
+    auxInputDirs: string[];
+    inputFiles: string[];
+    auxInputFiles: string[];
+    libraryPackages: string[];
+};
+export declare function formatInputPaths(options: any): InputPaths;
+export declare function validatePaths(paths: string[], type: 'file' | 'dir'): void;
+//# sourceMappingURL=inputPaths.d.ts.map

package/build/lib/src/inputPaths.js

@@ -0,0 +1,81 @@
+/*
+ * 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 * as fs from "fs";
+import * as path from "path";
+function processInputOption(option) {
+    if (typeof option === 'undefined') {
+        return [];
+    }
+    else if (typeof option === 'string') {
+        return option.split(',')
+            .map(item => item.trim())
+            .filter(Boolean);
+    }
+    else {
+        return option.flatMap(processInputOption);
+    }
+}
+// iterate through files in the same order even if input order changes
+function sortFiles(files) {
+    return files.sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
+}
+export function formatInputPaths(options) {
+    if (options.inputFiles) {
+        options.inputFiles = processInputOption(options.inputFiles);
+    }
+    if (options.auxInputFiles) {
+        options.auxInputFiles = processInputOption(options.auxInputFiles);
+    }
+    if (options.inputDir) {
+        options.inputDir = processInputOption(options.inputDir);
+    }
+    if (options.auxInputDir) {
+        options.auxInputDir = processInputOption(options.auxInputDir);
+    }
+    if (options.libraryPackages) {
+        options.libraryPackages = processInputOption(options.libraryPackages);
+    }
+    const inputDirs = options.inputDir || [];
+    const auxInputDirs = options.auxInputDir || [];
+    const inputFiles = options.inputFiles || [];
+    const auxInputFiles = options.auxInputFiles || [];
+    const libraryPackages = options.libraryPackages || [];
+    let baseDirs = options.baseDir ? processInputOption(options.baseDir) : inputDirs;
+    if (!baseDirs.length && inputFiles.length) {
+        baseDirs = [...(new Set(options.inputFiles.map((it) => path.dirname(it))).values())];
+    }
+    if (!baseDirs.length)
+        throw new Error("Check your --base-dir parameter, value is missing");
+    return {
+        baseDirs,
+        inputDirs,
+        auxInputDirs,
+        inputFiles: sortFiles(inputFiles),
+        auxInputFiles: sortFiles(auxInputFiles),
+        libraryPackages
+    };
+}
+export function validatePaths(paths, type) {
+    paths.forEach(pathItem => {
+        if (!fs.existsSync(pathItem)) {
+            console.error(`Input ${type} does not exist: ${pathItem}`);
+            process.exit(1);
+        }
+        else {
+            console.log(`Input ${type} exists: ${pathItem}`);
+        }
+    });
+}
+//# sourceMappingURL=inputPaths.js.map

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

@@ -1,5 +1,4 @@
 export declare const cppKeywords: Set<string>;
 export declare const CJKeywords: Set<string>;
-export declare const IDLKeywords: Set<string>;
 export declare const TSKeywords: Set<string>;
 //# sourceMappingURL=languageSpecificKeywords.d.ts.map

package/build/lib/src/languageSpecificKeywords.js

@@ -40,11 +40,6 @@ export const CJKeywords = new Set([
     'open', 'operator', 'foreign', 'inout',
     'prop', 'mut', 'unsafe', 'get', 'set', 'type'
 ]);
-export const IDLKeywords = new Set([
-    "attribute", "callback", "object", "toString",
-    'sequence', 'record', 'or', 'Int8Array',
-    'interface', 'number', 'undefined'
-]);
 export const TSKeywords = new Set([
     "namespace"
 ]);

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

@@ -6,7 +6,7 @@ export declare enum LayoutNodeRole {
     COMPONENT = 3,
     SERIALIZER = 4
 }
-export type LayoutTargetDescriptionHint = 'component.implementation' | 'component.interface' | 'component.function' | 'component.modifier';
+export type LayoutTargetDescriptionHint = 'component.implementation' | 'component.interface' | 'component.function' | 'component.modifier' | 'component.handwritten';
 export interface LayoutTargetDescription {
     node: IDLEntry;
     role: LayoutNodeRole;

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

@@ -11,8 +11,14 @@ export declare class MaterializedField {
     isNullableOriginalTypeField?: boolean | undefined;
     extraMethodName: string | undefined;
     constructor(field: Field, argConvertor: ArgConvertor, outArgConvertor?: ArgConvertor | undefined, isNullableOriginalTypeField?: boolean | undefined, extraMethodName?: string | undefined);
-    hasGetter(): boolean;
-    hasSetter(): boolean;
+    get state(): {
+        isAccessor: true;
+        hasGetter: boolean;
+        hasSetter: boolean;
+    } | {
+        isAccessor: false;
+        isReadonly: boolean;
+    };
 }
 export declare class MaterializedMethod extends PeerMethod {
     decl: idl.IDLConstructor | idl.IDLMethod | undefined;

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

@@ -24,19 +24,31 @@ export class MaterializedField {
         this.outArgConvertor = outArgConvertor;
         this.isNullableOriginalTypeField = isNullableOriginalTypeField;
         this.extraMethodName = extraMethodName;
+        const isReadonly = field.modifiers.includes(FieldModifier.READONLY);
+        const isGetter = field.modifiers.includes(FieldModifier.GET);
+        const isSetter = field.modifiers.includes(FieldModifier.SET);
+        if (isReadonly && (isGetter || isSetter))
+            throw new Error(`Unsupported modifiers combination: field can be either readonly or getter/setter or mutable for field ${field.name}`);
+        if (isSetter && !isGetter)
+            throw new Error(`Unsupported modifiers combination: if setter is defined getter must be defined too for field ${field.name}`);
     }
-    hasGetter() {
-        const isGetter = this.field.modifiers.includes(FieldModifier.GET);
-        const isSetter = this.field.modifiers.includes(FieldModifier.SET);
-        const isAccessor = isGetter || isSetter;
-        return !isAccessor || isGetter;
-    }
-    hasSetter() {
-        const isReadonly = this.field.modifiers.includes(FieldModifier.READONLY);
-        const isGetter = this.field.modifiers.includes(FieldModifier.GET);
-        const isSetter = this.field.modifiers.includes(FieldModifier.SET);
-        const isAccessor = isGetter || isSetter;
-        return (!isAccessor && !isReadonly) || isSetter;
+    get state() {
+        const hasGetter = this.field.modifiers.includes(FieldModifier.GET);
+        const hasSetter = this.field.modifiers.includes(FieldModifier.SET);
+        if (hasGetter || hasSetter) {
+            return {
+                isAccessor: true,
+                hasGetter,
+                hasSetter
+            };
+        }
+        else {
+            const isReadonly = this.field.modifiers.includes(FieldModifier.READONLY);
+            return {
+                isAccessor: false,
+                isReadonly
+            };
+        }
     }
 }
 export class MaterializedMethod extends PeerMethod {

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

@@ -4,11 +4,11 @@ import { LanguageWriter } from '../LanguageWriters/LanguageWriter';
 import { IdlNameConvertor } from '../LanguageWriters';
 import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
 import { LibraryInterface } from '../LibraryInterface';
-import { BuilderClass } from './BuilderClass';
 import { MaterializedClass } from './Materialized';
 import { LayoutManager, LayoutManagerStrategy } from './LayoutManager';
 import { IDLLibrary } from '../library';
 import { NativeModuleType } from '../LanguageWriters/common';
+import { ReferenceResolver } from './ReferenceResolver';
 export interface GlobalScopeDeclarations {
     methods: idl.IDLMethod[];
     constants: idl.IDLConstant[];
@@ -10259,13 +10259,11 @@ export declare class PeerLibrary implements LibraryInterface {
     asIDLLibrary(): IDLLibrary;
     get globals(): GlobalScopeDeclarations[];
     layout: LayoutManager;
-    private _syntheticFile;
-    initSyntheticEntries(file: idl.IDLFile): void;
-    getSyntheticData(): idl.IDLInterface[];
-    readonly files: idl.IDLFile[];
+    private _files;
+    get files(): idl.IDLFile[];
+    set files(value: idl.IDLFile[]);
     readonly auxFiles: idl.IDLFile[];
-    readonly builderClasses: Map<string, BuilderClass>;
-    get buildersToGenerate(): BuilderClass[];
+    private resolver;
     readonly materializedClasses: Map<string, MaterializedClass>;
     get orderedMaterialized(): MaterializedClass[];
     constructor(language: Language, interopNativeModule: NativeModuleType, useMemoM3?: boolean);
@@ -10281,14 +10279,10 @@ export declare class PeerLibrary implements LibraryInterface {
     setCurrentContext(context: string | undefined): void;
     findFileByOriginalFilename(filename: string): idl.IDLFile | undefined;
     mapType(type: idl.IDLType): string;
-    private referenceCache;
-    enableCache(): void;
-    resolveTypeReference(type: idl.IDLReferenceType, singleStep?: boolean): idl.IDLEntry | undefined;
-    private resolveTypeReferenceUncached;
-    private _useFallback;
-    disableFallback(): void;
-    resolveNamedNode(target: string[], pov?: idl.IDLNode | undefined): idl.IDLEntry | undefined;
-    resolveImport(target: idl.IDLImport): idl.IDLEntry | undefined;
+    resolveTypeReference(type: idl.IDLReferenceType, options?: {
+        terminalImports?: boolean;
+        unresolvedOk?: boolean;
+    }): idl.IDLEntry | undefined;
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     private customConvertor;
@@ -10302,4 +10296,5 @@ export declare const ArkFunction: idl.IDLPrimitiveType;
 export declare const ArkDate: idl.IDLPrimitiveType;
 export declare const ArkCustomObject: idl.IDLPrimitiveType;
 export declare function cleanPrefix(name: string, prefix: string): string;
+export declare function forceTypedefAsResource(resolver: ReferenceResolver, type: idl.IDLType, decl: idl.IDLTypedef): boolean;
 //# sourceMappingURL=PeerLibrary.d.ts.map

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

@@ -14,24 +14,24 @@
  */
 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, ObjectConvertor, TransformOnSerializeConvertor, } from "../LanguageWriters/ArgConvertors";
+import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, ObjectConvertor, TransformOnSerializeConvertor, } from "../LanguageWriters/ArgConvertors";
+import { StructureNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { ETSTypeNameConvertor } from '../LanguageWriters/convertors/ETSConvertors';
 import { TSTypeNameConvertor } from '../LanguageWriters/convertors/TSConvertors';
-import { isBuilderClass } from './BuilderClass';
 import { generateSyntheticFunctionName, isImportAttr } from './idl/common';
 import { LayoutManager } from './LayoutManager';
 import { lib, query } from '../library';
 import { isMaterialized } from './isMaterialized';
-import { isInIdlizeInternal } from '../idl';
 import { isInCurrentModule } from './modules';
 import { generatorConfiguration } from '../config';
 import { KotlinTypeNameConvertor } from '../LanguageWriters/convertors/KotlinConvertors';
 import { toIdlType } from '../from-idl/deserialize';
+import { createCachedReferenceResolver } from './ReferenceResolver';
+import { toDeclaration } from './toDeclaration';
 export const lenses = {
     globals: lib.lens(lib.select.files())
         .pipe(lib.select.nodes())
@@ -77,14 +77,12 @@ export class PeerLibrary {
     get globals() {
         return query(this.asIDLLibrary(), lenses.globals);
     }
-    initSyntheticEntries(file) {
-        this._syntheticFile = file;
+    get files() {
+        return this._files;
     }
-    getSyntheticData() {
-        return this._syntheticFile.entries.filter(it => idl.isInterface(it));
-    }
-    get buildersToGenerate() {
-        return Array.from(this.builderClasses.values()).filter(it => it.needBeGenerated);
+    set files(value) {
+        this._files = value;
+        this.resolver = createCachedReferenceResolver(value);
     }
     get orderedMaterialized() {
         function accessorName(decl) {
@@ -98,14 +96,12 @@ export class PeerLibrary {
         this.interopNativeModule = interopNativeModule;
         this.useMemoM3 = useMemoM3;
         this.layout = LayoutManager.Empty();
-        this._syntheticFile = idl.createFile([]);
-        this.files = [];
+        this._files = [];
         this.auxFiles = [];
-        this.builderClasses = new Map();
+        this.resolver = createCachedReferenceResolver([]);
         this.materializedClasses = new Map();
         this.name = "";
         this.customComponentMethods = [];
-        this._useFallback = true;
     }
     createLanguageWriter(language) {
         return createLanguageWriter(language !== null && language !== void 0 ? language : this.language, this);
@@ -140,8 +136,11 @@ export class PeerLibrary {
     }
     createContinuationCallbackReference(continuationType) {
         const continuationParameters = this.createContinuationParameters(continuationType);
-        const syntheticName = generateSyntheticFunctionName(continuationParameters, idl.IDLVoidType);
-        return idl.createReferenceType(syntheticName);
+        const syntheticName = generateSyntheticFunctionName(continuationParameters, idl.IDLVoidType, { nameConvertor: new StructureNameConvertor(this) });
+        const primaryReference = idl.createReferenceType(`synthetic.${syntheticName}`);
+        if (this.resolveTypeReference(primaryReference, { unresolvedOk: true }))
+            return primaryReference;
+        return idl.createReferenceType(`synthetic.synthetic_${syntheticName}`);
     }
     getCurrentContext() {
         return this.context;
@@ -155,124 +154,8 @@ export class PeerLibrary {
     mapType(type) {
         return this.createTypeNameConvertor(this.language).convert(type);
     }
-    enableCache() {
-        this.referenceCache = new Map();
-    }
-    resolveTypeReference(type, singleStep) {
-        var _a, _b;
-        const key = type.parent ? type : type.name; // does entry have resolve context or just FQN
-        let result = ((_a = this.referenceCache) === null || _a === void 0 ? void 0 : _a.has(key))
-            ? this.referenceCache.get(key)
-            : this.resolveTypeReferenceUncached(type, singleStep);
-        (_b = this.referenceCache) === null || _b === void 0 ? void 0 : _b.set(key, result);
-        return result;
-    }
-    resolveTypeReferenceUncached(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;
-        (_b = this.referenceCache) === null || _b === void 0 ? void 0 : _b.set(type, result);
-        return result;
-    }
-    disableFallback() {
-        this._useFallback = false;
-    }
-    resolveNamedNode(target, pov = undefined) {
-        const qualifiedName = target.join(".");
-        const entry = this._syntheticFile.entries.find(it => it.name === qualifiedName);
-        if (entry)
-            return entry;
-        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;
-        }
-        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;
-            }
-        }
-        // TODO: remove the next block after namespaces out of quarantine
-        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) {
-                    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));
-            for (const resolved of resolveds)
-                if (idl.isEntry(resolved))
-                    return resolved;
-        } // end of block to remove
-        return undefined;
-    }
-    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;
+    resolveTypeReference(type, options) {
+        return this.resolver.resolveTypeReference(type, options);
     }
     typeConvertor(param, type, isOptionalParam = false) {
         if (isOptionalParam) {
@@ -362,17 +245,11 @@ export class PeerLibrary {
             return new ImportTypeConvertor(param, this.createTypeNameConvertor(this.language).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);
-            }
+            throw new Error(`Unexpected declaration ${declaration.kind}`);
         }
         if (idl.hasExtAttribute(declaration, idl.IDLExtendedAttributes.TransformOnSerialize)) {
-            const targetRef = idl.createReferenceType(idl.getExtAttribute(declaration, idl.IDLExtendedAttributes.TransformOnSerialize));
-            return new TransformOnSerializeConvertor(param, this, declaration, targetRef);
+            const targetType = toIdlType("", idl.getExtAttribute(declaration, idl.IDLExtendedAttributes.TransformOnSerialize));
+            return new TransformOnSerializeConvertor(param, this, declaration, targetType);
         }
         if (idl.isEnum(declaration)) {
             return new EnumConvertor(param, declaration);
@@ -384,17 +261,17 @@ export class PeerLibrary {
             return new CallbackConvertor(this, param, declaration, this.interopNativeModule);
         }
         if (idl.isTypedef(declaration)) {
-            if (forceTypedefAsResource(type, declaration))
+            if (forceTypedefAsResource(this, type, declaration))
                 return new ObjectConvertor(param, type);
             return new TypeAliasConvertor(this, param, declaration);
         }
         if (idl.isInterface(declaration)) {
+            if (generatorConfiguration().forceResource.includes(declaration.name)) {
+                return new ObjectConvertor(param, type);
+            }
             if (isMaterialized(declaration, this)) {
                 return new MaterializedClassConvertor(this, param, declaration);
             }
-            if (isBuilderClass(declaration)) {
-                return new ClassConvertor(this, declarationName, param, declaration);
-            }
             switch (declaration.subkind) {
                 case idl.IDLInterfaceSubkind.Interface:
                 case idl.IDLInterfaceSubkind.Class:
@@ -424,51 +301,7 @@ export class PeerLibrary {
         return undefined;
     }
     toDeclaration(type) {
-        switch (type) {
-            case idl.IDLAnyType: return ArkCustomObject;
-            case idl.IDLVoidType: return idl.IDLVoidType;
-            case idl.IDLUndefinedType: return idl.IDLUndefinedType;
-            case idl.IDLUnknownType: return ArkCustomObject;
-            // case idl.IDLObjectType: return ArkCustomObject
-        }
-        const typeName = idl.isNamedNode(type) ? type.name : undefined;
-        switch (typeName) {
-            case "object":
-            case "Object": return idl.IDLObjectType;
-        }
-        if (idl.isReferenceType(type)) {
-            // TODO: remove all this!
-            if (type.name === 'Date') {
-                return ArkDate;
-            }
-            if (type.name === 'AnimationRange') {
-                return ArkCustomObject;
-            }
-            if (type.name === 'Function') {
-                return ArkFunction;
-            }
-            if (type.name === 'Optional') {
-                return this.toDeclaration(type.typeArguments[0]);
-            }
-            const decl = this.resolveTypeReference(type);
-            if (!decl) {
-                warn(`undeclared type ${idl.DebugUtils.debugPrintType(type)}`);
-            }
-            if (decl && idl.isTypedef(decl) && forceTypedefAsResource(type, decl)) {
-                return idl.IDLObjectType;
-            }
-            if (decl && idl.hasExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize)) {
-                const type = toIdlType("", idl.getExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize));
-                return this.toDeclaration(type);
-            }
-            return !decl ? ArkCustomObject // assume some builtin type
-                : idl.isTypedef(decl) ? this.toDeclaration(decl.type)
-                    : decl;
-        }
-        if (isImportAttr(type)) {
-            return ArkCustomObject;
-        }
-        return type;
+        return toDeclaration(type, this);
     }
     setFileLayout(strategy) {
         this.layout = new LayoutManager(strategy);
@@ -488,34 +321,21 @@ export const ArkCustomObject = idl.IDLCustomObjectType;
 export function cleanPrefix(name, prefix) {
     return name.replace(prefix, "");
 }
-function forceTypedefAsResource(type, decl) {
+export function forceTypedefAsResource(resolver, type, decl) {
     if (generatorConfiguration().forceResource.includes(idl.getFQName(decl)))
         return true;
-    if (isCyclicTypeDef(decl)) {
+    if (isCyclicTypeDef(resolver, decl)) {
         warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
         return true;
     }
     return false;
 }
-function isCyclicTypeDef(decl) {
-    return checkCyclicType(idl.getFQName(decl), decl.type);
-}
-function checkCyclicType(fqn, type) {
-    if (idl.isReferenceType(type) && idl.isNamedNode(type) && idl.getFQName(type) == fqn)
-        return true;
-    if (idl.isOptionalType(type) && checkCyclicType(fqn, type.type))
-        return true;
-    if (idl.isUnionType(type) && checkCyclicTypes(fqn, type.types))
-        return true;
-    if (idl.isContainerType(type) && checkCyclicTypes(fqn, type.elementType))
-        return true;
-    return false;
-}
-function checkCyclicTypes(fqn, types) {
-    for (const t of types) {
-        if (checkCyclicType(fqn, t))
-            return true;
-    }
-    return false;
+function isCyclicTypeDef(resolver, decl) {
+    let foundCycle = false;
+    idl.forEachChild(decl, (node) => {
+        if (idl.isReferenceType(node) && resolver.resolveTypeReference(node) === decl)
+            foundCycle = true;
+    });
+    return foundCycle;
 }
 //# sourceMappingURL=PeerLibrary.js.map

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

@@ -1,9 +1,14 @@
 import * as idl from '../idl';
 export interface ReferenceResolver {
-    resolveTypeReference(type: idl.IDLReferenceType, terminalImports?: boolean): idl.IDLEntry | undefined;
+    resolveTypeReference(type: idl.IDLReferenceType, options?: {
+        terminalImports?: boolean;
+        unresolvedOk?: boolean;
+    }): idl.IDLEntry | undefined;
     toDeclaration(type: idl.IDLNode): idl.IDLNode;
 }
 export declare function createEmptyReferenceResolver(): ReferenceResolver;
 /** Please do not store any global instances */
 export declare function createAlternativeReferenceResolver(mainResolver: ReferenceResolver, alternatives: Map<string, idl.IDLEntry>): ReferenceResolver;
+export declare function createAlgotithmicReferenceResolver(files: idl.IDLFile[], useFallback?: boolean): ReferenceResolver;
+export declare function createCachedReferenceResolver(files: idl.IDLFile[]): ReferenceResolver;
 //# sourceMappingURL=ReferenceResolver.d.ts.map