@idlizer/core 2.0.17 → 2.0.19

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as idl from '../../idl';
+export function convertType(convertor, type) {
+    if (idl.isOptionalType(type))
+        return convertor.convertOptional(type);
+    if (idl.isUnionType(type))
+        return convertor.convertUnion(type);
+    if (idl.isContainerType(type))
+        return convertor.convertContainer(type);
+    if (idl.isReferenceType(type)) {
+        const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
+        return importAttr
+            ? convertor.convertImport(type, importAttr)
+            : convertor.convertTypeReference(type);
+    }
+    if (idl.isTypeParameterType(type))
+        return convertor.convertTypeParameter(type);
+    if (idl.isPrimitiveType(type))
+        return convertor.convertPrimitiveType(type);
+    throw new Error(`Unknown type ${idl.IDLKind[type.kind]}`);
+}
+export function convertDeclaration(convertor, decl) {
+    if (idl.isInterface(decl))
+        return convertor.convertInterface(decl);
+    if (idl.isEnum(decl))
+        return convertor.convertEnum(decl);
+    if (idl.isEnumMember(decl))
+        return convertor.convertEnum(decl.parent);
+    if (idl.isTypedef(decl))
+        return convertor.convertTypedef(decl);
+    if (idl.isCallback(decl))
+        return convertor.convertCallback(decl);
+    throw new Error(`Unknown declaration type ${decl.kind ? idl.IDLKind[decl.kind] : "(undefined kind)"}`);
+}
+export function convertNode(convertor, node) {
+    if (idl.isEntry(node))
+        return convertDeclaration(convertor, node);
+    if (idl.isType(node))
+        return convertType(convertor, node);
+    throw new Error(`Unknown node type ${idl.IDLKind[node.kind]}`);
+}
+//# sourceMappingURL=nameConvertor.js.map

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

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

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

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+export var LayoutNodeRole;
+(function (LayoutNodeRole) {
+    LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
+    LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
+})(LayoutNodeRole || (LayoutNodeRole = {}));
+export class LayoutManager {
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    resolve(node, role) {
+        return this.strategy.resolve(node, role);
+    }
+    ////////////////////////////////////////////////////////////////////
+    static Empty() {
+        return new LayoutManager({ resolve: () => '' });
+    }
+}
+//# sourceMappingURL=LayoutManager.js.map

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

@@ -3,6 +3,8 @@ import { ArgConvertor } from '../LanguageWriters/ArgConvertors';
 import { Field, Method } from '../LanguageWriters/LanguageWriter';
 import { PeerClassBase } from './PeerClass';
 import { PeerMethod } from './PeerMethod';
+import { ReferenceResolver } from './ReferenceResolver';
+export declare function isMaterialized(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
 export declare class MaterializedField {
     field: Field;
     argConvertor: ArgConvertor;

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

@@ -12,11 +12,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { generatorConfiguration } from '../config';
 import * as idl from '../idl';
 import { copyMethod, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
 import { capitalize } from '../util';
+import { isBuilderClass } from './BuilderClass';
 import { qualifiedName } from './idl/common';
 import { PeerMethod } from './PeerMethod';
+export function isMaterialized(declaration, resolver) {
+    if (idl.isHandwritten(declaration) ||
+        isBuilderClass(declaration) ||
+        declaration.subkind === idl.IDLInterfaceSubkind.AnonymousInterface ||
+        declaration.subkind === idl.IDLInterfaceSubkind.Tuple) {
+        return false;
+    }
+    for (const ignore of generatorConfiguration().paramArray("ignoreMaterialized")) {
+        if (declaration.name.endsWith(ignore))
+            return false;
+    }
+    // A materialized class is a class or an interface with methods
+    // excluding components and related classes
+    if (declaration.methods.length > 0)
+        return true;
+    // Or a class or an interface derived from materialized class
+    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 isMaterialized(superType, resolver);
+    }
+    return false;
+}
 export class MaterializedField {
     constructor(field, argConvertor, outArgConvertor, isNullableOriginalTypeField) {
         this.field = field;

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

@@ -0,0 +1,53 @@
+import * as idl from '../idl';
+import { Language } from '../Language';
+import { IdlNameConvertor } from '../LanguageWriters';
+import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
+import { LibraryInterface } from '../LibraryInterface';
+import { BuilderClass } from './BuilderClass';
+import { MaterializedClass } from './Materialized';
+import { PeerFile } from './PeerFile';
+import { LayoutManager, LayoutManagerStrategy } from './LayoutManager';
+export declare class PeerLibrary implements LibraryInterface {
+    language: Language;
+    layout: LayoutManager;
+    private _syntheticEntries;
+    /** @deprecated PeerLibrary should contain only SDK entries */
+    get syntheticEntries(): idl.IDLEntry[];
+    initSyntheticEntries(entries: idl.IDLEntry[]): void;
+    readonly files: PeerFile[];
+    readonly builderClasses: Map<string, BuilderClass>;
+    get buildersToGenerate(): BuilderClass[];
+    readonly materializedClasses: Map<string, MaterializedClass>;
+    get materializedToGenerate(): MaterializedClass[];
+    readonly predefinedDeclarations: idl.IDLInterface[];
+    readonly globalScopeInterfaces: idl.IDLInterface[];
+    constructor(language: Language);
+    name: string;
+    readonly customComponentMethods: string[];
+    createTypeNameConvertor(language: Language): IdlNameConvertor;
+    protected readonly targetNameConvertorInstance: IdlNameConvertor;
+    private readonly interopNameConvertorInstance;
+    get libraryPrefix(): string;
+    createContinuationParameters(continuationType: idl.IDLType): idl.IDLParameter[];
+    createContinuationCallbackReference(continuationType: idl.IDLType): idl.IDLReferenceType;
+    private context;
+    getCurrentContext(): string | undefined;
+    setCurrentContext(context: string | undefined): void;
+    findFileByOriginalFilename(filename: string): PeerFile | undefined;
+    mapType(type: idl.IDLType): string;
+    resolveTypeReference(type: idl.IDLReferenceType, pointOfView?: idl.IDLEntry, rootEntries?: idl.IDLEntry[]): 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;
+    getInteropName(node: idl.IDLNode): string;
+    toDeclaration(type: idl.IDLType | idl.IDLTypedef | idl.IDLCallback | idl.IDLEnum | idl.IDLInterface): idl.IDLEntry | idl.IDLType;
+    setFileLayout(strategy: LayoutManagerStrategy): void;
+}
+export declare const ArkInt32: idl.IDLPrimitiveType;
+export declare const ArkInt64: idl.IDLPrimitiveType;
+export declare const ArkFunction: idl.IDLPrimitiveType;
+export declare const ArkLength: idl.IDLPrimitiveType;
+export declare const ArkDate: idl.IDLPrimitiveType;
+export declare const ArkCustomObject: idl.IDLPrimitiveType;
+export declare function cleanPrefix(name: string, prefix: string): string;
+//# sourceMappingURL=PeerLibrary.d.ts.map

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

@@ -0,0 +1,340 @@
+/*
+ * 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 { warn } from 'console';
+import * as idl from '../idl';
+import { Language } from '../Language';
+import { InteropNameConvertor } from '../LanguageWriters';
+import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ClassConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, } from "../LanguageWriters/ArgConvertors";
+import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
+import { CppInteropConvertor } from '../LanguageWriters/convertors/CppConvertors';
+import { ETSTypeNameConvertor } from '../LanguageWriters/convertors/ETSConvertors';
+import { JavaTypeNameConvertor } from '../LanguageWriters/convertors/JavaConvertors';
+import { TSTypeNameConvertor } from '../LanguageWriters/convertors/TSConvertors';
+import { generateSyntheticFunctionName, isImportAttr } from './idl/common';
+import { isMaterialized } from './Materialized';
+import { LayoutManager } from './LayoutManager';
+export class PeerLibrary {
+    /** @deprecated PeerLibrary should contain only SDK entries */
+    get syntheticEntries() {
+        return this._syntheticEntries;
+    }
+    initSyntheticEntries(entries) {
+        this._syntheticEntries = entries;
+    }
+    get buildersToGenerate() {
+        return Array.from(this.builderClasses.values()).filter(it => it.needBeGenerated);
+    }
+    get materializedToGenerate() {
+        return Array.from(this.materializedClasses.values()).filter(it => it.needBeGenerated);
+    }
+    constructor(language) {
+        this.language = language;
+        this.layout = LayoutManager.Empty();
+        this._syntheticEntries = [];
+        this.files = [];
+        this.builderClasses = new Map();
+        this.materializedClasses = new Map();
+        this.predefinedDeclarations = [];
+        this.globalScopeInterfaces = [];
+        this.name = "";
+        this.customComponentMethods = [];
+        this.targetNameConvertorInstance = this.createTypeNameConvertor(this.language);
+        this.interopNameConvertorInstance = new InteropNameConvertor(this);
+    }
+    createTypeNameConvertor(language) {
+        switch (language) {
+            case Language.TS: return new TSTypeNameConvertor(this);
+            case Language.ARKTS: return new ETSTypeNameConvertor(this);
+            case Language.JAVA: return new JavaTypeNameConvertor(this);
+            case Language.CJ: return new CJTypeNameConvertor(this);
+            case Language.CPP: return new CppInteropConvertor(this);
+        }
+        throw new Error(`IdlNameConvertor for ${language} is not implemented`);
+    }
+    get libraryPrefix() {
+        return this.name ? this.name + "_" : "";
+    }
+    createContinuationParameters(continuationType) {
+        const continuationParameters = [];
+        if (idl.isContainerType(continuationType) && idl.IDLContainerUtils.isPromise(continuationType)) {
+            const errorType = idl.createOptionalType(idl.createContainerType("sequence", [idl.IDLStringType]));
+            continuationParameters.push(idl.createParameter("error", errorType, true));
+            const promise = continuationType;
+            if (!idl.isVoidType(promise.elementType[0])) {
+                const valueType = idl.createOptionalType(promise.elementType[0]);
+                continuationParameters.unshift(idl.createParameter("value", valueType, true));
+            }
+        }
+        else if (!idl.isVoidType(continuationType))
+            continuationParameters.push(idl.createParameter('value', continuationType));
+        return continuationParameters;
+    }
+    createContinuationCallbackReference(continuationType) {
+        const continuationParameters = this.createContinuationParameters(continuationType);
+        const syntheticName = generateSyntheticFunctionName(continuationParameters, idl.IDLVoidType);
+        return idl.createReferenceType(syntheticName, undefined, continuationType);
+    }
+    getCurrentContext() {
+        return this.context;
+    }
+    setCurrentContext(context) {
+        this.context = context;
+    }
+    findFileByOriginalFilename(filename) {
+        return this.files.find(it => it.originalFilename === filename);
+    }
+    mapType(type) {
+        return this.targetNameConvertorInstance.convert(type);
+    }
+    resolveTypeReference(type, pointOfView, rootEntries) {
+        const entry = this.syntheticEntries.find(it => it.name === type.name);
+        if (entry)
+            return entry;
+        const qualifiedName = type.name.split(".");
+        pointOfView !== null && pointOfView !== void 0 ? pointOfView : (pointOfView = type.namespace);
+        let pointOfViewNamespace = !pointOfView || idl.isNamespace(pointOfView)
+            ? pointOfView
+            : pointOfView.namespace;
+        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 found = predefined.find(it => it.name === qualifiedName[0]);
+            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) {
+                    return candidates.length == 1
+                        ? candidates[0]
+                        : candidates.find(it => !idl.hasExtAttribute(it, idl.IDLExtendedAttributes.Import)); // probably the wrong logic here
+                }
+                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);
+                }
+            }
+            pointOfViewNamespace = pointOfViewNamespace === null || pointOfViewNamespace === void 0 ? void 0 : pointOfViewNamespace.namespace;
+        }
+        // TODO: remove the next block after namespaces out of quarantine
+        if (!pointOfView) {
+            const resolveds = [];
+            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.resolveTypeReference(type, entry, rootEntries);
+                    if (resolved)
+                        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(".")}'`);
+        } // end of block to remove
+        return undefined; // empty result
+    }
+    typeConvertor(param, type, isOptionalParam = false) {
+        if (isOptionalParam) {
+            return new OptionConvertor(this, param, idl.maybeUnwrapOptionalType(type));
+        }
+        if (idl.isOptionalType(type)) {
+            return new OptionConvertor(this, param, type.type);
+        }
+        if (idl.isPrimitiveType(type)) {
+            switch (type) {
+                case idl.IDLI8Type: return new NumericConvertor(param, type);
+                case idl.IDLU8Type: return new NumericConvertor(param, type);
+                case idl.IDLI16Type: return new NumericConvertor(param, type);
+                case idl.IDLU16Type: return new NumericConvertor(param, type);
+                case idl.IDLI32Type: return new NumericConvertor(param, type);
+                case idl.IDLU32Type: return new NumericConvertor(param, type);
+                case idl.IDLI64Type: return new NumericConvertor(param, type);
+                case idl.IDLU64Type: return new NumericConvertor(param, type);
+                case idl.IDLF16Type: return new NumericConvertor(param, type);
+                case idl.IDLF32Type: return new NumericConvertor(param, type);
+                case idl.IDLF64Type: return new NumericConvertor(param, type);
+                case idl.IDLPointerType: return new PointerConvertor(param);
+                case idl.IDLBufferType: return new BufferConvertor(param);
+                case idl.IDLBooleanType: return new BooleanConvertor(param);
+                case idl.IDLStringType: return new StringConvertor(param);
+                case idl.IDLNumberType: return new NumberConvertor(param);
+                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");
+                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));
+            const decl = this.resolveTypeReference(type);
+            return this.declarationConvertor(param, type, decl);
+        }
+        if (idl.isUnionType(type)) {
+            return new UnionConvertor(this, param, type);
+        }
+        if (idl.isContainerType(type)) {
+            if (idl.IDLContainerUtils.isSequence(type))
+                return new ArrayConvertor(this, param, type, type.elementType[0]);
+            if (idl.IDLContainerUtils.isRecord(type))
+                return new MapConvertor(this, param, type, type.elementType[0], type.elementType[1]);
+        }
+        if (idl.isTypeParameterType(type)) {
+            // TODO: unlikely correct.
+            return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), true);
+        }
+        throw new Error(`Cannot convert: ${type.kind}`);
+    }
+    declarationConvertor(param, type, declaration) {
+        let customConv = this.customConvertor(param, type.name, type);
+        if (customConv)
+            return customConv;
+        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.isEnum(declaration)) {
+            return new EnumConvertor(param, declaration);
+        }
+        if (idl.isEnumMember(declaration)) {
+            return new EnumConvertor(param, declaration.parent);
+        }
+        if (idl.isCallback(declaration)) {
+            return new CallbackConvertor(this, param, declaration);
+        }
+        if (idl.isTypedef(declaration)) {
+            if (isCyclicTypeDef(declaration)) {
+                warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
+                return new CustomTypeConvertor(param, declaration.name, false, declaration.name);
+            }
+            return new TypeAliasConvertor(this, param, declaration);
+        }
+        if (idl.isInterface(declaration)) {
+            if (isMaterialized(declaration, this)) {
+                return new MaterializedClassConvertor(param, declaration);
+            }
+            switch (declaration.subkind) {
+                case idl.IDLInterfaceSubkind.Interface:
+                    return new InterfaceConvertor(this, declarationName, param, declaration);
+                case idl.IDLInterfaceSubkind.Class:
+                    return new ClassConvertor(this, declarationName, param, declaration);
+                case idl.IDLInterfaceSubkind.AnonymousInterface:
+                    return new AggregateConvertor(this, param, type, declaration);
+                case idl.IDLInterfaceSubkind.Tuple:
+                    return new TupleConvertor(this, param, type, declaration);
+            }
+        }
+        throw new Error(`Unknown decl ${declarationName} of kind ${declaration.kind}`);
+    }
+    customConvertor(param, typeName, type) {
+        switch (typeName) {
+            case `Object`:
+                return new CustomTypeConvertor(param, "Object");
+            case `Date`:
+                return new DateConvertor(param);
+            case `Function`:
+                return new FunctionConvertor(this, param, type);
+            case `Record`:
+                return new CustomTypeConvertor(param, "Record", false, "Record<string, string>");
+            case `Optional`:
+                return new OptionConvertor(this, param, type.typeArguments[0]);
+        }
+        return undefined;
+    }
+    getInteropName(node) {
+        return this.interopNameConvertorInstance.convert(node);
+    }
+    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 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') {
+                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) && isCyclicTypeDef(decl)) {
+                warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
+                return ArkCustomObject;
+            }
+            return !decl ? ArkCustomObject // assume some builtin type
+                : idl.isTypedef(decl) ? this.toDeclaration(decl.type)
+                    : decl;
+        }
+        return type;
+    }
+    setFileLayout(strategy) {
+        this.layout = new LayoutManager(strategy);
+    }
+}
+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) {
+    return name.replace(prefix, "");
+}
+function isCyclicTypeDef(decl) {
+    return idl.isReferenceType(decl.type) && idl.isNamedNode(decl.type) && decl.type.name == decl.name;
+}
+//# sourceMappingURL=PeerLibrary.js.map

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

@@ -16,6 +16,7 @@ export declare class TSFeatureNameConvertor extends DeclarationNameConvertor {
     static readonly I: TSFeatureNameConvertor;
 }
 export declare class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl: idl.IDLInterface): string;
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: ETSDeclarationNameConvertor;
 }

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

@@ -46,6 +46,9 @@ export class TSFeatureNameConvertor extends DeclarationNameConvertor {
 }
 TSFeatureNameConvertor.I = new TSFeatureNameConvertor();
 export class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return idl.getFQName(decl);
+    }
     convertEnum(decl) {
         const namespace = idl.getNamespacesPathFor(decl).map(it => it.name).join('_');
         return `${namespace ? `${namespace}_` : ``}${decl.name}`;

package/package.json

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

package/webidl2.js/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Robin Berjon
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.