@idlizer/arktscgen 2.1.10-arktscgen-3a → 2.1.10-arktscgen-5

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

@@ -1,69 +1,86 @@
-/*
- * Copyright (c) 2022-2023 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 { int32 } from "@koalaui/common"
-import {
-    Access,
-    ArrayDecoder,
-    CallbackRegistry,
-    NativeStringBase,
-    nullptr,
-    pointer,
-    providePlatformDefinedData,
-    withByteArray
-} from "@koalaui/interop"
-import { global } from "../static/global"
-
-class NativeString extends NativeStringBase {
-    constructor(ptr: pointer) {
-        super(ptr)
-    }
-    protected bytesLength(): int32 {
-        return global.interop._StringLength(this.ptr)
-    }
-    protected getData(data: Uint8Array): void {
-        withByteArray(data, Access.WRITE, (dataPtr: pointer) => {
-            global.interop._StringData(this.ptr, dataPtr, data.length)
-        })
-    }
-    close(): void {
-        global.interop._InvokeFinalizer(this.ptr, global.interop._GetStringFinalizer())
-        this.ptr = nullptr
-    }
-}
-
-providePlatformDefinedData({
-    nativeString(ptr: pointer): NativeStringBase {
-        return new NativeString(ptr)
-    },
-    nativeStringArrayDecoder(): ArrayDecoder<NativeStringBase> {
-        throw new Error("Not yet implemented")
-    },
-    callbackRegistry(): CallbackRegistry | undefined {
-        return undefined
-    }
-})
-
-export class NativePtrDecoder extends ArrayDecoder<pointer> {
-    getArraySize(blob: pointer) {
-        return global.interop._GetPtrVectorSize(blob)
-    }
-    disposeArray(blob: pointer): void {
-        // Improve:
-    }
-    getArrayElement(blob: pointer, index: int32): pointer {
-        return global.interop._GetPtrVectorElement(blob, index)
-    }
-}
+/*
+ * Copyright (c) 2022-2023 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 { int32 } from '@koalaui/common';
+import {
+    Access,
+    ArrayDecoder,
+    CallbackRegistry,
+    NativeStringBase,
+    nullptr,
+    pointer,
+    providePlatformDefinedData,
+    withByteArray,
+} from '@koalaui/interop';
+import { global } from '../static/global';
+
+class NativeString extends NativeStringBase {
+    constructor(ptr: pointer) {
+        super(ptr);
+    }
+    protected bytesLength(): int32 {
+        return global.interop._StringLength(this.ptr);
+    }
+    protected getData(data: Uint8Array): void {
+        withByteArray(data, Access.WRITE, (dataPtr: pointer) => {
+            global.interop._StringData(this.ptr, dataPtr, data.length);
+        });
+    }
+    close(): void {
+        global.interop._InvokeFinalizer(this.ptr, global.interop._GetStringFinalizer());
+        this.ptr = nullptr;
+    }
+}
+
+providePlatformDefinedData({
+    nativeString(ptr: pointer): NativeStringBase {
+        return new NativeString(ptr);
+    },
+    nativeStringArrayDecoder(): ArrayDecoder<NativeStringBase> {
+        throw new Error('Not yet implemented');
+    },
+    callbackRegistry(): CallbackRegistry | undefined {
+        return undefined;
+    },
+});
+
+export class NativePtrDecoder extends ArrayDecoder<pointer> {
+    getArraySize(blob: pointer) {
+        return global.interop._GetPtrVectorSize(blob);
+    }
+    disposeArray(blob: pointer): void {
+        // Improve:
+    }
+    getArrayElement(blob: pointer, index: int32): pointer {
+        return global.interop._GetPtrVectorElement(blob, index);
+    }
+}
+
+// This decoder uses a napi's external buffer and
+// it is not efficient for small arraya(guessing, less than 10)
+export class OptimizedNativePtrDecoder {
+    disposeArray(blob: pointer): void {
+        // Improve:
+    }
+    decode(blob: pointer): BigUint64Array {
+        return global.interop._GetPtrVector(blob);
+    }
+    decodeAndCopy(blob: pointer): Array<pointer> {
+        const data = global.interop._GetPtrVector(blob);
+        const result = Array.from(data);
+        this.disposeArray(blob);
+        return result;
+    }
+}

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

@@ -14,7 +14,7 @@
  */
 
 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 +30,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 +42,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 +136,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 +167,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 +189,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 +203,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 +226,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 +259,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 +270,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)}`);
+        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(
+                `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,142 @@
  * 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 { OptimizedNativePtrDecoder as 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[] {
+export function acceptNativeObjectArrayResult<T extends ArktsObject>(
+    arrayObject: KNativePointer,
+    factory: (instance: KNativePointer) => T
+): T[] {
+    // For OptimizedNativePtrDecoder
+    //const decoded = new NativePtrDecoder().decode(arrayObject)
+    //return decoded.reduce((prev, curr) => {
+    //    prev.push(factory(curr))
+    //    return prev
+    //}, [] as T[])
     return new NativePtrDecoder().decode(arrayObject).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 != undefined)?.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));
 }
-