@idlizer/core 2.1.5 → 2.1.9-arktscgen-4

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

@@ -17,7 +17,7 @@ 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, } 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, ExternalTypeConvertor, } from "../LanguageWriters/ArgConvertors";
 import { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
@@ -32,6 +32,8 @@ import { isMaterialized } from './isMaterialized';
 import { isInIdlizeInternal } from '../idlize';
 import { isInCurrentModule } from './modules';
 import { generatorConfiguration } from '../config';
+import { isExternalType } from './isExternalType';
+import { KotlinTypeNameConvertor } from '../LanguageWriters/convertors/KotlinConvertors';
 export const lenses = {
     globals: lib.lens(lib.select.files())
         .pipe(lib.select.nodes())
@@ -86,11 +88,16 @@ export class PeerLibrary {
     get buildersToGenerate() {
         return Array.from(this.builderClasses.values()).filter(it => it.needBeGenerated);
     }
-    get materializedToGenerate() {
-        return Array.from(this.materializedClasses.values()).filter(it => it.needBeGenerated);
+    get orderedMaterialized() {
+        function accessorName(decl) {
+            return idl.getQualifiedName(decl, "namespace.name");
+        }
+        return Array.from(this.materializedClasses.values()).filter(it => it.needBeGenerated)
+            .sort((a, b) => accessorName(a.decl).localeCompare(accessorName(b.decl)));
     }
-    constructor(language, useMemoM3 = false) {
+    constructor(language, interopNativeModule, useMemoM3 = false) {
         this.language = language;
+        this.interopNativeModule = interopNativeModule;
         this.useMemoM3 = useMemoM3;
         this.layout = LayoutManager.Empty();
         this._syntheticFile = idl.createFile([]);
@@ -114,6 +121,7 @@ export class PeerLibrary {
             case Language.JAVA: return new JavaTypeNameConvertor(this);
             case Language.CJ: return new CJTypeNameConvertor(this);
             case Language.CPP: return new CppConvertor(this);
+            case Language.KOTLIN: return new KotlinTypeNameConvertor(this);
         }
         throw new Error(`IdlNameConvertor for ${language} is not implemented`);
     }
@@ -156,6 +164,15 @@ export class PeerLibrary {
         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);
@@ -182,8 +199,7 @@ export class PeerLibrary {
         }
         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);
+        (_b = this.referenceCache) === null || _b === void 0 ? void 0 : _b.set(type, result);
         return result;
     }
     disableFallback() {
@@ -293,6 +309,7 @@ export class PeerLibrary {
                 case idl.IDLUndefinedType: return new UndefinedConvertor(param);
                 case idl.IDLVoidType: return new VoidConvertor(param);
                 case idl.IDLUnknownType:
+                case idl.IDLObjectType:
                 case idl.IDLAnyType: return new ObjectConvertor(param, idl.IDLAnyType);
                 case idl.IDLDate: return new DateConvertor(param);
                 case idl.IDLFunctionType: return new FunctionConvertor(this, param);
@@ -365,7 +382,7 @@ export class PeerLibrary {
             return new EnumConvertor(param, declaration.parent);
         }
         if (idl.isCallback(declaration)) {
-            return new CallbackConvertor(this, param, declaration);
+            return new CallbackConvertor(this, param, declaration, this.interopNativeModule);
         }
         if (idl.isTypedef(declaration)) {
             if (isCyclicTypeDef(declaration)) {
@@ -375,8 +392,11 @@ export class PeerLibrary {
             return new TypeAliasConvertor(this, param, declaration);
         }
         if (idl.isInterface(declaration)) {
+            if (isExternalType(declaration, this)) {
+                return new ExternalTypeConvertor(this, param, declaration);
+            }
             if (isMaterialized(declaration, this)) {
-                return new MaterializedClassConvertor(param, declaration);
+                return new MaterializedClassConvertor(this, param, declaration);
             }
             if (isBuilderClass(declaration)) {
                 return new ClassConvertor(this, declarationName, param, declaration);
@@ -417,12 +437,12 @@ export class PeerLibrary {
             case idl.IDLVoidType: return idl.IDLVoidType;
             case idl.IDLUndefinedType: return idl.IDLUndefinedType;
             case idl.IDLUnknownType: return ArkCustomObject;
-            case idl.IDLObjectType: return ArkCustomObject;
+            // case idl.IDLObjectType: return ArkCustomObject
         }
         const typeName = idl.isNamedNode(type) ? type.name : undefined;
         switch (typeName) {
             case "object":
-            case "Object": return ArkCustomObject;
+            case "Object": return idl.IDLObjectType;
         }
         if (idl.isReferenceType(type)) {
             // TODO: remove all this!

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

@@ -10,7 +10,7 @@ export declare class PeerMethod {
     isCallSignature: boolean;
     method: Method;
     outArgConvertor?: ArgConvertor | undefined;
-    private overloadIndex?;
+    protected overloadIndex?: number;
     constructor(originalParentName: string, argConvertors: ArgConvertor[], returnType: IDLType, isCallSignature: boolean, method: Method, outArgConvertor?: ArgConvertor | undefined);
     get overloadedName(): string;
     get fullMethodName(): string;

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

@@ -0,0 +1,5 @@
+import * as idl from '../idl';
+import { ReferenceResolver } from './ReferenceResolver';
+export declare function getSuper(declaration: idl.IDLInterface, resolver: ReferenceResolver): idl.IDLInterface | undefined;
+export declare function getSuperType(declaration: idl.IDLInterface, resolver: ReferenceResolver): idl.IDLReferenceType | undefined;
+//# sourceMappingURL=getSuperType.d.ts.map

package/build/lib/src/peer-generation/getSuperType.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';
+function getSuperCandidates(declaration, resolver) {
+    return declaration.inheritance
+        .map(it => [resolver.resolveTypeReference(it), it])
+        .filter(([it,]) => it && idl.isInterface(it) && idl.isClassSubkind(it))
+        .map(it => it);
+}
+function getSuperTuple(declaration, resolver) {
+    if (idl.isClassSubkind(declaration)) {
+        const found = declaration.inheritance.find(it => idl.hasExtAttribute(it, idl.IDLExtendedAttributes.Extends));
+        if (found) {
+            const resolved = resolver.resolveTypeReference(found);
+            if (resolved && idl.isInterface(resolved)) {
+                return [resolved, found];
+            }
+        }
+        const candidates = getSuperCandidates(declaration, resolver);
+        if (candidates.length > 0) {
+            return candidates[0];
+        }
+        return undefined;
+    }
+    const fst = declaration.inheritance[0];
+    if (!fst) {
+        return undefined;
+    }
+    const resolved = resolver.resolveTypeReference(fst);
+    if (!resolved || !idl.isInterface(resolved)) {
+        return undefined;
+    }
+    return [resolved, fst];
+}
+export function getSuper(declaration, resolver) {
+    var _a;
+    return (_a = getSuperTuple(declaration, resolver)) === null || _a === void 0 ? void 0 : _a[0];
+}
+export function getSuperType(declaration, resolver) {
+    var _a;
+    return (_a = getSuperTuple(declaration, resolver)) === null || _a === void 0 ? void 0 : _a[1];
+}
+//# sourceMappingURL=getSuperType.js.map

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

@@ -34,6 +34,10 @@ export declare class CJFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: CJFeatureNameConvertor;
 }
+export declare class KotlinFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl: idl.IDLEnum): string;
+    static readonly I: KotlinFeatureNameConvertor;
+}
 export declare function createDeclarationNameConvertor(language: Language): DeclarationNameConvertor;
 export declare function createFeatureNameConvertor(language: Language): DeclarationNameConvertor;
 //# sourceMappingURL=IdlNameConvertor.d.ts.map

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

@@ -85,6 +85,12 @@ export class CJFeatureNameConvertor extends DeclarationNameConvertor {
     }
 }
 CJFeatureNameConvertor.I = new CJFeatureNameConvertor();
+export class KotlinFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+KotlinFeatureNameConvertor.I = new KotlinFeatureNameConvertor();
 export function createDeclarationNameConvertor(language) {
     switch (language) {
         case Language.ARKTS: return ETSDeclarationNameConvertor.I;
@@ -102,6 +108,7 @@ export function createFeatureNameConvertor(language) {
         case Language.CPP:
         case Language.TS: return TSFeatureNameConvertor.I;
         case Language.CJ: return CJFeatureNameConvertor.I;
+        case Language.KOTLIN: return KotlinFeatureNameConvertor.I;
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }

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

@@ -6,6 +6,7 @@ export declare function collapseTypes(types: idl.IDLType[], name?: string): idl.
 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 generateSyntheticFunctionParameterName(parameter: idl.IDLParameter): 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

@@ -28,7 +28,7 @@ export function generateSyntheticIdlNodeName(type) {
         }
     }
     if (idl.isNamedNode(type))
-        return type.name;
+        return type.name.split('.').map(capitalize).join('_');
     if (idl.isOptionalType(type))
         return `Opt_${generateSyntheticIdlNodeName(type.type)}`;
     throw `Can not compute type name of ${idl.IDLKind[type.kind]}`;
@@ -58,7 +58,7 @@ export function generifiedTypeName(refType, refName) {
     var _a;
     if (!refType)
         return undefined;
-    const typeArgs = (_a = refType.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it)).join(",");
+    const typeArgs = (_a = refType.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it) /* FIXME: BUG! */).join(",");
     return `${refName ? refName : refType.name}${typeArgs ? `<${typeArgs}>` : ``}`;
 }
 export function sanitizeGenerics(genericDeclarationString) {
@@ -75,9 +75,15 @@ export function sanitizeGenerics(genericDeclarationString) {
 export function generateSyntheticUnionName(types) {
     return `Union_${types.map(it => generateSyntheticIdlNodeName(it)).join("_").replaceAll(".", "_")}`;
 }
+export function generateSyntheticFunctionParameterName(parameter) {
+    if (parameter.isOptional) {
+        return generateSyntheticIdlNodeName(idl.createOptionalType(parameter.type));
+    }
+    return generateSyntheticIdlNodeName(parameter.type);
+}
 export function generateSyntheticFunctionName(parameters, returnType, isAsync = false) {
     let prefix = isAsync ? "AsyncCallback" : "Callback";
-    const names = parameters.map(it => `${generateSyntheticIdlNodeName(it.type)}`).concat(generateSyntheticIdlNodeName(returnType));
+    const names = parameters.map(generateSyntheticFunctionParameterName).concat(generateSyntheticIdlNodeName(returnType));
     return `${prefix}_${names.join("_").replaceAll(".", "_")}`;
 }
 export function isImportAttr(decl) {

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

@@ -0,0 +1,4 @@
+import * as idl from '../idl';
+import { ReferenceResolver } from './ReferenceResolver';
+export declare function isExternalType(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
+//# sourceMappingURL=isExternalType.d.ts.map

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

@@ -0,0 +1,15 @@
+import * as idl from '../idl';
+import { generatorConfiguration } from '../config';
+export function isExternalType(declaration, resolver) {
+    // declarations outside of the generator input dirs
+    if (generatorConfiguration().externalTypes.get(declaration.name) != undefined)
+        return true;
+    // treat as external types only declarations with methods
+    if (declaration.methods.length == 0)
+        return false;
+    const pack = idl.getPackageName(declaration);
+    if (generatorConfiguration().externalPackages.includes(pack))
+        return true;
+    return false;
+}
+//# sourceMappingURL=isExternalType.js.map

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

@@ -15,6 +15,8 @@
 import { generatorConfiguration } from '../config';
 import * as idl from '../idl';
 import { isBuilderClass } from './BuilderClass';
+import { isExternalType } from './isExternalType';
+import { getSuper } from './getSuperType';
 export function isMaterialized(declaration, resolver) {
     var _a;
     if (!idl.isInterfaceSubkind(declaration) && !idl.isClassSubkind(declaration))
@@ -27,6 +29,11 @@ export function isMaterialized(declaration, resolver) {
     if (generatorConfiguration().forceMaterialized.includes(declaration.name)) {
         return true;
     }
+    // TODO: rework this
+    // TODO: CustomComponent from components.custom config file
+    if (["BaseSpan", "CustomComponent"].includes(declaration.name)) {
+        return false;
+    }
     for (const ignore of ["Attribute", "Method", "Interface"]) {
         if (declaration.name.endsWith(ignore)) {
             return false;
@@ -38,15 +45,19 @@ export function isMaterialized(declaration, resolver) {
     if (generatorConfiguration().ignoreMaterialized.includes(declaration.name)) {
         return false;
     }
+    if (isExternalType(declaration, resolver)) {
+        return false;
+    }
     // A materialized class is a class or an interface with methods
     // excluding components and related classes
     if (declaration.methods.length > 0 || declaration.constructors.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));
+    const superClass = getSuper(declaration, resolver);
+    if (superClass) {
+        const superType = superClass;
         if (!superType || !idl.isInterface(superType)) {
-            console.log(`Unable to resolve ${idl.getSuperType(declaration).name} type, consider ${declaration.name} to be not materialized`);
+            console.log(`Unable to resolve ${superClass.name} type, consider ${declaration.name} to be not materialized`);
             return false;
         }
         return isMaterialized(superType, resolver);
@@ -69,10 +80,11 @@ export function isStaticMaterialized(declaration, resolver) {
             return false;
         if (!declaration.methods.every(it => it.isStatic && !isSelfReturnMethod(it, declaration, resolver)))
             return false;
-        if (idl.hasSuperType(declaration)) {
-            const superType = resolver.resolveTypeReference(idl.getSuperType(declaration));
+        const superClass = getSuper(declaration, resolver);
+        if (superClass) {
+            const superType = superClass;
             if (!superType || !idl.isInterface(superType)) {
-                console.log(`Unable to resolve ${idl.getSuperType(declaration).name} type, consider ${declaration.name} to be not materialized`);
+                console.log(`Unable to resolve ${superClass.name} type, consider ${declaration.name} to be not materialized`);
                 return false;
             }
             return isStaticMaterialized(superType, resolver);

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

@@ -110,7 +110,7 @@ export class UnionRuntimeTypeChecker {
                 const discriminator = discr ? discr.asString() : "<undefined>";
                 report += ` ${num}| ${typename}| ${properties}| ${resolved}| ${discriminator}\n`;
             });
-            throw new Error(report);
+            // throw new Error(report)
         }
     }
 }

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

@@ -42,6 +42,7 @@ export declare function heritageDeclarations(typechecker: ts.TypeChecker, clause
 export declare function typeName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): string | undefined;
 export declare function typeEntityName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): ts.EntityName | undefined;
 export declare function zip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
+export declare function zipStrip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
 export declare function identNameWithNamespace(node: ts.Node, language: Language): string;
 export declare function identName(node: ts.Node | undefined): string | undefined;
 export declare function identString(node: ts.Identifier | ts.PrivateIdentifier | ts.StringLiteral | ts.QualifiedName | ts.NumericLiteral | ts.ComputedPropertyName | ts.BindingName | undefined): string | undefined;
@@ -66,7 +67,7 @@ export declare function className(node: ts.ClassDeclaration | ts.InterfaceDeclar
  * Add a prefix to an enum value which camel case name coincidence
  * with the the same upper case name for an another enum value
  */
-export declare function nameEnumValues(enumTarget: ts.EnumDeclaration): string[];
+export declare function nameEnumValues(enumTarget: string[]): string[];
 export declare function groupBy<K, V>(values: V[], selector: (value: V) => K): Map<K, V[]>;
 export declare function groupByIndexed<K, V>(values: V[], selector: (value: V) => K): Map<K, [V, number][]>;
 export declare function removeExt(filename: string): string;
@@ -89,5 +90,7 @@ type StringProperties<T> = {
     [Property in keyof T as (T[Property] extends string ? Property : never)]: T[Property];
 };
 export declare function sorted<T, N extends keyof StringProperties<T>>(array: T[], key: ((value: T) => string) | N): T[];
+export declare function getExtractorName(target: idl.IDLInterface, language: Language, toPtr?: boolean): string;
+export declare function getExternalTypePackage(node: idl.IDLEntry): string | undefined;
 export {};
 //# sourceMappingURL=util.d.ts.map

package/build/lib/src/util.js

@@ -17,6 +17,7 @@ import * as fs from "fs";
 import * as ts from "typescript";
 import * as idl from "./idl";
 import { Language } from './Language';
+import { generatorConfiguration } from './config';
 /** True if this is visible outside this file, false otherwise */
 export function isNodePublic(node) {
     return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Public) !== 0;
@@ -269,6 +270,13 @@ export function zip(left, right) {
         throw new Error("Arrays of different length");
     return left.map((_, i) => [left[i], right[i]]);
 }
+export function zipStrip(left, right) {
+    const result = [];
+    for (let i = 0; i < left.length && i < right.length; ++i) {
+        result.push([left[i], right[i]]);
+    }
+    return result;
+}
 export function identNameWithNamespace(node, language) {
     let parent = node.parent;
     while (parent && !ts.isModuleDeclaration(parent))
@@ -558,9 +566,7 @@ export function className(node) {
 export function nameEnumValues(enumTarget) {
     const prefix = "LEGACY";
     const nameToIndex = new Map();
-    enumTarget.members
-        .map(it => identName(it.name))
-        .forEach((name, index) => {
+    enumTarget.forEach((name, index) => {
         let upperCaseName;
         if (isUpperCase(name)) {
             upperCaseName = name;
@@ -612,13 +618,10 @@ export function hashCodeFromString(value) {
     return hash;
 }
 export function forceWriteFile(filePath, content) {
-    path.dirname(filePath).split(path.sep).reduce((last, dir) => {
-        const dirPath = path.join(last, dir);
-        if (!fs.existsSync(dirPath)) {
-            fs.mkdirSync(dirPath);
-        }
-        return dirPath;
-    }, ".");
+    const dirPath = path.dirname(filePath);
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
     fs.writeFileSync(filePath, content);
 }
 export function findVersion() {
@@ -687,4 +690,16 @@ export function sorted(array, key) {
     return array.map(it => it)
         .sort((a, b) => comparator.compare(a[key], b[key]));
 }
+export function getExtractorName(target, language, toPtr = true) {
+    // TODO: Update for CJ
+    return toPtr ? `to${target.name}Ptr` : `from${target.name}Ptr`;
+}
+export function getExternalTypePackage(node) {
+    if (!idl.isInterface(node))
+        return undefined;
+    const pack = idl.getPackageName(node);
+    if (generatorConfiguration().externalPackages.includes(pack))
+        return `@${pack}`;
+    return generatorConfiguration().externalTypes.get(node.name);
+}
 //# sourceMappingURL=util.js.map

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

@@ -39,4 +39,6 @@ export declare class IDLDependencyCollector implements IDLConverter<idl.IDLNode[
     walk(node?: idl.IDLNode): idl.IDLNode[];
 }
 export declare function collectDependencies(resolver: ReferenceResolver, node: idl.IDLNode): idl.IDLNode[];
+export declare function filterRedundantMethodsOverloads(methods: idl.IDLMethod[]): idl.IDLMethod[];
+export declare function filterRedundantAttributesOverloads(properties: idl.IDLProperty[]): idl.IDLProperty[];
 //# sourceMappingURL=visitor.d.ts.map

package/build/lib/src/visitor.js

@@ -89,7 +89,6 @@ export class IDLDependencyCollector {
     visitInterface(decl) {
         return [
             ...decl.inheritance
-                .filter(it => it !== idl.IDLTopType)
                 .flatMap(it => this.walk(it)),
             ...decl.properties
                 .filter(it => !it.isStatic)
@@ -134,4 +133,112 @@ export class IDLDependencyCollector {
 export function collectDependencies(resolver, node) {
     return walkIDL(new IDLDependencyCollector(resolver), node);
 }
+function isFirstTypeSubsetOfSecond(first, second) {
+    if (idl.isOptionalType(second)) {
+        return isFirstTypeSubsetOfSecond(idl.maybeUnwrapOptionalType(first), idl.maybeUnwrapOptionalType(second));
+    }
+    if (idl.isUnionType(second)) {
+        const firstTypes = idl.isUnionType(first) ? first.types : [first];
+        const secondTypes = second.types;
+        return firstTypes.every(firstType => secondTypes.some(secondType => isFirstTypeSubsetOfSecond(firstType, secondType)));
+    }
+    return idl.printType(first) === idl.printType(second);
+}
+function isFirstParameterSubsetOfSecond(first, second) {
+    if (first === undefined)
+        return second.isOptional;
+    if (first.isOptional && !second.isOptional)
+        return false;
+    if (second.isOptional)
+        return isFirstTypeSubsetOfSecond(idl.maybeUnwrapOptionalType(first.type), idl.maybeUnwrapOptionalType(second.type));
+    return isFirstTypeSubsetOfSecond(first.type, second.type);
+}
+function isFirstMethodSubsetOfSecond(first, second) {
+    if (first.parameters.length > second.parameters.length)
+        return false;
+    if (first.isAsync !== second.isAsync)
+        return false;
+    if (first.isStatic !== second.isStatic)
+        return false;
+    if (second.parameters.some((secondParameter, idx) => !isFirstParameterSubsetOfSecond(first.parameters.at(idx), secondParameter)))
+        return false;
+    if (!isFirstTypeSubsetOfSecond(first.returnType, second.returnType))
+        return false;
+    return true;
+}
+function isFirstPropertySubsetOfSecond(first, second) {
+    if (idl.getExtAttribute(first, idl.IDLExtendedAttributes.Accessor) !==
+        idl.getExtAttribute(second, idl.IDLExtendedAttributes.Accessor))
+        return false;
+    if (first.isStatic !== second.isStatic)
+        return false;
+    if (first.isOptional && !second.isOptional)
+        return false;
+    if (second.isOptional)
+        return isFirstTypeSubsetOfSecond(idl.maybeUnwrapOptionalType(first.type), idl.maybeUnwrapOptionalType(second.type));
+    return isFirstTypeSubsetOfSecond(first.type, second.type);
+}
+function filterRedundantOverloadsSameNamed(entries) {
+    const entryToSupersets = new Map();
+    for (const entry of entries) {
+        entryToSupersets.set(entry, []);
+        for (const other of entries) {
+            if (entry === other)
+                continue;
+            if (idl.isMethod(entry) && idl.isMethod(other)) {
+                if (isFirstMethodSubsetOfSecond(entry, other))
+                    entryToSupersets.get(entry).push(other);
+            }
+            else if (idl.isProperty(entry) && idl.isProperty(other)) {
+                if (isFirstPropertySubsetOfSecond(entry, other))
+                    entryToSupersets.get(entry).push(other);
+            }
+            else {
+                throw new Error("Not implemented");
+            }
+        }
+    }
+    const visited = [];
+    const roots = [];
+    const visit = (method) => {
+        if (visited.includes(method))
+            return;
+        visited.push(method);
+        for (const superset of entryToSupersets.get(method)) {
+            visit(superset);
+        }
+        if (!entryToSupersets.get(method).some(it => roots.includes(it)))
+            roots.push(method);
+    };
+    entries.forEach(visit);
+    return roots;
+}
+export function filterRedundantMethodsOverloads(methods) {
+    const sameNamedGroups = new Map();
+    for (const method of methods) {
+        if (!sameNamedGroups.has(method.name))
+            sameNamedGroups.set(method.name, []);
+        sameNamedGroups.get(method.name).push(method);
+    }
+    const filtered = [];
+    for (const sameNamed of sameNamedGroups.values()) {
+        filtered.push(...filterRedundantOverloadsSameNamed(sameNamed));
+    }
+    // stabilizing order
+    return methods.filter(it => filtered.includes(it));
+}
+export function filterRedundantAttributesOverloads(properties) {
+    const sameNamedGroups = new Map();
+    for (const property of properties) {
+        if (!sameNamedGroups.has(property.name))
+            sameNamedGroups.set(property.name, []);
+        sameNamedGroups.get(property.name).push(property);
+    }
+    const filtered = [];
+    for (const sameNamed of sameNamedGroups.values()) {
+        filtered.push(...filterRedundantOverloadsSameNamed(sameNamed));
+    }
+    // stabilizing order
+    return properties.filter(it => filtered.includes(it));
+}
 //# sourceMappingURL=visitor.js.map

package/package.json

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