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

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

@@ -13,19 +13,19 @@
  * limitations under the License.
  */
 
-import * as fs from "fs"
-import * as path from "path"
-import { Es2pandaContextState } from "../../generated/Es2pandaEnums"
-import { global } from "./global"
+import * as fs from 'fs';
+import * as path from 'path';
+import { Es2pandaContextState } from '../../../generated/Es2pandaEnums';
+import { global } from './global';
 
-const PERFORMANCE_DATA_DIR = "./performance-results/"
+const PERFORMANCE_DATA_DIR = './performance-results/';
 
 interface PluginData {
-    transformTime: number
-    transformTimeDeps: number
-    visitedNodes: number
-    createdNodes: number
-    contextState?: Es2pandaContextState
+    transformTime: number;
+    transformTimeDeps: number;
+    visitedNodes: number;
+    createdNodes: number;
+    contextState?: Es2pandaContextState;
 }
 
 function emptyPluginData(contextState?: Es2pandaContextState): PluginData {
@@ -34,156 +34,172 @@ function emptyPluginData(contextState?: Es2pandaContextState): PluginData {
         transformTimeDeps: 0,
         visitedNodes: 0,
         createdNodes: 0,
-        contextState: contextState
-    }
+        contextState: contextState,
+    };
 }
 
 interface PerformanceData {
-    filePath: string
+    filePath: string;
 
-    visitedNodes: number
-    createdNodes: number
-    proceedTime: number
-    totalTime: number
+    visitedNodes: number;
+    createdNodes: number;
+    proceedTime: number;
+    totalTime: number;
 
-    pluginsByName: Record<string, PluginData>
+    pluginsByName: Record<string, PluginData>;
 }
 
 interface PerformanceDataFile {
-    data: PerformanceData[]
-    summary?: PerformanceData
+    data: PerformanceData[];
+    summary?: PerformanceData;
 }
 
 function parseFile(performanceFile: string): PerformanceDataFile | undefined {
-    if (!fs.existsSync(performanceFile)) return undefined
+    if (!fs.existsSync(performanceFile)) return undefined;
 
-    const data = fs.readFileSync(path.resolve(performanceFile)).toString()
-    if (!data.length) return undefined
-    return JSON.parse(data) as PerformanceDataFile
+    const data = fs.readFileSync(path.resolve(performanceFile)).toString();
+    if (!data.length) return undefined;
+    return JSON.parse(data) as PerformanceDataFile;
 }
 
 export class Profiler implements PerformanceData {
-    filePath: string = ""
-    visitedNodes: number = 0
-    createdNodes: number = 0
-    proceedTime: number = 0
-    totalTime: number = 0
-    pluginsByName: Record<string, PluginData> = {}
+    filePath: string = '';
+    visitedNodes: number = 0;
+    createdNodes: number = 0;
+    proceedTime: number = 0;
+    totalTime: number = 0;
+    pluginsByName: Record<string, PluginData> = {};
 
-    curPlugin: string = ""
-    curContextState?: Es2pandaContextState
+    curPlugin: string = '';
+    curContextState?: Es2pandaContextState;
 
     private getPluginData(pluginName: string, contextState?: Es2pandaContextState): PluginData {
         if (!(pluginName in this.pluginsByName)) {
-            this.pluginsByName[pluginName] = emptyPluginData(contextState)
+            this.pluginsByName[pluginName] = emptyPluginData(contextState);
         }
-        return this.pluginsByName[pluginName]
+        return this.pluginsByName[pluginName];
     }
 
-    disableReport = false
+    disableReport = true;
 
     nodeCreated() {
-        this.createdNodes++
-        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).createdNodes++
+        this.createdNodes++;
+        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).createdNodes++;
     }
 
     nodeVisited() {
-        this.visitedNodes++
-        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).visitedNodes++
+        this.visitedNodes++;
+        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).visitedNodes++;
     }
 
-    private transformStartTime = 0
-    transformStarted() {
-        this.transformStartTime = Date.now()
+    private transformStartTime = 0;
+    transformStarted(): void {
+        this.transformStartTime = Date.now();
     }
-    private transformDepStartTime = 0
-    transformDepStarted() {
-        this.transformDepStartTime = Date.now()
+    private transformDepStartTime = 0;
+    transformDepStarted(): void {
+        this.transformDepStartTime = Date.now();
     }
 
-    transformEnded(state: Es2pandaContextState, pluginName: string) {
-        const transformEndTime = Date.now()
-        const consumedTime = transformEndTime - this.transformStartTime
-        this.getPluginData(pluginName, state).transformTime += consumedTime
+    transformEnded(state: Es2pandaContextState, pluginName: string): void {
+        const transformEndTime = Date.now();
+        const consumedTime = transformEndTime - this.transformStartTime;
+        this.getPluginData(pluginName, state).transformTime += consumedTime;
     }
 
-    transformDepEnded(state: Es2pandaContextState, pluginName: string) {
-        const transformEndTime = Date.now()
-        const consumedTime = transformEndTime - this.transformDepStartTime
-        this.getPluginData(pluginName, state).transformTimeDeps += consumedTime
+    transformDepEnded(state: Es2pandaContextState, pluginName: string): void {
+        const transformEndTime = Date.now();
+        const consumedTime = transformEndTime - this.transformDepStartTime;
+        this.getPluginData(pluginName, state).transformTimeDeps += consumedTime;
     }
 
     proceededToState(consumedTime: number) {
-        this.proceedTime += consumedTime
+        this.proceedTime += consumedTime;
     }
 
-    private compilationStartTime = 0
+    private compilationStartTime = 0;
     compilationStarted(filePath: string) {
-        this.filePath = filePath
+        this.filePath = filePath;
 
-        this.visitedNodes = 0
-        this.createdNodes = 0
-        this.proceedTime = 0
-        this.totalTime = 0
-        this.pluginsByName = {}
+        this.visitedNodes = 0;
+        this.createdNodes = 0;
+        this.proceedTime = 0;
+        this.totalTime = 0;
+        this.pluginsByName = {};
 
-        this.curPlugin = ""
-        this.compilationStartTime = Date.now()
+        this.curPlugin = '';
+        this.compilationStartTime = Date.now();
     }
 
     compilationEnded() {
-        const consumedTime: number = Date.now() - this.compilationStartTime
-        this.totalTime = consumedTime
+        const consumedTime: number = Date.now() - this.compilationStartTime;
+        this.totalTime = consumedTime;
     }
 
     report() {
         Object.entries(this.pluginsByName).forEach((data, key) => {
-            console.log(data[0], "totalTransformTime =", data[1].transformTime, "ms")
-            console.log(data[0], "totalDepsTransformTime =", data[1].transformTimeDeps, "ms")
-        })
+            console.log(data[0], 'totalTransformTime =', data[1].transformTime, 'ms');
+            console.log(data[0], 'totalDepsTransformTime =', data[1].transformTimeDeps, 'ms');
+        });
     }
 
     reportToFile(withSummary: boolean = false) {
-        if (this.disableReport) return
-        const outDir = path.resolve(global.arktsconfig!.outDir, PERFORMANCE_DATA_DIR)
-        fs.mkdirSync(outDir, { recursive: true })
-        const outFilePath = path.resolve(outDir, path.basename(this.filePath)) + ".json"
-    
-        const data: PerformanceDataFile = { data: [this as PerformanceData] }
+        if (this.disableReport) return;
+        const outDir = path.resolve(global.arktsconfig!.outDir, PERFORMANCE_DATA_DIR);
+        fs.mkdirSync(outDir, { recursive: true });
+        const outFilePath = path.resolve(outDir, path.basename(this.filePath)) + '.json';
+
+        const data: PerformanceDataFile = { data: [this as PerformanceData] };
         if (!fs.existsSync(outFilePath)) {
-            fs.writeFileSync(outFilePath, JSON.stringify(data))
+            fs.writeFileSync(outFilePath, JSON.stringify(data));
         } else {
-            const savedData: PerformanceDataFile | undefined = parseFile(outFilePath) ?? data
-            savedData.data.push(this as PerformanceData)
+            const savedData: PerformanceDataFile | undefined = parseFile(outFilePath) ?? data;
+            savedData.data.push(this as PerformanceData);
 
             if (withSummary) {
                 const summary: PerformanceData = {
                     filePath: this.filePath,
-                    visitedNodes: savedData.data.map(it => it.visitedNodes).reduce((sum, it) => sum + it),
-                    createdNodes: savedData.data.map(it => it.createdNodes).reduce((sum, it) => sum + it),
-                    proceedTime: savedData.data.map(it => it.proceedTime).reduce((sum, it) => sum + it),
-                    totalTime: savedData.data.map(it => it.totalTime).reduce((sum, it) => sum + it),
-                    pluginsByName: {}
-                }
-                const pluginNames = new Set(savedData.data.flatMap(it => Object.keys(it.pluginsByName)))
+                    visitedNodes: savedData.data.map((it) => it.visitedNodes).reduce((sum, it) => sum + it),
+                    createdNodes: savedData.data.map((it) => it.createdNodes).reduce((sum, it) => sum + it),
+                    proceedTime: savedData.data.map((it) => it.proceedTime).reduce((sum, it) => sum + it),
+                    totalTime: savedData.data.map((it) => it.totalTime).reduce((sum, it) => sum + it),
+                    pluginsByName: {},
+                };
+                const pluginNames = new Set(savedData.data.flatMap((it) => Object.keys(it.pluginsByName)));
                 for (const pluginName of pluginNames) {
-                    const sumTransformTime = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].transformTime).reduce((sum, it) => sum+it)
-                    const sumTransformTimeDeps = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].transformTimeDeps).reduce((sum, it) => sum+it)
-                    const sumCreatedNodes = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].createdNodes).reduce((sum, it) => sum+it)
-                    const sumVisitedNodes = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].visitedNodes).reduce((sum, it) => sum+it)
+                    const sumTransformTime = savedData.data
+                        .map((it) => it.pluginsByName)
+                        .filter((it) => !!it[pluginName])
+                        .map((it) => it[pluginName].transformTime)
+                        .reduce((sum, it) => sum + it);
+                    const sumTransformTimeDeps = savedData.data
+                        .map((it) => it.pluginsByName)
+                        .filter((it) => !!it[pluginName])
+                        .map((it) => it[pluginName].transformTimeDeps)
+                        .reduce((sum, it) => sum + it);
+                    const sumCreatedNodes = savedData.data
+                        .map((it) => it.pluginsByName)
+                        .filter((it) => !!it[pluginName])
+                        .map((it) => it[pluginName].createdNodes)
+                        .reduce((sum, it) => sum + it);
+                    const sumVisitedNodes = savedData.data
+                        .map((it) => it.pluginsByName)
+                        .filter((it) => !!it[pluginName])
+                        .map((it) => it[pluginName].visitedNodes)
+                        .reduce((sum, it) => sum + it);
 
                     summary.pluginsByName[pluginName] = {
                         transformTime: sumTransformTime,
                         transformTimeDeps: sumTransformTimeDeps,
                         createdNodes: sumCreatedNodes,
                         visitedNodes: sumVisitedNodes,
-                    }
+                    };
                 }
 
-                savedData.summary = summary
+                savedData.summary = summary;
             }
 
-            fs.writeFileSync(outFilePath, JSON.stringify(savedData))
+            fs.writeFileSync(outFilePath, JSON.stringify(savedData));
         }
     }
 }

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

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-import { KInt, KNativePointer, KUInt } from "@koalaui/interop"
+import { KNativePointer, KUInt } from '@koalaui/interop';
 import type {
     ClassDefinition,
     ETSFunctionType,
@@ -25,113 +25,130 @@ import type {
     Program,
     ScriptFunction,
     SourcePosition,
-} from "../../generated"
-import { ExternalSource } from "../peers/ExternalSource"
-import { Es2pandaAstNodeType, Es2pandaModuleFlag } from "../../generated/Es2pandaEnums"
-import { global } from "../static/global"
-import { acceptNativeObjectArrayResult, passNodeArray, unpackNodeArray, unpackNonNullableNode } from "./private"
-import type { AstNode } from "../peers/AstNode"
+} from '../../../generated';
+import { ExternalSource } from '../peers/ExternalSource';
+import { Es2pandaAstNodeType, Es2pandaModuleFlag } from '../../../generated/Es2pandaEnums';
+import { global } from '../static/global';
+import { acceptNativeObjectArrayResult, passNodeArray, unpackNodeArray, unpackNonNullableNode } from './private';
+import type { AstNode } from '../peers/AstNode';
 
 export function extension_ETSModuleGetNamespaceFlag(this: ETSModule): Es2pandaModuleFlag {
-    return (this.isETSScript ? Es2pandaModuleFlag.MODULE_FLAG_ETSSCRIPT : 0)
-        + (this.isNamespace ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE : 0)
-        + (this.isNamespaceChainLastNode ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE_CHAIN_LAST_NODE : 0)
+    return (
+        (this.isETSScript ? Es2pandaModuleFlag.MODULE_FLAG_ETSSCRIPT : 0) +
+        (this.isNamespace ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE : 0) +
+        (this.isNamespaceChainLastNode ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE_CHAIN_LAST_NODE : 0)
+    );
 }
 
 // this is a workaround for overloads not included in children list
 export function extension_MethodDefinitionSetChildrenParentPtr(this: MethodDefinition) {
-    global.es2panda._AstNodeSetChildrenParentPtr(global.context, this.peer)
-    const overloads = this.overloads
+    global.es2panda._AstNodeSetChildrenParentPtr(global.context, this.peer);
+    const overloads = this.overloads;
     for (const overload of overloads) {
-        overload.setBaseOverloadMethod(this)
-        overload.parent = this // overloads are not listed as children in native
+        overload.setBaseOverloadMethod(this);
+        overload.parent = this; // overloads are not listed as children in native
     }
 }
 
 export function extension_MethodDefinitionOnUpdate(this: MethodDefinition, original: MethodDefinition): void {
-    this.setChildrenParentPtr()
-    global.es2panda._AstNodeOnUpdate(global.context, this.peer, original.peer)
-    const originalBase = original.baseOverloadMethod
+    this.setChildrenParentPtr();
+    global.es2panda._AstNodeOnUpdate(global.context, this.peer, original.peer);
+    const originalBase = original.baseOverloadMethod;
     if (originalBase) {
-        this.setBaseOverloadMethod(originalBase)
+        this.setBaseOverloadMethod(originalBase);
     }
 }
 
 // Improve: generate checker related stuff
 export function extension_ScriptFunctionGetSignaturePointer(this: ScriptFunction): KNativePointer {
-    return global.es2panda._Checker_ScriptFunctionSignature(global.context, this.peer)
+    return global.es2panda._Checker_ScriptFunctionSignature(global.context, this.peer);
 }
 
-export function extension_ScriptFunctionSetSignaturePointer(this: ScriptFunction, signaturePointer: KNativePointer): void {
-    global.es2panda._Checker_ScriptFunctionSetSignature(global.context, this.peer, signaturePointer)
+export function extension_ScriptFunctionSetSignaturePointer(
+    this: ScriptFunction,
+    signaturePointer: KNativePointer
+): void {
+    global.es2panda._Checker_ScriptFunctionSetSignature(global.context, this.peer, signaturePointer);
 }
 
 // Improve: weird API
 export function extension_ScriptFunctionGetParamsCasted(this: ScriptFunction): readonly ETSParameterExpression[] {
-    return unpackNodeArray<ETSParameterExpression>(global.generatedEs2panda._ScriptFunctionParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
+    return unpackNodeArray<ETSParameterExpression>(
+        global.generatedEs2panda._ScriptFunctionParams(global.context, this.peer),
+        Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION
+    );
 }
 
 // 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.es2panda._Checker_ScriptFunctionGetPreferredReturnType(global.context, this.peer);
 }
 
-export function extension_ScriptFunctionSetPreferredReturnTypePointer(this: ScriptFunction, typePointer: KNativePointer): void {
-    global.es2panda._Checker_ScriptFunctionSetPreferredReturnType(global.context, this.peer, typePointer)
+export function extension_ScriptFunctionSetPreferredReturnTypePointer(
+    this: ScriptFunction,
+    typePointer: KNativePointer
+): void {
+    global.es2panda._Checker_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.es2panda._Checker_ExpressionGetPreferredType(global.context, this.peer);
 }
 
 export function extension_ExpressionSetPreferredTypePointer(this: Expression, typePointer: KNativePointer): void {
-    global.es2panda._Checker_ExpressionSetPreferredType(global.context, this.peer, typePointer)
+    global.es2panda._Checker_ExpressionSetPreferredType(global.context, this.peer, typePointer);
 }
 
 // Improve: weird API
 export function extension_ProgramGetAstCasted(this: Program): ETSModule {
-    return unpackNonNullableNode<ETSModule>(global.generatedEs2panda._ProgramAst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)
+    return unpackNonNullableNode<ETSModule>(
+        global.generatedEs2panda._ProgramAst(global.context, this.peer),
+        Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE
+    );
 }
 
 // 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,
-    )
+        ExternalSource.instantiate
+    );
 }
 
 // Improve: SourcePositionLine is global in idl
 export function extension_SourcePositionGetLine(this: SourcePosition): KUInt {
-    return global.generatedEs2panda._SourcePositionLine(global.context, this.peer)
+    return global.generatedEs2panda._SourcePositionLine(global.context, this.peer);
 }
 
 // Improve: SourcePositionCol is not described in idl
 export function extension_SourcePositionGetCol(this: SourcePosition): KUInt {
-    return global.es2panda._SourcePositionCol(global.context, this.peer)
+    return global.es2panda._SourcePositionCol(global.context, this.peer);
 }
 
 // Improve: SourcePositionIndex is global in idl
 export function extension_SourcePositionGetIndex(this: SourcePosition): KUInt {
-    return global.generatedEs2panda._SourcePositionIndex(global.context, this.peer)
+    return global.generatedEs2panda._SourcePositionIndex(global.context, this.peer);
 }
 
 export function extension_SourcePositionToString(this: SourcePosition): string {
-    return `:${this.getLine() + 1}:${this.getCol()}`
+    return `:${this.getLine() + 1}:${this.getCol()}`;
 }
 
 // Improve: weird API
 export function extension_NumberLiteralValue(this: NumberLiteral): number {
-    return +this.dumpSrc()
+    return +this.dumpSrc();
 }
 
 // Improve: weird API
 export function extension_ClassDefinitionSetBody(this: ClassDefinition, body: readonly AstNode[]): void {
-    global.es2panda._ClassDefinitionSetBody(global.context, this.peer, passNodeArray(body), body.length)
+    global.es2panda._ClassDefinitionSetBody(global.context, this.peer, passNodeArray(body), body.length);
 }
 
 // Improve: weird API
 export function extension_ETSFunctionTypeGetParamsCasted(this: ETSFunctionType): readonly ETSParameterExpression[] {
-    return unpackNodeArray<ETSParameterExpression>(global.generatedEs2panda._ETSFunctionTypeParamsConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
+    return unpackNodeArray<ETSParameterExpression>(
+        global.generatedEs2panda._ETSFunctionTypeParamsConst(global.context, this.peer),
+        Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION
+    );
 }

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;
+    }
+}