@idlizer/core 2.0.15 → 2.0.17

package/build/lib/src/LanguageWriters/ArgConvertors.js

@@ -123,7 +123,7 @@ export class StringConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         return writer.language == Language.CPP
             ? writer.makeUnsafeCast_(writer.makeString(`&${param}`), this.idlType, PrintHint.AsConstPointer)
-            : param;
+            : writer.escapeKeyword(param);
     }
     convertorSerialize(param, value, writer) {
         writer.writeMethodCall(`${param}Serializer`, `writeString`, [value]);
@@ -158,7 +158,7 @@ export class EnumConvertor extends BaseArgConvertor {
         this.enumEntry = enumEntry;
     }
     convertorArg(param, writer) {
-        return writer.makeEnumCast(param, false, this);
+        return writer.makeEnumCast(writer.escapeKeyword(param), false, this);
     }
     convertorSerialize(param, value, writer) {
         value =
@@ -199,7 +199,7 @@ export class NumberConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         return writer.language == Language.CPP
             ? writer.makeUnsafeCast_(writer.makeString(`&${param}`), this.idlType, PrintHint.AsConstPointer)
-            : param;
+            : writer.escapeKeyword(param);
     }
     convertorSerialize(param, value, printer) {
         printer.writeMethodCall(`${param}Serializer`, "writeNumber", [value]);
@@ -698,14 +698,26 @@ export class OptionConvertor extends BaseArgConvertor {
         const valueType = `${value}_type`;
         const serializedType = (printer.language == Language.JAVA ? undefined : idl.IDLI32Type);
         printer.writeStatement(printer.makeAssign(valueType, serializedType, printer.makeRuntimeType(RuntimeType.UNDEFINED), true, false));
-        printer.runtimeType(this, valueType, value);
-        printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.castToInt(valueType, 8)]);
+        if (printer.language != Language.CJ) {
+            printer.runtimeType(this, valueType, value);
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.castToInt(valueType, 8)]);
+        }
         printer.print(`if (${printer.makeRuntimeTypeCondition(valueType, false, RuntimeType.UNDEFINED, value).asString()}) {`);
         printer.pushIndent();
+        if (printer.language == Language.CJ) {
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.OBJECT.ordinal"]); // everything is object, except None<T>
+        }
         printer.writeStatement(printer.makeAssign(`${value}_value`, undefined, printer.makeValueFromOption(value, this.typeConvertor), true));
         this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, `${value}_value`), printer);
         printer.popIndent();
         printer.print(`}`);
+        if (printer.language == Language.CJ) {
+            printer.print('else {');
+            printer.pushIndent();
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.UNDEFINED.ordinal"]); // undefined
+            printer.popIndent();
+            printer.print('}');
+        }
     }
     convertorCArg(param) {
         throw new Error("Must never be used");

package/build/lib/src/LanguageWriters/LanguageWriter.d.ts

@@ -273,6 +273,7 @@ export declare abstract class LanguageWriter {
     writeStatement(stmt: LanguageStatement): void;
     writeStatements(...statements: LanguageStatement[]): void;
     writeExpressionStatement(smth: LanguageExpression): void;
+    writeStaticBlock(op: (writer: this) => void): void;
     makeRef(type: idl.IDLType, _options?: MakeRefOptions): idl.IDLType;
     makeThis(): LanguageExpression;
     makeNull(value?: string): LanguageExpression;

package/build/lib/src/LanguageWriters/LanguageWriter.js

@@ -281,11 +281,10 @@ export class LambdaExpression {
                 stmt.write(writer);
             }
         }
-        return writer.printer.getOutput()
-            .map(line => line.trim())
+        return writer.getOutput()
             .filter(line => line !== "")
-            .map(line => line === "{" || line === "}" || this.statementHasSemicolon ? line : `${line};`)
-            .join(" ");
+            .map(line => line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`)
+            .join("\n");
     }
 }
 ////////////////////////////////////////////////////////////////
@@ -438,6 +437,13 @@ export class LanguageWriter {
     writeExpressionStatement(smth) {
         this.writeStatement(new ExpressionStatement(smth));
     }
+    writeStaticBlock(op) {
+        this.print("static {");
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.print("}");
+    }
     makeRef(type, _options) {
         return type;
     }

package/build/lib/src/LanguageWriters/convertors/CppConvertors.js

@@ -25,7 +25,9 @@ export class CppInteropConvertor extends InteropConvertor {
         }
         const conf = generatorConfiguration();
         const typePrefix = conf.param("TypePrefix");
-        const libPrefix = idl.isPrimitiveType(type) ? "" : conf.param("LibraryPrefix");
+        // TODO remove this ugly hack for CustomObject's
+        const convertedToCustomObject = result.text === idl.IDLCustomObjectType.name;
+        const libPrefix = idl.isPrimitiveType(type) || convertedToCustomObject ? "" : conf.param("LibraryPrefix");
         return `${typePrefix}${libPrefix}${result.text}`;
     }
     convert(node) {

package/build/lib/src/LanguageWriters/writers/CJLanguageWriter.js

@@ -309,7 +309,7 @@ export class CJLanguageWriter extends LanguageWriter {
     }
     generateFunctionDeclaration(name, signature) {
         const args = signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`);
-        return `public func ${name}(${args.join(", ")})`;
+        return `public func ${name}(${args.join(", ")}): ${this.getNodeName(signature.returnType)}`;
     }
     writeMethodCall(receiver, method, params, nullable = false) {
         params = params.map(argName => this.escapeKeyword(argName));

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.js

@@ -15,7 +15,7 @@
 import * as idl from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, CheckOptionalStatement, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, Method, MethodModifier, NamedMethodSignature, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, CheckOptionalStatement, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { RuntimeType } from "../common";
 import { throwException } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
@@ -193,6 +193,10 @@ export class TSLanguageWriter extends LanguageWriter {
     }
     writeNativeMethodDeclaration(name, signature, isNative) {
         this.writeMethodImplementation(new Method(name, signature, [MethodModifier.STATIC]), writer => {
+            const selfCallExpression = writer.makeFunctionCall(`this.${name}`, signature.args.map((_, i) => writer.makeString(this.escapeKeyword(signature.argName(i)))));
+            writer.writeStatement(new IfStatement(new NaryOpExpression("==", [writer.makeFunctionCall("this._LoadOnce", []), writer.makeString("true")]), new BlockStatement([
+                writer.makeReturn(selfCallExpression)
+            ]), undefined, undefined, undefined));
             writer.writeStatement(writer.makeThrowError("Not implemented"));
         });
     }

package/build/lib/src/idl.js

@@ -517,7 +517,7 @@ export function createConstructor(parameters, returnType, nodeInitializer = {})
         returnType }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 export function createCallback(name, parameters, returnType, nodeInitializer = {}, typeParameters = []) {
-    if (returnType === IDLThisType)
+    if (returnType === IDLThisType || isReferenceType(returnType) && returnType.name === "this")
         returnType = IDLAnyType;
     parameters = parameters.map(it => {
         if (it.type && isNamedNode(it.type) && (it.type.name === "T" || it.type.name === "this"))

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

@@ -24,6 +24,11 @@ export * from "./LanguageWriters/writers/TsLanguageWriter";
 export * from "./LanguageWriters/writers/ETSLanguageWriter";
 export * from "./peer-generation/idl/IdlNameConvertor";
 export * from "./peer-generation/PrimitiveType";
+export * from "./peer-generation/PeerFile";
+export * from "./peer-generation/PeerClass";
+export * from "./peer-generation/PeerMethod";
+export * from "./peer-generation/BuilderClass";
+export * from "./peer-generation/Materialized";
 export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";

package/build/lib/src/index.js

@@ -38,6 +38,11 @@ export * from "./LanguageWriters/writers/TsLanguageWriter";
 export * from "./LanguageWriters/writers/ETSLanguageWriter";
 export * from "./peer-generation/idl/IdlNameConvertor";
 export * from "./peer-generation/PrimitiveType";
+export * from "./peer-generation/PeerFile";
+export * from "./peer-generation/PeerClass";
+export * from "./peer-generation/PeerMethod";
+export * from "./peer-generation/BuilderClass";
+export * from "./peer-generation/Materialized";
 export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";

package/build/lib/src/languageSpecificKeywords.js

@@ -35,7 +35,7 @@ export const CJKeywords = new Set([
     'break', 'is', 'as', 'in', 'match',
     'from', 'where', 'extend', 'spawn',
     'synchronized', 'macro', 'quote', 'true',
-    'false', 'static', 'public', 'private',
+    /*'false', */ 'static', 'public', 'private',
     'protected', 'override', 'redef', 'abstract',
     'open', 'operator', 'foreign', 'inout',
     'prop', 'mut', 'unsafe', 'get', 'set'

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

@@ -0,0 +1,22 @@
+import { IDLInterface, IDLReferenceType } from "../idl";
+import { Field, Method } from "../LanguageWriters/LanguageWriter";
+export declare class BuilderClass {
+    readonly declaration: IDLInterface;
+    readonly name: string;
+    readonly generics: string[] | undefined;
+    readonly isInterface: boolean;
+    readonly superClass: IDLReferenceType | undefined;
+    readonly fields: Field[];
+    readonly constructors: Method[];
+    readonly methods: Method[];
+    readonly needBeGenerated: boolean;
+    constructor(declaration: IDLInterface, name: string, generics: string[] | undefined, isInterface: boolean, superClass: IDLReferenceType | undefined, fields: Field[], constructors: Method[], methods: Method[], needBeGenerated?: boolean);
+}
+/**
+ * Builder classes are classes with methods which have only one parameter and return only itself
+ */
+export declare function isBuilderClass(declaration: IDLInterface): boolean;
+export declare const CUSTOM_BUILDER_CLASSES: BuilderClass[];
+export declare function isCustomBuilderClass(name: string): boolean;
+export declare function methodsGroupOverloads(methods: Method[]): Method[][];
+//# sourceMappingURL=BuilderClass.d.ts.map

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

@@ -0,0 +1,76 @@
+/*
+ * 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 { isDefined } from "../util";
+export class BuilderClass {
+    constructor(declaration, name, generics, isInterface, superClass, fields, constructors, methods, needBeGenerated = true) {
+        this.declaration = declaration;
+        this.name = name;
+        this.generics = generics;
+        this.isInterface = isInterface;
+        this.superClass = superClass;
+        this.fields = fields;
+        this.constructors = constructors;
+        this.methods = methods;
+        this.needBeGenerated = needBeGenerated;
+    }
+}
+/**
+ * Builder classes are classes with methods which have only one parameter and return only itself
+ */
+export function isBuilderClass(declaration) {
+    const className = declaration.name;
+    if (generatorConfiguration().paramArray("builderClasses").includes(className)) {
+        return true;
+    }
+    if (isCustomBuilderClass(className)) {
+        return true;
+    }
+    // TBD: update builder class check condition.
+    // Only SubTabBarStyle, BottomTabBarStyle, DotIndicator, and DigitIndicator classes
+    // are used for now.
+    return false;
+    /*
+    if (PeerGeneratorConfig.isStandardNameIgnored(className)) {
+        return false
+    }
+
+    const methods: (ts.MethodSignature | ts.MethodDeclaration)[] = [
+        ...ts.isClassDeclaration(declaration) ? declaration.members.filter(ts.isMethodDeclaration) : [],
+    ]
+
+    if (methods.length === 0) {
+        return false
+    }
+
+    return methods.every(it => it.type && className == it.type.getText() && it.parameters.length === 1)
+    */
+}
+export const CUSTOM_BUILDER_CLASSES = [];
+export function isCustomBuilderClass(name) {
+    return isDefined(CUSTOM_BUILDER_CLASSES.find(it => it.name === name));
+}
+export function methodsGroupOverloads(methods) {
+    const seenNames = new Set();
+    const groups = [];
+    for (const method of methods) {
+        if (seenNames.has(method.name))
+            continue;
+        seenNames.add(method.name);
+        groups.push(methods.filter(it => it.name === method.name));
+    }
+    return groups;
+}
+//# sourceMappingURL=BuilderClass.js.map

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

@@ -0,0 +1,58 @@
+import * as idl from '../idl';
+import { ArgConvertor } from '../LanguageWriters/ArgConvertors';
+import { Field, Method } from '../LanguageWriters/LanguageWriter';
+import { PeerClassBase } from './PeerClass';
+import { PeerMethod } from './PeerMethod';
+export declare class MaterializedField {
+    field: Field;
+    argConvertor: ArgConvertor;
+    outArgConvertor?: ArgConvertor | undefined;
+    isNullableOriginalTypeField?: boolean | undefined;
+    constructor(field: Field, argConvertor: ArgConvertor, outArgConvertor?: ArgConvertor | undefined, isNullableOriginalTypeField?: boolean | undefined);
+}
+export declare class MaterializedMethod extends PeerMethod {
+    implementationParentName: string;
+    outArgConvertor?: ArgConvertor | undefined;
+    constructor(originalParentName: string, implementationParentName: string, argConvertors: ArgConvertor[], returnType: idl.IDLType, isCallSignature: boolean, method: Method, outArgConvertor?: ArgConvertor | undefined);
+    get peerMethodName(): string;
+    get implNamespaceName(): string;
+    get toStringName(): string;
+    get dummyReturnValue(): string | undefined;
+    get receiverType(): string;
+    get apiCall(): string;
+    get apiKind(): string;
+    generateReceiver(): {
+        argName: string;
+        argType: string;
+    } | undefined;
+    getImplementationName(): string;
+    tsReturnType(): idl.IDLType | undefined;
+    getPrivateMethod(): MaterializedMethod;
+}
+export declare function copyMaterializedMethod(method: MaterializedMethod, overrides: {
+    method?: Method;
+}): MaterializedMethod;
+export declare class MaterializedClass implements PeerClassBase {
+    readonly decl: idl.IDLInterface;
+    readonly className: string;
+    readonly isInterface: boolean;
+    readonly superClass: idl.IDLReferenceType | undefined;
+    readonly interfaces: idl.IDLReferenceType[] | undefined;
+    readonly generics: string[] | undefined;
+    readonly fields: MaterializedField[];
+    readonly ctor: MaterializedMethod;
+    readonly finalizer: MaterializedMethod;
+    readonly methods: MaterializedMethod[];
+    readonly needBeGenerated: boolean;
+    readonly taggedMethods: idl.IDLMethod[];
+    constructor(decl: idl.IDLInterface, className: string, isInterface: boolean, superClass: idl.IDLReferenceType | undefined, interfaces: idl.IDLReferenceType[] | undefined, generics: string[] | undefined, fields: MaterializedField[], ctor: MaterializedMethod, finalizer: MaterializedMethod, methods: MaterializedMethod[], needBeGenerated?: boolean, taggedMethods?: idl.IDLMethod[]);
+    getComponentName(): string;
+    getImplementationName(): string;
+    generatedName(isCallSignature: boolean): string;
+    isGlobalScope(): boolean;
+}
+export declare function createDestroyPeerMethod(clazz: MaterializedClass): MaterializedMethod;
+export declare function getInternalClassName(name: string): string;
+export declare function getInternalClassQualifiedName(target: idl.IDLEntry): string;
+export declare function getMaterializedFileName(name: string): string;
+//# sourceMappingURL=Materialized.d.ts.map

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

@@ -0,0 +1,150 @@
+/*
+ * 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';
+import { copyMethod, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
+import { capitalize } from '../util';
+import { qualifiedName } from './idl/common';
+import { PeerMethod } from './PeerMethod';
+export class MaterializedField {
+    constructor(field, argConvertor, outArgConvertor, isNullableOriginalTypeField) {
+        this.field = field;
+        this.argConvertor = argConvertor;
+        this.outArgConvertor = outArgConvertor;
+        this.isNullableOriginalTypeField = isNullableOriginalTypeField;
+    }
+}
+export class MaterializedMethod extends PeerMethod {
+    constructor(originalParentName, implementationParentName, argConvertors, returnType, isCallSignature, method, outArgConvertor) {
+        super(originalParentName, argConvertors, returnType, isCallSignature, method, outArgConvertor);
+        this.implementationParentName = implementationParentName;
+        this.outArgConvertor = outArgConvertor;
+    }
+    get peerMethodName() {
+        return this.overloadedName;
+    }
+    get implNamespaceName() {
+        return `${capitalize(this.originalParentName)}Accessor`;
+    }
+    get toStringName() {
+        switch (this.method.name) {
+            case "ctor": return `new ${this.originalParentName}`;
+            case "destructor": return `delete ${this.originalParentName}`;
+            default: return super.toStringName;
+        }
+    }
+    get dummyReturnValue() {
+        var _a;
+        if (this.method.name === "ctor")
+            return `(${this.originalParentName}Peer*) 100`;
+        if (this.method.name === "getFinalizer")
+            return `fnPtr<KNativePointer>(dummyClassFinalizer)`;
+        if ((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.STATIC)) {
+            if (this.method.signature.returnType === idl.IDLNumberType) {
+                return '100';
+            }
+            if (this.method.signature.returnType === idl.IDLBooleanType) {
+                return '0';
+            }
+            return `(void*) 300`;
+        }
+        return undefined;
+    }
+    get receiverType() {
+        return `${this.originalParentName}Peer*`;
+    }
+    get apiCall() {
+        return "GetAccessors()";
+    }
+    get apiKind() {
+        return "Accessor";
+    }
+    generateReceiver() {
+        if (!this.hasReceiver())
+            return undefined;
+        return {
+            argName: 'peer',
+            argType: `${this.originalParentName}Peer*`
+        };
+    }
+    getImplementationName() {
+        return this.implementationParentName;
+    }
+    tsReturnType() {
+        return this.method.signature.returnType;
+    }
+    getPrivateMethod() {
+        var _a, _b;
+        let privateMethod = this;
+        if (!((_a = privateMethod.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.PRIVATE))) {
+            privateMethod = copyMaterializedMethod(this, {
+                method: copyMethod(this.method, {
+                    modifiers: ((_b = this.method.modifiers) !== null && _b !== void 0 ? _b : [])
+                        .filter(it => it !== MethodModifier.PUBLIC)
+                        .concat([MethodModifier.PRIVATE])
+                })
+            });
+        }
+        return privateMethod;
+    }
+}
+export function copyMaterializedMethod(method, overrides) {
+    var _a;
+    const copied = new MaterializedMethod(method.originalParentName, method.implementationParentName, method.argConvertors, method.returnType, method.isCallSignature, (_a = overrides.method) !== null && _a !== void 0 ? _a : method.method, method.outArgConvertor);
+    copied.setSameOverloadIndex(method);
+    return copied;
+}
+export class MaterializedClass {
+    constructor(decl, className, isInterface, superClass, interfaces, generics, fields, ctor, finalizer, methods, needBeGenerated = true, taggedMethods = []) {
+        this.decl = decl;
+        this.className = className;
+        this.isInterface = isInterface;
+        this.superClass = superClass;
+        this.interfaces = interfaces;
+        this.generics = generics;
+        this.fields = fields;
+        this.ctor = ctor;
+        this.finalizer = finalizer;
+        this.methods = methods;
+        this.needBeGenerated = needBeGenerated;
+        this.taggedMethods = taggedMethods;
+        PeerMethod.markAndGroupOverloads(methods);
+    }
+    getComponentName() {
+        return this.className;
+    }
+    getImplementationName() {
+        return this.isInterface ? getInternalClassName(this.className) : this.className;
+    }
+    generatedName(isCallSignature) {
+        return this.className;
+    }
+    isGlobalScope() {
+        return idl.hasExtAttribute(this.decl, idl.IDLExtendedAttributes.GlobalScope);
+    }
+}
+export function createDestroyPeerMethod(clazz) {
+    return new MaterializedMethod(clazz.className, clazz.getImplementationName(), [], idl.IDLVoidType, false, new Method('destroyPeer', new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.className)], ['peer'])));
+}
+export function getInternalClassName(name) {
+    return `${name}Internal`;
+}
+export function getInternalClassQualifiedName(target) {
+    return getInternalClassName(qualifiedName(target, "."));
+}
+export function getMaterializedFileName(name) {
+    const pascalCase = name.split('_').map(x => capitalize(x)).join('');
+    return `Ark${pascalCase}Materialized`;
+}
+//# sourceMappingURL=Materialized.js.map

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

@@ -0,0 +1,29 @@
+import { IDLProperty } from "../idl";
+import { PeerMethod } from "./PeerMethod";
+import { PeerFile } from "./PeerFile";
+export interface PeerClassBase {
+    generatedName(isCallSignature: boolean): string;
+    getComponentName(): string;
+}
+export declare class PeerClass implements PeerClassBase {
+    readonly file: PeerFile;
+    readonly componentName: string;
+    readonly originalFilename: string;
+    constructor(file: PeerFile, componentName: string, originalFilename: string);
+    generatedName(isCallSignature: boolean): string;
+    getComponentName(): string;
+    methods: PeerMethod[];
+    originalClassName: string | undefined;
+    originalInterfaceName: string | undefined;
+    originalParentName: string | undefined;
+    originalParentFilename: string | undefined;
+    parentComponentName: string | undefined;
+    attributesFields: IDLProperty[];
+    attributesTypes: {
+        typeName: string;
+        content: string;
+    }[];
+    hasGenericType: boolean;
+}
+export declare function createConstructPeerMethod(clazz: PeerClass): PeerMethod;
+//# sourceMappingURL=PeerClass.d.ts.map

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

@@ -0,0 +1,44 @@
+/*
+ * 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 { IDLI32Type, IDLPointerType } from "../idl";
+import { NumericConvertor } from "../LanguageWriters/ArgConvertors";
+import { PeerMethod } from "./PeerMethod";
+import { Method, MethodModifier, NamedMethodSignature } from "../LanguageWriters/LanguageWriter";
+export class PeerClass {
+    constructor(file, componentName, originalFilename) {
+        this.file = file;
+        this.componentName = componentName;
+        this.originalFilename = originalFilename;
+        this.methods = [];
+        this.originalClassName = undefined;
+        this.originalInterfaceName = undefined;
+        this.originalParentName = undefined;
+        this.originalParentFilename = undefined;
+        this.parentComponentName = undefined;
+        this.attributesFields = [];
+        this.attributesTypes = [];
+        this.hasGenericType = false;
+    }
+    generatedName(isCallSignature) {
+        return isCallSignature ? this.originalInterfaceName : this.originalClassName;
+    }
+    getComponentName() {
+        return this.componentName;
+    }
+}
+export function createConstructPeerMethod(clazz) {
+    return new PeerMethod(clazz.componentName, [new NumericConvertor('id', IDLI32Type), new NumericConvertor('flags', IDLI32Type)], IDLPointerType, false, new Method('construct', new NamedMethodSignature(IDLPointerType, [IDLI32Type, IDLI32Type], ['id', 'flags']), [MethodModifier.STATIC]));
+}
+//# sourceMappingURL=PeerClass.js.map

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

@@ -0,0 +1,13 @@
+import * as idl from '../idl';
+import { PeerClass } from "./PeerClass";
+import { LibraryFileInterface } from '../LibraryInterface';
+export declare class PeerFile implements LibraryFileInterface {
+    readonly originalFilename: string;
+    readonly entries: idl.IDLEntry[];
+    readonly isPredefined: boolean;
+    readonly peers: Map<string, PeerClass>;
+    constructor(originalFilename: string, entries: idl.IDLEntry[], isPredefined?: boolean);
+    packageName(): string;
+    get peersToGenerate(): PeerClass[];
+}
+//# sourceMappingURL=PeerFile.d.ts.map

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as idl from '../idl';
+export class PeerFile {
+    constructor(originalFilename, entries, isPredefined = false) {
+        this.originalFilename = originalFilename;
+        this.entries = entries;
+        this.isPredefined = isPredefined;
+        this.peers = new Map();
+    }
+    packageName() {
+        let packageTag = this.entries.find(it => idl.isPackage(it));
+        if (packageTag === undefined) {
+            return "";
+        }
+        if (packageTag.name.startsWith('"') && packageTag.name.endsWith('"')) {
+            return packageTag.name.slice(1, packageTag.name.length - 1);
+        }
+        return packageTag.name;
+    }
+    get peersToGenerate() {
+        const peers = Array.from(this.peers.values());
+        return peers;
+    }
+}
+//# sourceMappingURL=PeerFile.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.js

@@ -54,7 +54,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.17",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,13 +34,9 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "2.0.15",
+    "@koalaui/interop": "2.0.17",
     "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",