@idlizer/core 2.0.15 → 2.0.19

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

@@ -0,0 +1,2 @@
+export * from "./nameConvertor";
+//# sourceMappingURL=index.d.ts.map

package/build/lib/src/peer-generation/LanguageWriters/index.js

@@ -0,0 +1,2 @@
+export * from "./nameConvertor";
+//# sourceMappingURL=index.js.map

package/build/lib/src/peer-generation/LanguageWriters/nameConvertor.d.ts

@@ -0,0 +1,25 @@
+import * as idl from '../../idl';
+export interface IdlNameConvertor {
+    convert(node: idl.IDLNode): string;
+}
+export interface TypeConvertor<T> {
+    convertOptional(type: idl.IDLOptionalType): T;
+    convertUnion(type: idl.IDLUnionType): T;
+    convertContainer(type: idl.IDLContainerType): T;
+    convertImport(type: idl.IDLReferenceType, importClause: string): T;
+    convertTypeReference(type: idl.IDLReferenceType): T;
+    convertTypeParameter(type: idl.IDLTypeParameterType): T;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): T;
+}
+export declare function convertType<T>(convertor: TypeConvertor<T>, type: idl.IDLType): T;
+export interface DeclarationConvertor<T> {
+    convertInterface(node: idl.IDLInterface): T;
+    convertEnum(node: idl.IDLEnum): T;
+    convertTypedef(node: idl.IDLTypedef): T;
+    convertCallback(node: idl.IDLCallback): T;
+}
+export declare function convertDeclaration<T>(convertor: DeclarationConvertor<T>, decl: idl.IDLEntry): T;
+export interface NodeConvertor<T> extends TypeConvertor<T>, DeclarationConvertor<T> {
+}
+export declare function convertNode<T>(convertor: NodeConvertor<T>, node: idl.IDLNode): T;
+//# sourceMappingURL=nameConvertor.d.ts.map

package/build/lib/src/peer-generation/LanguageWriters/nameConvertor.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';
+export function convertType(convertor, type) {
+    if (idl.isOptionalType(type))
+        return convertor.convertOptional(type);
+    if (idl.isUnionType(type))
+        return convertor.convertUnion(type);
+    if (idl.isContainerType(type))
+        return convertor.convertContainer(type);
+    if (idl.isReferenceType(type)) {
+        const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
+        return importAttr
+            ? convertor.convertImport(type, importAttr)
+            : convertor.convertTypeReference(type);
+    }
+    if (idl.isTypeParameterType(type))
+        return convertor.convertTypeParameter(type);
+    if (idl.isPrimitiveType(type))
+        return convertor.convertPrimitiveType(type);
+    throw new Error(`Unknown type ${idl.IDLKind[type.kind]}`);
+}
+export function convertDeclaration(convertor, decl) {
+    if (idl.isInterface(decl))
+        return convertor.convertInterface(decl);
+    if (idl.isEnum(decl))
+        return convertor.convertEnum(decl);
+    if (idl.isEnumMember(decl))
+        return convertor.convertEnum(decl.parent);
+    if (idl.isTypedef(decl))
+        return convertor.convertTypedef(decl);
+    if (idl.isCallback(decl))
+        return convertor.convertCallback(decl);
+    throw new Error(`Unknown declaration type ${decl.kind ? idl.IDLKind[decl.kind] : "(undefined kind)"}`);
+}
+export function convertNode(convertor, node) {
+    if (idl.isEntry(node))
+        return convertDeclaration(convertor, node);
+    if (idl.isType(node))
+        return convertType(convertor, node);
+    throw new Error(`Unknown node type ${idl.IDLKind[node.kind]}`);
+}
+//# sourceMappingURL=nameConvertor.js.map

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

@@ -0,0 +1,15 @@
+import { IDLNode } from "../idl";
+export declare enum LayoutNodeRole {
+    PEER = 0,
+    INTERFACE = 1
+}
+export interface LayoutManagerStrategy {
+    resolve(node: IDLNode, role: LayoutNodeRole): string;
+}
+export declare class LayoutManager {
+    private strategy;
+    constructor(strategy: LayoutManagerStrategy);
+    resolve(node: IDLNode, role: LayoutNodeRole): string;
+    static Empty(): LayoutManager;
+}
+//# sourceMappingURL=LayoutManager.d.ts.map

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

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+export var LayoutNodeRole;
+(function (LayoutNodeRole) {
+    LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
+    LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
+})(LayoutNodeRole || (LayoutNodeRole = {}));
+export class LayoutManager {
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    resolve(node, role) {
+        return this.strategy.resolve(node, role);
+    }
+    ////////////////////////////////////////////////////////////////////
+    static Empty() {
+        return new LayoutManager({ resolve: () => '' });
+    }
+}
+//# sourceMappingURL=LayoutManager.js.map

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

@@ -0,0 +1,60 @@
+import * as idl from '../idl';
+import { ArgConvertor } from '../LanguageWriters/ArgConvertors';
+import { Field, Method } from '../LanguageWriters/LanguageWriter';
+import { PeerClassBase } from './PeerClass';
+import { PeerMethod } from './PeerMethod';
+import { ReferenceResolver } from './ReferenceResolver';
+export declare function isMaterialized(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
+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,178 @@
+/*
+ * 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 { copyMethod, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
+import { capitalize } from '../util';
+import { isBuilderClass } from './BuilderClass';
+import { qualifiedName } from './idl/common';
+import { PeerMethod } from './PeerMethod';
+export function isMaterialized(declaration, resolver) {
+    if (idl.isHandwritten(declaration) ||
+        isBuilderClass(declaration) ||
+        declaration.subkind === idl.IDLInterfaceSubkind.AnonymousInterface ||
+        declaration.subkind === idl.IDLInterfaceSubkind.Tuple) {
+        return false;
+    }
+    for (const ignore of generatorConfiguration().paramArray("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)
+        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;
+}
+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/PeerLibrary.d.ts

@@ -0,0 +1,53 @@
+import * as idl from '../idl';
+import { Language } from '../Language';
+import { IdlNameConvertor } from '../LanguageWriters';
+import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
+import { LibraryInterface } from '../LibraryInterface';
+import { BuilderClass } from './BuilderClass';
+import { MaterializedClass } from './Materialized';
+import { PeerFile } from './PeerFile';
+import { LayoutManager, LayoutManagerStrategy } from './LayoutManager';
+export declare class PeerLibrary implements LibraryInterface {
+    language: Language;
+    layout: LayoutManager;
+    private _syntheticEntries;
+    /** @deprecated PeerLibrary should contain only SDK entries */
+    get syntheticEntries(): idl.IDLEntry[];
+    initSyntheticEntries(entries: idl.IDLEntry[]): void;
+    readonly files: PeerFile[];
+    readonly builderClasses: Map<string, BuilderClass>;
+    get buildersToGenerate(): BuilderClass[];
+    readonly materializedClasses: Map<string, MaterializedClass>;
+    get materializedToGenerate(): MaterializedClass[];
+    readonly predefinedDeclarations: idl.IDLInterface[];
+    readonly globalScopeInterfaces: idl.IDLInterface[];
+    constructor(language: Language);
+    name: string;
+    readonly customComponentMethods: string[];
+    createTypeNameConvertor(language: Language): IdlNameConvertor;
+    protected readonly targetNameConvertorInstance: IdlNameConvertor;
+    private readonly interopNameConvertorInstance;
+    get libraryPrefix(): string;
+    createContinuationParameters(continuationType: idl.IDLType): idl.IDLParameter[];
+    createContinuationCallbackReference(continuationType: idl.IDLType): idl.IDLReferenceType;
+    private context;
+    getCurrentContext(): string | undefined;
+    setCurrentContext(context: string | undefined): void;
+    findFileByOriginalFilename(filename: string): PeerFile | undefined;
+    mapType(type: idl.IDLType): string;
+    resolveTypeReference(type: idl.IDLReferenceType, pointOfView?: idl.IDLEntry, rootEntries?: idl.IDLEntry[]): idl.IDLEntry | undefined;
+    typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
+    declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
+    private customConvertor;
+    getInteropName(node: idl.IDLNode): string;
+    toDeclaration(type: idl.IDLType | idl.IDLTypedef | idl.IDLCallback | idl.IDLEnum | idl.IDLInterface): idl.IDLEntry | idl.IDLType;
+    setFileLayout(strategy: LayoutManagerStrategy): void;
+}
+export declare const ArkInt32: idl.IDLPrimitiveType;
+export declare const ArkInt64: idl.IDLPrimitiveType;
+export declare const ArkFunction: idl.IDLPrimitiveType;
+export declare const ArkLength: idl.IDLPrimitiveType;
+export declare const ArkDate: idl.IDLPrimitiveType;
+export declare const ArkCustomObject: idl.IDLPrimitiveType;
+export declare function cleanPrefix(name: string, prefix: string): string;
+//# sourceMappingURL=PeerLibrary.d.ts.map