@idlizer/arktscgen 2.1.10-arktscgen-7 → 2.1.10-arktscgen-10

package/build/libarkts-copy/src/Es2pandaNativeModule.ts

@@ -37,9 +37,6 @@ import { Es2pandaPluginDiagnosticType } from '../generated/Es2pandaEnums';
 export type KPtrArray = BigUint64Array;
 
 export class Es2pandaNativeModule {
-    _AnnotationAllowedAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr {
-        throw new Error('Not implemented');
-    }
     _AstNodeRebind(context: KPtr, node: KPtr): void {
         throw new Error('Not implemented');
     }
@@ -64,9 +61,6 @@ export class Es2pandaNativeModule {
     _HasGlobalStructInfo(context: KNativePointer, str: String): KBoolean {
         throw new Error('Not implemented');
     }
-    _DestroyContext(context: KPtr): void {
-        throw new Error('Not implemented');
-    }
     _ProceedToState(context: KPtr, state: number): void {
         throw new Error('Not implemented');
     }
@@ -91,9 +85,6 @@ export class Es2pandaNativeModule {
     _VariableDeclaration(context: KPtr, variable: KPtr): KPtr {
         throw new Error('Not implemented');
     }
-    _DeclNode(context: KPtr, decl: KPtr): KPtr {
-        throw new Error('Not implemented');
-    }
     _ProgramSourceFilePath(context: KNativePointer, instance: KNativePointer): KNativePointer {
         throw new Error('Not implemented');
     }
@@ -141,54 +132,11 @@ export class Es2pandaNativeModule {
     _OptionsArkTsConfig(context: KNativePointer, options: KNativePointer): KNativePointer {
         throw new Error('Not implemented');
     }
-    _Checker_CreateOpaqueTypeNode(context: KNativePointer, type: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_ScriptFunctionSignature(context: KNativePointer, node: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_ScriptFunctionSetSignature(
-        context: KNativePointer,
-        node: KNativePointer,
-        signature: KNativePointer
-    ): void {
-        throw new Error('Not implemented');
-    }
-    _Checker_SignatureReturnType(context: KNativePointer, signature: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_ScriptFunctionGetPreferredReturnType(context: KNativePointer, node: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_ScriptFunctionSetPreferredReturnType(
+    _JumpFromETSTypeReferenceToTSTypeAliasDeclarationTypeAnnotation(
         context: KNativePointer,
-        node: KNativePointer,
-        type: KNativePointer
-    ): void {
-        throw new Error('Not implemented');
-    }
-    _Checker_ExpressionGetPreferredType(context: KNativePointer, node: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_ExpressionSetPreferredType(context: KNativePointer, node: KNativePointer, type: KNativePointer): void {
-        throw new Error('Not implemented');
-    }
-    _Checker_TypeToString(context: KNativePointer, type: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_TypeClone(context: KNativePointer, type: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_TypeNodeGetType(context: KNativePointer, node: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _ScriptFunctionSetParams(
-        context: KNativePointer,
-        receiver: KNativePointer,
-        paramsList: BigUint64Array,
-        paramsListLength: KUInt
-    ): void {
-        throw new Error('Not implemented');
+        etsTypeReference: KNativePointer,
+    ): KNativePointer {
+        throw new Error('Not implemented')
     }
     _ClassDefinitionSetBody(
         context: KNativePointer,
@@ -212,6 +160,15 @@ export class Es2pandaNativeModule {
     _ClassVariableDeclaration(context: KNativePointer, classInstance: KNativePointer): KNativePointer {
         throw new Error('Not implemented');
     }
+    _DeclarationFromProperty(context: KPtr, property: KPtr): KPtr {
+        throw new Error('Not implemented');
+    }
+    _DeclarationFromMemberExpression(context: KPtr, expression: KPtr): KPtr {
+        throw new Error('Not implemented');
+    }
+    _DeclarationFromAstNode(context: KPtr, node: KPtr): KPtr {
+        throw new Error('Not implemented');
+    }
     _ETSParserGetGlobalProgramAbsName(context: KNativePointer): KNativePointer {
         throw new Error('Not implemented');
     }
@@ -234,16 +191,22 @@ export class Es2pandaNativeModule {
     _SetUpSoPath(soPath: string): void {
         throw new Error('Not implemented');
     }
-    _MemInitialize(): void {
+    _ProgramCanSkipPhases(context: KNativePointer, program: KNativePointer): KBoolean {
         throw new Error('Not implemented');
     }
-    _MemFinalize(): void {
+    _AstNodeProgram(context: KNativePointer, instance: KNativePointer): KNativePointer {
         throw new Error('Not implemented');
     }
-    _ProgramCanSkipPhases(context: KNativePointer, program: KNativePointer): KBoolean {
+
+    _AstNodeFindNodeInInnerChild(context: KNativePointer, node: KNativePointer, target: KNativePointer): boolean {
         throw new Error('Not implemented');
     }
-    _AstNodeProgram(context: KNativePointer, instance: KNativePointer): KNativePointer {
+
+    _AstNodeFindInnerChild(context: KNativePointer, node: KNativePointer, nodeType: KInt): KNativePointer {
+        throw new Error('Not implemented');
+    }
+
+    _AstNodeFindOuterParent(context: KNativePointer, node: KNativePointer, nodeType: KInt): KNativePointer {
         throw new Error('Not implemented');
     }
 
@@ -269,7 +232,11 @@ export class Es2pandaNativeModule {
 }
 
 export function findNativeModule(): string {
-    const candidates = [path.resolve(__dirname, '../native/build'), path.resolve(__dirname, '../build/native/build')];
+    const candidates = [
+        path.resolve(__dirname, '../native/build'),
+        path.resolve(__dirname, '../build/native'),
+        path.resolve(__dirname, '../build/native/build')
+    ];
     let result = undefined;
     candidates.forEach((path) => {
         if (fs.existsSync(path)) {

package/build/libarkts-copy/src/arkts-api/index.ts

@@ -29,7 +29,6 @@ export * from './ProgramProvider';
 export * from './peers/AstNode';
 export * from './peers/Config';
 export * from './peers/Context';
-export { GlobalContext } from './peers/Context';
 export * from './peers/ExternalSource';
 export * from './peers/Options';
 export * from './node-utilities/ArkTsConfig';

package/build/libarkts-copy/src/arkts-api/node-utilities/OpaqueTypeNode.ts

@@ -20,7 +20,7 @@ import { Es2pandaAstNodeType } from '../../../generated/Es2pandaEnums';
 
 export function createOpaqueTypeNode(typePointer: KNativePointer): OpaqueTypeNode {
     return new OpaqueTypeNode(
-        global.es2panda._Checker_CreateOpaqueTypeNode(global.context, typePointer),
+        global.generatedEs2panda._CreateOpaqueTypeNode(global.context, typePointer),
         Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE
     );
 }

package/build/libarkts-copy/src/arkts-api/peers/AstNode.ts

@@ -105,6 +105,20 @@ export abstract class AstNode extends ArktsObject {
         return clonedNode as this;
     }
 
+    public findNodeInInnerChild(node: AstNode): boolean {
+        return global.es2panda._AstNodeFindNodeInInnerChild(global.context, this.peer, node.peer);
+    }
+
+    public findInnerChild<T extends AstNode>(nodeType: Es2pandaAstNodeType): T | undefined {
+        const childNodePeer = global.es2panda._AstNodeFindInnerChild(global.context, this.peer, nodeType);
+        return unpackNode(childNodePeer, nodeType);
+    }
+
+    public findOuterParent<T extends AstNode>(nodeType: Es2pandaAstNodeType): T | undefined {
+        const parentNodePeer = global.es2panda._AstNodeFindOuterParent(global.context, this.peer, nodeType);
+        return unpackNode(parentNodePeer, nodeType);
+    }
+
     public get parent(): AstNode | undefined {
         const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer);
         return unpackNode(parent);

package/build/libarkts-copy/src/arkts-api/peers/Context.ts

@@ -14,110 +14,77 @@
  */
 
 import { ArktsObject } from './ArktsObject';
-import { Program } from '../../../generated';
+import { compiler, Program } from '../../../generated';
 import { global } from '../static/global';
-import { passString, passStringArray } from '../utilities/private';
 import { KNativePointer, nullptr, KBoolean } from '@koalaui/interop';
 import { Config } from './Config';
-import { filterSource, throwError } from '../../utils';
+import { filterSource } from '../../utils';
 import { AstNode } from './AstNode';
 
+// Perhaps, this file would become generated some time later
+// Please, do not add hard logic here
+
 export class Context extends ArktsObject {
     constructor(peer: KNativePointer) {
         super(peer);
     }
 
     static createFromString(source: string): Context {
-        if (!global.configIsInitialized()) {
-            throw new Error(`Config not initialized`);
-        }
-        return new Context(
-            global.generatedEs2panda._CreateContextFromString(global.config, passString(source), passString(global.filePath))
-        );
+        return compiler.createContextFromString(global.configObj, source, global.filePath);
     }
 
-    /** @deprecated Use {@link createCacheFromFile} instead */
     static createCacheContextFromFile(
         configPtr: KNativePointer,
         fileName: string,
         globalContextPtr: KNativePointer,
         isExternal: KBoolean
     ): Context {
-        return new Context(
-            global.generatedEs2panda._CreateCacheContextFromFile(configPtr, passString(fileName), globalContextPtr, isExternal)
-        );
+        return compiler.createCacheContextFromFile(new Config(configPtr), fileName, new GlobalContext(globalContextPtr), isExternal);
     }
 
     static createFromFile(filePath: string): Context {
-        return new Context(global.generatedEs2panda._CreateContextFromFile(global.config, passString(filePath)));
+        return compiler.createContextFromFile(global.configObj, filePath);
     }
 
-    static createCacheFromFile(filePath: string, config: Config, globalContext: GlobalContext, isExternal: boolean) {
-        return new Context(
-            global.generatedEs2panda._CreateCacheContextFromFile(
-                config.peer,
-                passString(filePath),
-                globalContext.peer,
-                isExternal
-            )
-        );
+    static createCacheFromFile(filePath: string, config: Config, globalContext: GlobalContext, isExternal: boolean): Context {
+        return compiler.createCacheContextFromFile(config, filePath, globalContext, isExternal);
     }
 
     static createContextGenerateAbcForExternalSourceFiles(filenames: string[]): Context {
-        if (!global.configIsInitialized()) {
-            throwError(`Config not initialized`);
-        }
-        return new Context(
-            global.generatedEs2panda._CreateContextGenerateAbcForExternalSourceFiles(
-                global.config,
-                filenames.length,
-                passStringArray(filenames)
-            )
-        );
+        return compiler.createContextGenerateAbcForExternalSourceFiles(global.configObj, filenames);
     }
 
-    destroy() {
-        if (this.peer !== nullptr) {
-            global.es2panda._DestroyContext(this.peer);
-            this.peer = nullptr;
-        }
+    static createFromStringWithHistory(source: string): Context {
+        return compiler.createContextFromStringWithHistory(global.configObj, source, global.filePath);
+    }
+
+    destroy(): void {
+        compiler.destroyContext();
     }
 
     /** @deprecated */
     static destroyAndRecreate(ast: AstNode): Context {
         console.log('[TS WRAPPER] DESTROY AND RECREATE');
         const source = filterSource(ast.dumpSrc());
-        global.es2panda._DestroyContext(global.context);
-        global.compilerContext = Context.createFromString(source) as any; // Improve: commonize Context
-
-        return new Context(global.context);
+        compiler.destroyContext();
+        return global.compilerContext = Context.createFromString(source);
     }
 
     get program(): Program {
-        return new Program(global.generatedEs2panda._ContextProgram(this.peer));
+        return compiler.contextProgram();
     }
 }
 
 export class GlobalContext extends ArktsObject {
-    static create(config: Config, externalFileList: string[]): GlobalContext {
-        return new GlobalContext(
-            global.generatedEs2panda._CreateGlobalContext(
-                config.peer,
-                passStringArray(externalFileList),
-                externalFileList.length,
-                false
-            )
-        );
-    }
-
     constructor(peer: KNativePointer) {
         super(peer);
     }
 
+    static create(config: Config, externalFileList: string[]): GlobalContext {
+        return compiler.createGlobalContext(config, externalFileList, false);
+    }
+
     destroy() {
-        if (this.peer !== nullptr) {
-            global.generatedEs2panda._DestroyGlobalContext(this.peer);
-            this.peer = nullptr;
-        }
+        compiler.destroyGlobalContext();
     }
 }

package/build/libarkts-copy/src/arkts-api/peers/ExternalSource.ts

@@ -13,11 +13,13 @@
  * limitations under the License.
  */
 
-import { global } from '../static/global';
-import { acceptNativeObjectArrayResult, unpackString } from '../utilities/private';
-import { KNativePointer, nullptr } from '@koalaui/interop';
+import { KNativePointer } from '@koalaui/interop';
 import { Program } from '../../../generated';
 import { ArktsObject } from './ArktsObject';
+import { compiler } from '../../../generated';
+
+// Perhaps, this file would become generated some time later
+// Please, do not add hard logic here
 
 export class ExternalSource extends ArktsObject {
     constructor(peer: KNativePointer) {
@@ -25,17 +27,10 @@ export class ExternalSource extends ArktsObject {
     }
 
     getName(): string {
-        return unpackString(global.es2panda._ExternalSourceName(this.peer));
-    }
-
-    get programs(): Program[] {
-        return acceptNativeObjectArrayResult<Program>(
-            global.es2panda._ExternalSourcePrograms(this.peer),
-            (instance: KNativePointer) => new Program(instance)
-        );
+        return compiler.externalSourceName(this);
     }
 
-    static instantiate(peer: KNativePointer) {
-        return new ExternalSource(peer);
+    get programs(): readonly Program[] {
+        return compiler.externalSourcePrograms(this);
     }
 }

package/build/libarkts-copy/src/arkts-api/plugins.ts

@@ -61,6 +61,7 @@ export interface ProjectConfig {
     frameworkMode?: string;
     isUi2abc?: boolean;
     memoPluginOptions?: Object;
+    uiPluginOptions?: Object;
 }
 
 export interface PluginContextBase {
@@ -223,10 +224,10 @@ export function defaultFilter(name: string): boolean {
     return true;
 }
 
-export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter): Program[] {
+export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter): readonly Program[] {
     return [
         program,
-        ...program.getExternalSources().flatMap((it: ExternalSource): Program[] => {
+        ...program.getExternalSources().flatMap((it: ExternalSource): readonly Program[] => {
             if (filter(it.getName())) {
                 return it.programs;
             }

package/build/libarkts-copy/src/arkts-api/static/global.ts

@@ -40,6 +40,7 @@ export class UpdateTracker {
 }
 
 export class global {
+    /** @deprecated */
     public static filePath: string = './plugins/input/main.ets';
 
     public static arktsconfig?: ArkTsConfig;
@@ -68,7 +69,6 @@ export class global {
 
     // Improve: rename to context when the pointer valued one is eliminated
     public static compilerContext: Context | undefined;
-    public static isContextGenerateAbcForExternalSourceFiles: boolean = false;
 
     private static _es2panda: Es2pandaNativeModule | undefined = undefined;
     public static get es2panda(): Es2pandaNativeModule {
@@ -79,6 +79,13 @@ export class global {
     }
 
     private static _generatedEs2panda: GeneratedEs2pandaNativeModule | undefined = undefined;
+    /**
+     * @deprecated
+     * 
+     * You should not generally use generatedEs2panda in handwritten code
+     * (only in exceptional cases).
+     * Please use generated wrapper for native call instead.
+     */
     public static get generatedEs2panda(): GeneratedEs2pandaNativeModule {
         if (this._generatedEs2panda === undefined) {
             this._generatedEs2panda = initGeneratedEs2panda();

package/build/libarkts-copy/src/arkts-api/utilities/extensions.ts

@@ -61,14 +61,14 @@ export function extension_MethodDefinitionOnUpdate(this: MethodDefinition, origi
 
 // Improve: generate checker related stuff
 export function extension_ScriptFunctionGetSignaturePointer(this: ScriptFunction): KNativePointer {
-    return global.es2panda._Checker_ScriptFunctionSignature(global.context, this.peer);
+    return global.generatedEs2panda._ScriptFunctionSignature(global.context, this.peer);
 }
 
 export function extension_ScriptFunctionSetSignaturePointer(
     this: ScriptFunction,
     signaturePointer: KNativePointer
 ): void {
-    global.es2panda._Checker_ScriptFunctionSetSignature(global.context, this.peer, signaturePointer);
+    global.generatedEs2panda._ScriptFunctionSetSignature(global.context, this.peer, signaturePointer);
 }
 
 // Improve: weird API
@@ -81,23 +81,23 @@ export function extension_ScriptFunctionGetParamsCasted(this: ScriptFunction): r
 
 // Improve: perhaps "preferredReturnType" stuff can be removed later if "signature" is always enough
 export function extension_ScriptFunctionGetPreferredReturnTypePointer(this: ScriptFunction): KNativePointer {
-    return global.es2panda._Checker_ScriptFunctionGetPreferredReturnType(global.context, this.peer);
+    return global.generatedEs2panda._ScriptFunctionGetPreferredReturnType(global.context, this.peer);
 }
 
 export function extension_ScriptFunctionSetPreferredReturnTypePointer(
     this: ScriptFunction,
     typePointer: KNativePointer
 ): void {
-    global.es2panda._Checker_ScriptFunctionSetPreferredReturnType(global.context, this.peer, typePointer);
+    global.generatedEs2panda._ScriptFunctionSetPreferredReturnType(global.context, this.peer, typePointer);
 }
 
 // Improve: generate checker related stuff
 export function extension_ExpressionGetPreferredTypePointer(this: Expression): KNativePointer {
-    return global.es2panda._Checker_ExpressionGetPreferredType(global.context, this.peer);
+    return global.generatedEs2panda._ExpressionPreferredTypeConst(global.context, this.peer);
 }
 
 export function extension_ExpressionSetPreferredTypePointer(this: Expression, typePointer: KNativePointer): void {
-    global.es2panda._Checker_ExpressionSetPreferredType(global.context, this.peer, typePointer);
+    global.generatedEs2panda._ExpressionSetPreferredType(global.context, this.peer, typePointer);
 }
 
 // Improve: weird API
@@ -108,12 +108,9 @@ export function extension_ProgramGetAstCasted(this: Program): ETSModule {
     );
 }
 
-// Improve: generate methods with string[] args or return type
-export function extension_ProgramGetExternalSources(this: Program): ExternalSource[] {
-    return acceptNativeObjectArrayResult<ExternalSource>(
-        global.es2panda._ProgramExternalSources(global.context, this.peer),
-        ExternalSource.instantiate
-    );
+/** @deprecated Now generated */
+export function extension_ProgramGetExternalSources(this: Program): readonly ExternalSource[] {
+    return this.externalSources;
 }
 
 // Improve: SourcePositionLine is global in idl

package/build/libarkts-copy/src/arkts-api/utilities/performance.ts

@@ -56,22 +56,34 @@ function round(value: number, index: number = 2): number {
     return Math.round(value * factor) / factor;
 }
 
+interface DetailedEventInfo {
+    duration: number;
+    count: number;
+}
+
 export class Performance {
     private static instance: Performance;
     private events: Map<string, Event>;
+    private detailedEvents: Map<string, Event>;
     private historyEvents = new Map<string | null, Event[]>();
     private scopes: string[];
     private shouldSkip: boolean;
+    private shouldSkipDetail: boolean;
     private totalDuration: number;
     private memoryContexts = new Map<string, MemoryContext>();
     private memoryTrackerEnable: boolean;
+    private detailedEventInfos: Map<string, DetailedEventInfo>;
+
     private constructor() {
         this.events = new Map();
+        this.detailedEvents = new Map();
         this.historyEvents = new Map();
         this.scopes = [];
         this.shouldSkip = true;
+        this.shouldSkipDetail = true;
         this.memoryTrackerEnable = false;
         this.totalDuration = 0;
+        this.detailedEventInfos = new Map<string, DetailedEventInfo>();
     }
 
     public static getInstance(): Performance {
@@ -81,8 +93,14 @@ export class Performance {
         return this.instance;
     }
 
-    skip(shouldSkip: boolean = true): void {
+    skip(shouldSkip: boolean = true): this {
         this.shouldSkip = shouldSkip;
+        return this;
+    }
+
+    skipDetail(shouldSkipDetail: boolean = true): this {
+        this.shouldSkipDetail = shouldSkipDetail;
+        return this;
     }
 
     enableMemoryTracker(enableMemoryTracker: boolean = false): void {
@@ -100,6 +118,57 @@ export class Performance {
         return newEvent;
     }
 
+    logDetailedEventInfos(shouldLog: boolean = false): void {
+        if (!shouldLog) {
+            return;
+        }
+        const sortedEvents = new Map([...this.detailedEventInfos.entries()].sort((a, b) => a[0].localeCompare(b[0])));
+        for (const [key, value] of sortedEvents) {
+            const dura = formatTime(value.duration);
+            const duraRound = round(value.duration);
+            const perDura = formatTime(value.duration / value.count);
+            const duraPerDura = round(value.duration / value.count);
+            console.log(
+                `[PERFORMANCE] name: ${key}, detailed-total-duration: ${dura}(${duraRound}), total-count: ${value.count}, time-per-conversion: ${perDura}(${duraPerDura})`
+            );
+        }
+    }
+
+    createDetailedEvent(name: string) {
+        if (this.shouldSkipDetail) {
+            return { name: '', startTime: 0 };
+        }
+        const startTime: number = performance.now();
+        const newEvent: Event = { name, startTime };
+        this.detailedEvents.set(name, newEvent);
+    }
+
+    stopDetailedEvent(name: string, shouldLog: boolean = false) {
+        if (this.shouldSkipDetail) {
+            return { name: '', startTime: 0 };
+        }
+        if (!this.detailedEvents.has(name)) {
+            throw new Error(`Event ${name} is not created.`);
+        }
+
+        const event: Event = this.detailedEvents.get(name)!;
+        const endTime: number = performance.now();
+        const duration: number = endTime - event.startTime;
+
+        let totalDetailedDuration = duration;
+        let totalDetailedCount = 1;
+        if (this.detailedEventInfos.has(name)) {
+            const lastInfo = this.detailedEventInfos.get(name)!;
+            totalDetailedDuration += lastInfo.duration;
+            totalDetailedCount += lastInfo.count;
+        }
+
+        this.detailedEventInfos.set(name, {
+            duration: totalDetailedDuration,
+            count: totalDetailedCount,
+        });
+    }
+
     stopEvent(name: string, shouldLog: boolean = false): Event {
         if (this.shouldSkip) {
             return { name: '', startTime: 0 };
@@ -122,7 +191,9 @@ export class Performance {
 
         if (shouldLog) {
             console.log(
-                `[PERFORMANCE] name: ${event.name}, parent: ${parentEvent}, duration: ${formatTime(duration)}(${round(duration)}), total: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`
+                `[PERFORMANCE] name: ${event.name}, parent: ${parentEvent}, duration: ${formatTime(duration)}(${round(
+                    duration
+                )}), total: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`
             );
         }
 
@@ -154,7 +225,9 @@ export class Performance {
 
         if (shouldLog) {
             console.log(
-                `[PERFORMANCE] name: ${event.name}, parent: ${parentEvent}, duration: ${formatTime(duration)}(${round(duration)}), total: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`
+                `[PERFORMANCE] name: ${event.name}, parent: ${parentEvent}, duration: ${formatTime(duration)}(${round(
+                    duration
+                )}), total: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`
             );
         }
 
@@ -176,6 +249,8 @@ export class Performance {
 
     clearTotalDuration(): void {
         this.totalDuration = 0;
+        this.detailedEventInfos.clear();
+        this.detailedEvents.clear();
     }
 
     clearHistory(): void {
@@ -273,23 +348,38 @@ export class Performance {
         console.log('---------------------------------------------------------------');
         console.log(
             '[PERFORMANCE]',
-            `RSS            | ${context.startMemory.rss.toFixed(2)}    | ${(endMemory.rss / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.rss.toFixed(2)}`
+            `RSS            | ${context.startMemory.rss.toFixed(2)}    | ${(
+                endMemory.rss /
+                (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+            ).toFixed(2)}    | ${memoryDiff.rss.toFixed(2)}`
         );
         console.log(
             '[PERFORMANCE]',
-            `Heap Total     | ${context.startMemory.heapTotal.toFixed(2)}    | ${(endMemory.heapTotal / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.heapTotal.toFixed(2)}`
+            `Heap Total     | ${context.startMemory.heapTotal.toFixed(2)}    | ${(
+                endMemory.heapTotal /
+                (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+            ).toFixed(2)}    | ${memoryDiff.heapTotal.toFixed(2)}`
         );
         console.log(
             '[PERFORMANCE]',
-            `Heap Used      | ${context.startMemory.heapUsed.toFixed(2)}    | ${(endMemory.heapUsed / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.heapUsed.toFixed(2)}`
+            `Heap Used      | ${context.startMemory.heapUsed.toFixed(2)}    | ${(
+                endMemory.heapUsed /
+                (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+            ).toFixed(2)}    | ${memoryDiff.heapUsed.toFixed(2)}`
         );
         console.log(
             '[PERFORMANCE]',
-            `External       | ${context.startMemory.external.toFixed(2)}    | ${(endMemory.external / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.external.toFixed(2)}`
+            `External       | ${context.startMemory.external.toFixed(2)}    | ${(
+                endMemory.external /
+                (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+            ).toFixed(2)}    | ${memoryDiff.external.toFixed(2)}`
         );
-        if (!!endMemory.arrayBuffers) {
+        if (endMemory.arrayBuffers !== undefined) {
             console.log(
-                `Array Buffers  | ${context.startMemory.arrayBuffers.toFixed(2)}    | ${((endMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.arrayBuffers.toFixed(2)}`
+                `Array Buffers  | ${context.startMemory.arrayBuffers.toFixed(2)}    | ${(
+                    (endMemory.arrayBuffers || 0) /
+                    (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+                ).toFixed(2)}    | ${memoryDiff.arrayBuffers.toFixed(2)}`
             );
         }
         console.log('---------------------------------------------------------------');

package/build/libarkts-copy/src/arkts-api/utilities/private.ts

@@ -76,6 +76,9 @@ export function unpackNativeObjectArray<T extends ArktsObject>(
     arrayObject: KNativePointer,
     factory: (instance: KNativePointer) => T
 ): T[] {
+    if (arrayObject == nullptr) {
+        return [];
+    }
     return acceptNativeObjectArrayResult(arrayObject, factory);
 }