@idlizer/arktscgen 2.1.10-arktscgen-4 → 2.1.10-arktscgen-6

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

@@ -13,8 +13,9 @@
  * limitations under the License.
  */
 
+const { performance } = require('perf_hooks');
 import * as process from 'process';
-import { global as localGlobal} from '../static/global';
+import { global as localGlobal } from '../static/global';
 
 const BYTES_PER_KIBIBYTE = 1024;
 
@@ -30,11 +31,11 @@ interface MemoryContext {
 }
 
 interface Event {
-    name: string,
-    startTime: number,
-    endTime?: number,
-    parentEvent?: string,
-    duration?: number
+    name: string;
+    startTime: number;
+    endTime?: number;
+    parentEvent?: string;
+    duration?: number;
 }
 
 function formatTime(ms: number): string {
@@ -42,7 +43,7 @@ function formatTime(ms: number): string {
     const seconds = Math.floor((ms / 1000) % 60);
     const minutes = Math.floor((ms / (1000 * 60)) % 60);
     const hours = Math.floor(ms / (1000 * 60 * 60));
-  
+
     return `${pad(hours, 2)}:${pad(minutes, 2)}:${pad(seconds, 2)}:${pad(milliseconds, 3)}`;
 }
 
@@ -136,7 +137,7 @@ export class Performance {
             return { name: '', startTime: 0 };
         }
         if (this.scopes.length === 0) {
-            throw new Error("No last event");
+            throw new Error('No last event');
         }
         const name: string = this.scopes.pop()!;
         if (!this.events.has(name)) {
@@ -167,7 +168,7 @@ export class Performance {
         if (this.shouldSkip) {
             return;
         }
-        for (let i = 0; i < this.scopes.length; i ++) {
+        for (let i = 0; i < this.scopes.length; i++) {
             this.stopLastEvent(shouldLog);
         }
         this.events = new Map();
@@ -189,8 +190,8 @@ export class Performance {
         function buildVisualization(parentKey: string | null, indentLevel: number): [string, number] {
             const children = that.historyEvents.get(parentKey) || [];
             let result = '';
-    
-            children.forEach(child => {
+
+            children.forEach((child) => {
                 const indent = '  '.repeat(indentLevel);
                 const duration = child.duration ?? 0;
                 const [_result, count] = buildVisualization(child.name, indentLevel + 1);
@@ -203,10 +204,10 @@ export class Performance {
 
         const [finalResult, _] = buildVisualization(null, 0);
         if (shouldLog) {
-          console.log(`[PERFORMANCE] ===== FINAL RESULT ====`);
-          console.log(`TOTAL: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`);
-          console.log(finalResult.trimEnd());
-          console.log(`[PERFORMANCE] ===== FINAL RESULT ====`);
+            console.log(`[PERFORMANCE] ===== FINAL RESULT ====`);
+            console.log(`TOTAL: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`);
+            console.log(finalResult.trimEnd());
+            console.log(`[PERFORMANCE] ===== FINAL RESULT ====`);
         }
     }
 
@@ -226,8 +227,8 @@ export class Performance {
                 heapTotal: startMemory.heapTotal / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE),
                 heapUsed: startMemory.heapUsed / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE),
                 external: startMemory.external / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE),
-                arrayBuffers: (startMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
-            }
+                arrayBuffers: (startMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE),
+            },
         });
 
         return;
@@ -259,7 +260,9 @@ export class Performance {
             heapTotal: endMemory.heapTotal / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE) - context.startMemory.heapTotal,
             heapUsed: endMemory.heapUsed / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE) - context.startMemory.heapUsed,
             external: endMemory.external / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE) - context.startMemory.external,
-            arrayBuffers: ((endMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)) - context.startMemory.arrayBuffers
+            arrayBuffers:
+                (endMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE) -
+                context.startMemory.arrayBuffers,
         };
         const duration = endTime - context.startTime;
 
@@ -268,12 +271,26 @@ export class Performance {
         console.log('---------------------------------------------------------------');
         console.log('[PERFORMANCE]', `内存类型       | 开始值(MB) | 结束值(MB) | 增量(MB)`);
         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)}`);
-        console.log('[PERFORMANCE]', `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)}`);
-        console.log('[PERFORMANCE]', `External       | ${context.startMemory.external.toFixed(2)}    | ${(endMemory.external / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.external.toFixed(2)}`);
-        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)}`);
+        console.log(
+            '[PERFORMANCE]',
+            `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)}`
+        );
+        console.log(
+            '[PERFORMANCE]',
+            `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)}`
+        );
+        if (!!endMemory.arrayBuffers) {
+            console.log(
+                `Array Buffers  | ${context.startMemory.arrayBuffers.toFixed(2)}    | ${((endMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.arrayBuffers.toFixed(2)}`
+            );
         }
         console.log('---------------------------------------------------------------');
         this.memoryContexts.delete(label);

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

@@ -13,130 +13,137 @@
  * limitations under the License.
  */
 
-import { global } from "../static/global"
-import { isNumber, throwError } from "../../utils"
+import { global } from '../static/global';
+import { isNumber, throwError } from '../../utils';
+import { KInt, KNativePointer as KPtr, KNativePointer, nullptr, withString, withStringArray } from '@koalaui/interop';
+import { NativePtrDecoder } from './nativePtrDecoder';
 import {
-    KInt,
-    KNativePointer as KPtr,
-    KNativePointer,
-    nullptr,
-    withString,
-    withStringArray
-} from "@koalaui/interop"
-import { NativePtrDecoder } from "./nativePtrDecoder"
-import { Es2pandaAstNodeType, Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums"
-import { nodeFrom } from "../class-by-peer"
-import { AstNode } from "../peers/AstNode"
-import { ArktsObject } from "../peers/ArktsObject"
-
-export const arrayOfNullptr = new BigUint64Array([nullptr])
-
-export const allFlags =
-    Object.values(Es2pandaModifierFlags)
-        .filter(isNumber)
-        .reduce(
-            (prev, next) => prev | next,
-            0
-        )
+    Es2pandaAstNodeType,
+    Es2pandaModifierFlags,
+    Es2pandaScriptFunctionFlags,
+} from '../../../generated/Es2pandaEnums';
+import { nodeFrom } from '../class-by-peer';
+import { AstNode } from '../peers/AstNode';
+import { ArktsObject } from '../peers/ArktsObject';
+
+export const arrayOfNullptr = new BigUint64Array([nullptr]);
+
+export const allFlags = Object.values(Es2pandaModifierFlags)
+    .filter(isNumber)
+    .reduce((prev, next) => prev | next, 0);
 
 export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void {
     if (peer === nullptr) {
-        throwError(`invalid peer`)
+        throwError(`invalid peer`);
     }
 
     if (global.validatePeerTypes) {
-        const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer)
-        if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION) {
+        const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer);
+        if (
+            peerType === Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION &&
+            expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION
+        ) {
             // Improve: Struct is a child class of Class
-            return
+            return;
         }
-        if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION) {
+        if (
+            peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION &&
+            expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION
+        ) {
             // Improve: ETSImportDeclaration is a child of a ImportDeclaration
-            return
+            return;
         }
-        if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) {
+        if (
+            peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE &&
+            expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT
+        ) {
             // Improve: ETSModule is a child of a BlockStatement
-            return
+            return;
         }
         if (peerType !== expectedKind) {
-            throwError(`expected: ${Es2pandaAstNodeType[expectedKind]}, got: ${Es2pandaAstNodeType[peerType]}`)
+            throwError(`expected: ${Es2pandaAstNodeType[expectedKind]}, got: ${Es2pandaAstNodeType[peerType]}`);
         }
     }
 }
 
-export function acceptNativeObjectArrayResult<T extends ArktsObject>(arrayObject: KNativePointer, factory: (instance: KNativePointer) => T): T[] {
-    return new NativePtrDecoder().decode(arrayObject).map(factory);
+export function acceptNativeObjectArrayResult<T extends ArktsObject>(
+    arrayObject: KNativePointer,
+    factory: (instance: KNativePointer) => T
+): T[] {
+    // OptimizedNativePtrDecoder:return decoded.reduce((prev, curr)=>{prev.push(factory(curr));return prev},[] as T[])
+    const decoded = new NativePtrDecoder().decode(arrayObject)
+    return decoded.map(factory);
 }
 
 export function unpackNonNullableNode<T extends AstNode>(peer: KNativePointer, typeHint?: Es2pandaAstNodeType): T {
     if (peer === nullptr) {
-        throwError('peer is NULLPTR (maybe you should use unpackNode)')
+        throwError('peer is NULLPTR (maybe you should use unpackNode)');
     }
-    return nodeFrom(peer, typeHint)
+    return nodeFrom(peer, typeHint);
 }
 
 export function unpackNode<T extends AstNode>(peer: KNativePointer, typeHint?: Es2pandaAstNodeType): T | undefined {
     if (peer === nullptr) {
-        return undefined
+        return undefined;
     }
-    return nodeFrom<T>(peer, typeHint)
+    return nodeFrom<T>(peer, typeHint);
 }
 
 export function passNode(node: ArktsObject | undefined): KNativePointer {
-    return node?.peer ?? nullptr
+    return node?.peer ?? nullptr;
 }
 
 export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer, typeHint?: Es2pandaAstNodeType): T[] {
     if (nodesPtr === nullptr) {
-        return []
+        return [];
     }
-    return new NativePtrDecoder()
-        .decode(nodesPtr)
-        .map((peer: KNativePointer) => unpackNonNullableNode(peer, typeHint))
+    // For OptimizedNativePtrDecoder
+    //const decoded = new NativePtrDecoder().decode(nodesPtr)
+    //return decoded.reduce((prev, curr) => {
+    //    prev.push(unpackNonNullableNode(curr, typeHint))
+    //    return prev
+    //}, [] as T[])
+    return new NativePtrDecoder().decode(nodesPtr).map((peer: KNativePointer) => unpackNonNullableNode(peer, typeHint));
 }
 
 export function passNodeArray(nodes: readonly ArktsObject[] | undefined): BigUint64Array {
-    return new BigUint64Array(
-        nodes
-            ?.filter(it => it.peer != undefined)
-            ?.map(node => BigInt(node.peer))
-        ?? []
-    )
+    return new BigUint64Array(nodes?.filter((it) => (!!it.peer))?.map((node) => BigInt(node.peer)) ?? []);
 }
 
 export function unpackString(peer: KNativePointer): string {
-    return global.interop._RawUtf8ToString(peer)
+    return global.interop._RawUtf8ToString(peer);
 }
 
 // Improve: use direct string arguments instead.
 export function passString(str: string | undefined): string {
-    return str ?? ""
+    return str ?? '';
 }
 
 // Improve: use direct string arguments instead.
 export function passStringArray(strings: readonly string[]): string[] {
-    return withStringArray(strings, (it: string[]) => it)
+    return withStringArray(strings, (it: string[]) => it);
 }
 
 export function passNodeWithNewModifiers<T extends AstNode>(node: T, modifiers: KInt): T {
-    return unpackNonNullableNode<T>(node.peer).updateModifiers(modifiers)
+    return unpackNonNullableNode<T>(node.peer).updateModifiers(modifiers);
 }
 
 export function scriptFunctionHasBody(peer: KNativePointer): boolean {
-    const flags = global.generatedEs2panda._ScriptFunctionFlagsConst(global.context, peer)
-    return (flags & Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_EXTERNAL) === 0
-        && (flags & Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_EXTERNAL_OVERLOAD) === 0
+    const flags = global.generatedEs2panda._ScriptFunctionFlagsConst(global.context, peer);
+    return (
+        (flags & Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_EXTERNAL) === 0 &&
+        (flags & Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_EXTERNAL_OVERLOAD) === 0
+    );
 }
 
 export function updateNodeByNode<T extends ArktsObject>(node: T, original: T): T {
     if (original.peer === nullptr) {
-        throwError('update called on NULLPTR')
+        throwError('update called on NULLPTR');
     }
-    node.onUpdate(original)
-    return node
+    node.onUpdate(original);
+    return node;
 }
 
 export function nodeType(node: AstNode): Es2pandaAstNodeType {
-    return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node))
+    return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node));
 }
-