@idlizer/core 2.0.26 → 2.0.28

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

@@ -17,17 +17,38 @@ import * as idl from '../idl';
 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, } from "../LanguageWriters/ArgConvertors";
-import { InteropNameConvertor } from '../LanguageWriters/convertors/InteropConvertors';
+import { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
-import { CppInteropConvertor } from '../LanguageWriters/convertors/CppConvertors';
+import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { ETSTypeNameConvertor } from '../LanguageWriters/convertors/ETSConvertors';
 import { JavaTypeNameConvertor } from '../LanguageWriters/convertors/JavaConvertors';
 import { TSTypeNameConvertor } from '../LanguageWriters/convertors/TSConvertors';
 import { isBuilderClass } from './BuilderClass';
 import { generateSyntheticFunctionName, isImportAttr } from './idl/common';
-import { isMaterialized } from './Materialized';
 import { LayoutManager } from './LayoutManager';
+import { lib, query } from '../library';
+import { isMaterialized } from './isMaterialized';
+export const lenses = {
+    globals: lib.lens(lib.select.files())
+        .pipe(lib.select.nodes({ expandNamespaces: true }))
+        .pipe(lib.select.interfaces())
+        .pipe(lib.select.hasExt(idl.IDLExtendedAttributes.GlobalScope))
+};
 export class PeerLibrary {
+    asIDLLibrary() {
+        if (this._cachedIdlLibrary) {
+            return this._cachedIdlLibrary;
+        }
+        this._cachedIdlLibrary = {
+            files: this.files.map(file => ({
+                fileName: file.originalFilename,
+                entities: file.entries,
+                package: file.package()
+            }))
+        };
+        return this._cachedIdlLibrary;
+    }
+    get globalScopeInterfaces() { return query(this.asIDLLibrary(), lenses.globals); }
     /** @deprecated PeerLibrary should contain only SDK entries */
     get syntheticEntries() {
         return this._syntheticEntries;
@@ -41,19 +62,19 @@ export class PeerLibrary {
     get materializedToGenerate() {
         return Array.from(this.materializedClasses.values()).filter(it => it.needBeGenerated);
     }
-    constructor(language) {
+    constructor(language, libraryPackages) {
         this.language = language;
+        this.libraryPackages = libraryPackages;
         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);
+        this.interopNameConvertorInstance = new CppNameConvertor(this);
     }
     createLanguageWriter(language) {
         return createLanguageWriter(language !== null && language !== void 0 ? language : this.language, this);
@@ -64,7 +85,7 @@ export class PeerLibrary {
             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);
+            case Language.CPP: return new CppConvertor(this);
         }
         throw new Error(`IdlNameConvertor for ${language} is not implemented`);
     }
@@ -165,6 +186,23 @@ export class PeerLibrary {
         } // end of block to remove
         return undefined; // empty result
     }
+    resolvePackageName(entry) {
+        var _a;
+        if (this._syntheticEntries.includes(entry))
+            return ((_a = this.libraryPackages) === null || _a === void 0 ? void 0 : _a.length) ? this.libraryPackages[0] : this.files[0].packageName();
+        while (entry.namespace) {
+            entry = entry.namespace;
+        }
+        for (const file of this.files) {
+            if (file.entries.includes(entry))
+                return file.packageName();
+        }
+        throw new Error(`Package name for entry ${entry.name} was not found`);
+    }
+    hasInLibrary(entry) {
+        var _a, _b;
+        return !((_a = this.libraryPackages) === null || _a === void 0 ? void 0 : _a.length) || ((_b = this.libraryPackages) === null || _b === void 0 ? void 0 : _b.includes(this.resolvePackageName(entry)));
+    }
     typeConvertor(param, type, isOptionalParam = false) {
         if (isOptionalParam) {
             return new OptionConvertor(this, param, idl.maybeUnwrapOptionalType(type));
@@ -194,7 +232,7 @@ export class PeerLibrary {
                 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");
+                case idl.IDLAnyType: return new CustomTypeConvertor(param, "Any", false, "Object");
                 default: throw new Error(`Unconverted primitive ${idl.DebugUtils.debugPrintType(type)}`);
             }
         }
@@ -215,7 +253,7 @@ export class PeerLibrary {
         }
         if (idl.isTypeParameterType(type)) {
             // TODO: unlikely correct.
-            return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), true);
+            return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), true, `<${type.name}>`);
         }
         throw new Error(`Cannot convert: ${type.kind}`);
     }
@@ -267,7 +305,7 @@ export class PeerLibrary {
     customConvertor(param, typeName, type) {
         switch (typeName) {
             case `Object`:
-                return new CustomTypeConvertor(param, "Object");
+                return new CustomTypeConvertor(param, "Object", false, "Object");
             case `Date`:
                 return new DateConvertor(param);
             case `Function`:

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

@@ -19,6 +19,7 @@ export declare class PrimitiveTypeList {
     readonly Tag: PrimitiveType;
     readonly Materialized: PrimitiveType;
     readonly CustomObject: PrimitiveType;
+    readonly String: PrimitiveType;
 }
 export declare const PrimitiveTypesInstance: PrimitiveTypeList;
 //# sourceMappingURL=PrimitiveType.d.ts.map

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

@@ -37,6 +37,7 @@ export class PrimitiveTypeList {
         this.Tag = new PrimitiveType(`Tag`);
         this.Materialized = new PrimitiveType(`Materialized`, true);
         this.CustomObject = new PrimitiveType(`CustomObject`, true);
+        this.String = new PrimitiveType(`String`);
     }
     static get UndefinedTag() {
         return "INTEROP_TAG_UNDEFINED";

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

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

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

@@ -0,0 +1,46 @@
+/*
+ * 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 { generatorConfiguration } from '../config';
+import * as idl from '../idl';
+import { isBuilderClass } from './BuilderClass';
+export function isMaterialized(declaration, resolver) {
+    if (!idl.isInterfaceSubkind(declaration) && !idl.isClassSubkind(declaration))
+        return false;
+    if (idl.isHandwritten(declaration) || isBuilderClass(declaration))
+        return false;
+    for (const forceMaterialized of generatorConfiguration().forceMaterialized) {
+        if (declaration.name == forceMaterialized)
+            return true;
+    }
+    for (const ignore of generatorConfiguration().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 || 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));
+        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;
+}
+//# sourceMappingURL=isMaterialized.js.map

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

@@ -0,0 +1,4 @@
+import { IDLType } from "../idl";
+import { ReferenceResolver } from "./ReferenceResolver";
+export declare function isStructureType(type: IDLType, library: ReferenceResolver): boolean;
+//# sourceMappingURL=isStructureType.d.ts.map

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { isReferenceType, isInterface } from "../idl";
+import { isMaterialized } from "./isMaterialized";
+export function isStructureType(type, library) {
+    if (!isReferenceType(type))
+        return false;
+    const resolved = library.resolveTypeReference(type);
+    if (!resolved || !isInterface(resolved))
+        return false;
+    return !isMaterialized(resolved, library);
+}
+//# sourceMappingURL=isStructureType.js.map

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

@@ -23,7 +23,7 @@ export declare class UnionRuntimeTypeChecker {
     constructor(convertors: ArgConvertor[]);
     private checkConflicts;
     makeDiscriminator(value: string, convertorIndex: number, writer: LanguageWriter): LanguageExpression;
-    reportConflicts(context: string | undefined): void;
+    reportConflicts(context: string | undefined, writer: LanguageWriter): void;
 }
 export declare function flattenUnionType(library: LibraryInterface, type: IDLType): IDLType;
 //# sourceMappingURL=unions.d.ts.map

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

@@ -15,6 +15,7 @@
 import { convertType } from "../LanguageWriters";
 import { IDLCustomObjectType, IDLUndefinedType, isType, isUnionType } from '../idl';
 import { typeOrUnion } from "./idl/common";
+import { CustomTypeConvertor } from "../LanguageWriters/ArgConvertors";
 import { RuntimeType } from "../LanguageWriters/common";
 export class UnionFlattener {
     constructor(resolver) {
@@ -92,10 +93,20 @@ export class UnionRuntimeTypeChecker {
             writer.makeUnionVariantCondition(convertor, value, `${value}_type`, RuntimeType[it], convertorIndex, runtimeTypeIndex)
         ])));
     }
-    reportConflicts(context) {
+    reportConflicts(context, writer) {
         if (this.discriminators.filter(([discriminator, _, __]) => discriminator === undefined).length > 1) {
-            this.discriminators.forEach(([discr, conv, n]) => console.log(`   ${n} : ${conv.constructor.name} : ${discr ? discr.asString() : "<undefined>"}`));
-            throw new Error(`runtime type conflict in \`${context}\``);
+            let report = `Union discrimination code can not be generated for \`${context}\`.\n`;
+            report += `Possible reasons for that are too similar or unresolved types in union (see below).\n`;
+            report += ` #  | type                          | duplicated properties         | resolved | discriminator expression\n`;
+            const properties = Array.from(this.duplicateMembers).join(",").padEnd(30);
+            this.discriminators.forEach(([discr, conv, n]) => {
+                const num = n.toString().padEnd(3);
+                const typename = conv.targetType(writer).padEnd(30);
+                const resolved = (conv instanceof CustomTypeConvertor ? "no" : "yes").padEnd(9);
+                const discriminator = discr ? discr.asString() : "<undefined>";
+                report += ` ${num}| ${typename}| ${properties}| ${resolved}| ${discriminator}\n`;
+            });
+            throw new Error(report);
         }
     }
 }

package/package.json

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