@idlizer/core 2.1.7 → 2.1.9-arktscgen-5

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);
@@ -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);

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.js

@@ -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) {

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))
@@ -28,7 +30,8 @@ export function isMaterialized(declaration, resolver) {
         return true;
     }
     // TODO: rework this
-    if (["BaseSpan"].includes(declaration.name)) {
+    // TODO: CustomComponent from components.custom config file
+    if (["BaseSpan", "CustomComponent"].includes(declaration.name)) {
         return false;
     }
     for (const ignore of ["Attribute", "Method", "Interface"]) {
@@ -42,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);
@@ -73,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/util.d.ts

@@ -90,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;
@@ -617,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() {
@@ -692,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.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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.7",
+  "version": "2.1.9-arktscgen-5",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,7 +34,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.7.1",
+    "@koalaui/interop": "1.7.5",
     "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.