@idlizer/arktscgen 2.1.7 → 2.1.9-arktscgen-4

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2022-2025 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 {
+        // TODO
+    }
+    getArrayElement(blob: pointer, index: int32): pointer {
+        return global.interop._GetPtrVectorElement(blob, index)
+    }
+}

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

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2022-2025 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.
+ */
+
+interface Event {
+    name: string,
+    startTime: number,
+    endTime?: number,
+    parentEvent?: string,
+    duration?: number
+}
+
+function formatTime(ms: number): string {
+    const milliseconds = Math.floor(ms % 1000);
+    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)}`;
+}
+
+function pad(value: number, length: number): string {
+    return value.toString().padStart(length, '0');
+}
+
+function round(value: number, index: number = 2): number {
+    const factor = Math.pow(10, index);
+    return Math.round(value * factor) / factor;
+}
+
+export class Performance {
+    private static instance: Performance;
+    private events: Map<string, Event>;
+    private historyEvents = new Map<string | null, Event[]>();
+    private scopes: string[];
+    private shouldSkip: boolean;
+    private totalDuration: number;
+
+    private constructor() {
+        this.events = new Map();
+        this.historyEvents = new Map();
+        this.scopes = [];
+        this.shouldSkip = true;
+        this.totalDuration = 0;
+    }
+
+    public static getInstance(): Performance {
+        if (!this.instance) {
+            this.instance = new Performance();
+        }
+        return this.instance;
+    }
+
+    skip(shouldSkip: boolean = true): void {
+        this.shouldSkip = shouldSkip;
+    }
+
+    createEvent(name: string): Event {
+        if (this.shouldSkip) {
+            return { name: '', startTime: 0 };
+        }
+        const startTime: number = performance.now();
+        const newEvent: Event = { name, startTime };
+        this.events.set(name, newEvent);
+        this.scopes.push(name);
+        return newEvent;
+    }
+
+    stopEvent(name: string, shouldLog: boolean = false): Event {
+        if (this.shouldSkip) {
+            return { name: '', startTime: 0 };
+        }
+        if (!this.events.has(name) || this.scopes.length === 0) {
+            throw new Error(`Event ${name} is not created.`);
+        }
+        if (this.scopes[this.scopes.length - 1] !== name) {
+            console.warn(`[PERFORMANCE WARNING] Event ${name} early exit.`);
+        }
+        this.scopes.pop();
+
+        const event: Event = this.events.get(name)!;
+        const endTime: number = performance.now();
+        const parentEvent: string = this.scopes[this.scopes.length - 1];
+        const duration: number = endTime - event.startTime;
+        if (!parentEvent) {
+            this.totalDuration += duration;
+        }
+
+        if (shouldLog) {
+            console.log(
+                `[PERFORMANCE] name: ${event.name}, parent: ${parentEvent}, duration: ${formatTime(duration)}(${round(duration)}), total: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`
+            );
+        }
+
+        const newEvent = { ...event, endTime, parentEvent, duration };
+        const history = this.historyEvents.get(parentEvent ?? null) || [];
+        this.historyEvents.set(parentEvent ?? null, [...history, newEvent]);
+        return newEvent;
+    }
+
+    stopLastEvent(shouldLog: boolean = false): Event {
+        if (this.shouldSkip) {
+            return { name: '', startTime: 0 };
+        }
+        if (this.scopes.length === 0) {
+            throw new Error("No last event");
+        }
+        const name: string = this.scopes.pop()!;
+        if (!this.events.has(name)) {
+            throw new Error(`Event ${name} is not created.`);
+        }
+
+        const event: Event = this.events.get(name)!;
+        const endTime: number = performance.now();
+        const parentEvent: string = this.scopes[this.scopes.length - 1];
+        const duration: number = endTime - event.startTime;
+        if (!parentEvent) {
+            this.totalDuration += duration;
+        }
+
+        if (shouldLog) {
+            console.log(
+                `[PERFORMANCE] name: ${event.name}, parent: ${parentEvent}, duration: ${formatTime(duration)}(${round(duration)}), total: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`
+            );
+        }
+
+        const newEvent = { ...event, endTime, parentEvent, duration };
+        const history = this.historyEvents.get(parentEvent ?? null) || [];
+        this.historyEvents.set(parentEvent ?? null, [...history, newEvent]);
+        return newEvent;
+    }
+
+    clearAllEvents(shouldLog: boolean = false): void {
+        if (this.shouldSkip) {
+            return;
+        }
+        for (let i = 0; i < this.scopes.length; i ++) {
+            this.stopLastEvent(shouldLog);
+        }
+        this.events = new Map();
+    }
+
+    clearTotalDuration(): void {
+        this.totalDuration = 0;
+    }
+
+    clearHistory(): void {
+        this.historyEvents = new Map();
+    }
+
+    visualizeEvents(shouldLog: boolean = false): void {
+        if (this.shouldSkip) {
+            return;
+        }
+        const that = this;
+        function buildVisualization(parentKey: string | null, indentLevel: number): [string, number] {
+            const children = that.historyEvents.get(parentKey) || [];
+            let result = '';
+    
+            children.forEach(child => {
+                const indent = '  '.repeat(indentLevel);
+                const duration = child.duration ?? 0;
+                const [_result, count] = buildVisualization(child.name, indentLevel + 1);
+                result += `${indent}- ${child.name}: ${formatTime(duration)}(${round(duration)}), ${count}\n`;
+                result += _result;
+            });
+    
+            return [result, children.length];
+        }
+
+        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 ====`);
+        }
+    }
+}

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

@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2022-2025 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 { 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 { Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from '../../../generated/Es2pandaEnums';
+import { classByPeer } from '../class-by-peer';
+import type { AstNode } from '../peers/AstNode';
+import { ArktsObject } from '../peers/ArktsObject';
+import { Es2pandaAstNodeType } from '../../../generated/Es2pandaEnums';
+
+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`);
+    }
+    const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer);
+    if (peerType !== expectedKind) {
+        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 unpackNonNullableNode<T extends AstNode>(peer: KNativePointer): T {
+    if (peer === nullptr) {
+        throwError('peer is NULLPTR (maybe you should use unpackNode)');
+    }
+    return classByPeer(peer) as T;
+}
+
+export function unpackNode<T extends AstNode>(peer: KNativePointer): T | undefined {
+    if (peer === nullptr) {
+        return undefined;
+    }
+    return classByPeer(peer) as T;
+}
+
+export function passNode(node: ArktsObject | undefined): KNativePointer {
+    return node?.peer ?? nullptr;
+}
+
+// meaning unpackNonNullableNodeArray
+export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer): T[] {
+    if (nodesPtr === nullptr) {
+        throwError('nodesPtr is NULLPTR (maybe you should use unpackNodeArray)');
+    }
+    return new NativePtrDecoder().decode(nodesPtr).map((peer: KNativePointer) => unpackNonNullableNode(peer));
+}
+
+export function passNodeArray(nodes: readonly AstNode[] | undefined): BigUint64Array {
+    return new BigUint64Array(nodes?.map((node) => BigInt(node.peer)) ?? []);
+}
+
+export function unpackNonNullableObject<T extends ArktsObject>(
+    Type: { new (peer: KNativePointer): T },
+    peer: KNativePointer
+): T {
+    if (peer === nullptr) {
+        throwError('peer is NULLPTR (maybe you should use unpackObject)');
+    }
+    return new Type(peer);
+}
+
+export function unpackObject<T extends ArktsObject>(
+    Type: { new (peer: KNativePointer): T },
+    peer: KNativePointer
+): T | undefined {
+    if (peer === nullptr) {
+        return undefined;
+    }
+    return new Type(peer);
+}
+
+export { unpackString } from "../../../arkts-api/utilities/private"
+
+export function passString(str: string | undefined): string {
+    if (str === undefined) {
+        return '';
+    }
+    return withString(str, (it: string) => it);
+}
+
+export function passStringArray(strings: readonly string[]): string[] {
+    return withStringArray(strings, (it: string[]) => it);
+}
+
+export function passNodeWithNewModifiers<T extends AstNode>(node: T, modifiers: KInt): T {
+    return (unpackNonNullableNode(node.peer) as T).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
+    );
+}
+
+// TODO: remove this
+// TODO: update scopes and other data
+export function updatePeerByNode<T extends AstNode>(peer: KNativePointer, original: T | undefined): KNativePointer {
+    if (peer === nullptr) {
+        throwError('updatePeerByNode called on NULLPTR');
+    }
+    if (original === undefined) {
+        return peer;
+    }
+    global.generatedEs2panda._AstNodeSetOriginalNode(global.context, peer, original.peer);
+    global.generatedEs2panda._AstNodeSetParent(
+        global.context,
+        peer,
+        global.generatedEs2panda._AstNodeParent(global.context, original.peer)
+    );
+    global.es2panda._AstNodeUpdateChildren(global.context, peer);
+    global.generatedEs2panda._AstNodeClearModifier(global.context, peer, allFlags);
+    global.generatedEs2panda._AstNodeAddModifier(global.context, peer, original.modifiers);
+    global.es2panda._AstNodeUpdateChildren(global.context, peer);
+    return peer;
+}
+
+// TODO: update scopes and other data
+export function updateNodeByNode<T extends AstNode>(node: T, original: AstNode): T {
+    if (original.peer === nullptr) {
+        throwError('update called on NULLPTR');
+    }
+    global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, original.peer);
+    global.generatedEs2panda._AstNodeSetParent(
+        global.context,
+        node.peer,
+        global.generatedEs2panda._AstNodeParent(global.context, original.peer)
+    );
+    global.es2panda._AstNodeUpdateChildren(global.context, node.peer);
+    return node;
+}
+
+export function nodeType(node: AstNode): Es2pandaAstNodeType {
+    return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node));
+}
+
+/**
+ * @deprecated
+ */
+export function compose<T extends AstNode, ARGS extends any[]>(
+    create: (...args: ARGS) => T,
+    update: (node: T, original: T) => T = updateNodeByNode
+): (node: T, ...args: ARGS) => T {
+    return (node: T, ...args: ARGS) => update(create(...args), node);
+}
+
+export function updateThenAttach<T extends AstNode, ARGS extends any[]>(
+    update: (original: T, ...args: ARGS) => T,
+    ...attachFuncs: ((node: T, original: T) => T)[]
+): (node: T, ...args: ARGS) => T {
+    return (node: T, ...args: ARGS) => {
+        let _node: T = update(node, ...args);
+        attachFuncs.forEach((attach) => {
+            _node = attach(_node, node);
+        });
+        return _node;
+    };
+}
+
+export function attachModifiers<T extends AstNode>(node: T, original: T): T {
+    node.modifiers = original.modifiers;
+    return node;
+}