@idlizer/core 2.0.15 → 2.0.19

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/PeerMethod.d.ts

@@ -0,0 +1,35 @@
+import { IDLType } from "../idl";
+import { IdlNameConvertor } from "../LanguageWriters";
+import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
+import { Method } from "../LanguageWriters/LanguageWriter";
+export declare class PeerMethod {
+    originalParentName: string;
+    argConvertors: ArgConvertor[];
+    returnType: IDLType;
+    isCallSignature: boolean;
+    method: Method;
+    outArgConvertor?: ArgConvertor | undefined;
+    private overloadIndex?;
+    constructor(originalParentName: string, argConvertors: ArgConvertor[], returnType: IDLType, isCallSignature: boolean, method: Method, outArgConvertor?: ArgConvertor | undefined);
+    get overloadedName(): string;
+    get fullMethodName(): string;
+    get peerMethodName(): string;
+    get implNamespaceName(): string;
+    get implName(): string;
+    get toStringName(): string;
+    get dummyReturnValue(): string | undefined;
+    get receiverType(): string;
+    get apiCall(): string;
+    get apiKind(): string;
+    get argAndOutConvertors(): ArgConvertor[];
+    hasReceiver(): boolean;
+    generateAPIParameters(converter: IdlNameConvertor): string[];
+    generateReceiver(): {
+        argName: string;
+        argType: string;
+    } | undefined;
+    getImplementationName(): string;
+    static markAndGroupOverloads(methods: PeerMethod[]): PeerMethod[];
+    setSameOverloadIndex(copyFrom: PeerMethod): void;
+}
+//# sourceMappingURL=PeerMethod.d.ts.map

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

@@ -0,0 +1,108 @@
+/*
+ * 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 { mangleMethodName, MethodModifier } from "../LanguageWriters/LanguageWriter";
+import { capitalize, isDefined } from "../util";
+import { PrimitiveTypesInstance } from "./PrimitiveType";
+export class PeerMethod {
+    constructor(originalParentName, argConvertors, returnType, isCallSignature, method, outArgConvertor) {
+        this.originalParentName = originalParentName;
+        this.argConvertors = argConvertors;
+        this.returnType = returnType;
+        this.isCallSignature = isCallSignature;
+        this.method = method;
+        this.outArgConvertor = outArgConvertor;
+    }
+    get overloadedName() {
+        return mangleMethodName(this.method, this.overloadIndex);
+    }
+    get fullMethodName() {
+        return this.isCallSignature ? this.overloadedName : this.peerMethodName;
+    }
+    get peerMethodName() {
+        const name = this.overloadedName;
+        if (!this.hasReceiver())
+            return name;
+        if (name.startsWith("set") ||
+            name.startsWith("get"))
+            return name;
+        return `set${capitalize(name)}`;
+    }
+    get implNamespaceName() {
+        return `${capitalize(this.originalParentName)}Modifier`;
+    }
+    get implName() {
+        return `${capitalize(this.overloadedName)}Impl`;
+    }
+    get toStringName() {
+        return this.method.name;
+    }
+    get dummyReturnValue() {
+        return undefined;
+    }
+    get receiverType() {
+        return "Ark_NodeHandle";
+    }
+    get apiCall() {
+        return "GetNodeModifiers()";
+    }
+    get apiKind() {
+        return "Modifier";
+    }
+    get argAndOutConvertors() {
+        var _a;
+        return this.argConvertors.concat((_a = this.outArgConvertor) !== null && _a !== void 0 ? _a : []);
+    }
+    hasReceiver() {
+        var _a;
+        return !((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.STATIC));
+    }
+    generateAPIParameters(converter) {
+        const args = this.argAndOutConvertors.map(it => {
+            let isPointer = it.isPointerType();
+            return `${isPointer ? "const " : ""}${converter.convert(it.nativeType())}${isPointer ? "*" : ""} ${it.param}`;
+        });
+        const receiver = this.generateReceiver();
+        if (receiver)
+            return [`${receiver.argType} ${receiver.argName}`, ...args];
+        return args;
+    }
+    generateReceiver() {
+        if (!this.hasReceiver())
+            return undefined;
+        return {
+            argName: "node",
+            argType: PrimitiveTypesInstance.NativePointer.getText()
+        };
+    }
+    getImplementationName() {
+        return this.originalParentName;
+    }
+    static markAndGroupOverloads(methods) {
+        let groupedMethods = [];
+        for (const peerMethod of methods) {
+            if (isDefined(peerMethod.overloadIndex))
+                continue;
+            const sameNamedMethods = methods.filter(it => it.method.name === peerMethod.method.name);
+            if (sameNamedMethods.length > 1)
+                sameNamedMethods.forEach((it, index) => it.overloadIndex = index);
+            groupedMethods = groupedMethods.concat(sameNamedMethods);
+        }
+        return groupedMethods;
+    }
+    setSameOverloadIndex(copyFrom) {
+        this.overloadIndex = copyFrom.overloadIndex;
+    }
+}
+//# sourceMappingURL=PeerMethod.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}`;
@@ -54,7 +57,7 @@ export class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
 ETSDeclarationNameConvertor.I = new ETSDeclarationNameConvertor();
 export class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl) {
-        const namespace = idl.getNamespacesPathFor(decl).join('');
+        const namespace = idl.getNamespacesPathFor(decl).map(it => it.name).join('');
         return `${namespace ? `${namespace}_` : ``}${decl.name}`;
     }
 }

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

@@ -5,5 +5,6 @@ export declare function qualifiedName(decl: idl.IDLNode, languageOrDelimiter: La
 export declare function typeOrUnion(types: idl.IDLType[], name?: string): idl.IDLType;
 export declare function generifiedTypeName(refType: idl.IDLReferenceType | undefined, refName?: string): string | undefined;
 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;
 //# sourceMappingURL=common.d.ts.map

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

@@ -64,6 +64,11 @@ export function generifiedTypeName(refType, refName) {
 export function generateSyntheticUnionName(types) {
     return `Union_${types.map(it => generateSyntheticIdlNodeName(it)).join("_")}`;
 }
+export function generateSyntheticFunctionName(parameters, returnType, isAsync = false) {
+    let prefix = isAsync ? "AsyncCallback" : "Callback";
+    const names = parameters.map(it => `${generateSyntheticIdlNodeName(it.type)}`).concat(generateSyntheticIdlNodeName(returnType));
+    return `${prefix}_${names.join("_").replaceAll(".", "_")}`;
+}
 export function isImportAttr(decl) {
     return idl.hasExtAttribute(decl, idl.IDLExtendedAttributes.Import);
 }

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

@@ -72,4 +72,12 @@ export declare function hashCodeFromString(value: string): number;
 export declare function forceWriteFile(filePath: string, content: string): void;
 export declare function findVersion(): any;
 export declare function zipMany<T>(...xs: T[][]): Array<Array<T | undefined>>;
+export declare class Lazy<T> {
+    private readonly factory;
+    constructor(factory: () => T);
+    private instantiated;
+    private instance;
+    get value(): T;
+}
+export declare function lazy<T>(factory: () => T): Lazy<T>;
 //# sourceMappingURL=util.d.ts.map

package/build/lib/src/util.js

@@ -619,4 +619,20 @@ export function zipMany(...xs) {
     }
     return result;
 }
+export class Lazy {
+    constructor(factory) {
+        this.instantiated = false;
+        this.factory = factory;
+    }
+    get value() {
+        if (!this.instantiated) {
+            this.instance = this.factory();
+            this.instantiated = true;
+        }
+        return this.instance;
+    }
+}
+export function lazy(factory) {
+    return new Lazy(factory);
+}
 //# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.0.15",
+  "version": "2.0.19",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,13 +34,9 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "2.0.15",
+    "@koalaui/interop": "1.4.6",
     "typescript": "4.9.5",
-    "@types/node": "^18.0.0",
-    "commander": "^10.0.0",
-    "comment-parser": "^1.4.1",
-    "cross-env": "^7.0.3",
-    "minimist": "^1.2.8"
+    "@types/node": "^18.0.0"
   },
   "scripts": {
     "clean": "rimraf -g build",

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.