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

package/build/libarkts-copy/native/src/{common.cc → common.cpp}

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-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
@@ -22,24 +22,26 @@
 #include <bitset>
 
 #include "interop-types.h"
+#include "memoryTracker.h"
 
 using std::string, std::cout, std::endl, std::vector;
+constexpr int AST_NODE_TYPE_LIMIT = 256;
 
 es2panda_Impl* es2pandaImplementation = nullptr;
 static thread_local StageArena currentArena;
 
-StageArena* StageArena::instance()
+StageArena* StageArena::Instance()
 {
     return &currentArena;
 }
 
-void StageArena::add(void* pointer)
+void StageArena::Add(void* pointer)
 {
     if (pointer)
         allocated.push_back(pointer);
 }
 
-void StageArena::cleanup()
+void StageArena::Cleanup()
 {
     if (totalSize > 0 && false)
         printf("cleanup %d objects %d bytes\n", (int)allocated.size(), (int)totalSize);
@@ -57,26 +59,26 @@ StageArena::StageArena()
 
 StageArena::~StageArena()
 {
-    cleanup();
+    Cleanup();
 }
 
-char* StageArena::strdup(const char* string)
+char* StageArena::Strdup(const char* string)
 {
-    auto* arena = StageArena::instance();
+    auto* arena = StageArena::Instance();
     auto size = strlen(string) + 1;
-    char* memory = (char*)arena->alloc(size);
+    char* memory = (char*)arena->Alloc(size);
     interop_memcpy(memory, size, string, size);
     return memory;
 }
 
-void* StageArena::alloc(size_t size)
+void* StageArena::Alloc(size_t size)
 {
     void* result = malloc(size);
     if (!result) {
         INTEROP_FATAL("Cannot allocate memory");
     }
     totalSize += size;
-    add(result);
+    Add(result);
     return result;
 }
 
@@ -178,7 +180,6 @@ void* TryLibrary(const char* name)
     return nullptr;
 }
 
-// TODO: @panda/sdk will be changed to match ohos-sdk
 void* FindLibrary()
 {
     void* res = nullptr;
@@ -227,7 +228,7 @@ const char** getStringArray(KStringArray& ptr)
 
 char* getStringCopy(KStringPtr& ptr)
 {
-    return StageArena::strdup(ptr.c_str() ? ptr.c_str() : "");
+    return StageArena::Strdup(ptr.c_str() ? ptr.c_str() : "");
 }
 
 void impl_DestroyConfig(KNativePointer config)
@@ -236,41 +237,10 @@ void impl_DestroyConfig(KNativePointer config)
     // panda prints diagnostics here and do not clone our strings
     // so keep arena alive until this moment.
     GetImpl()->DestroyConfig(_config);
-    StageArena::instance()->cleanup();
+    StageArena::Instance()->Cleanup();
     printf("[libarkts native] Arena cleaned up!\n");
 }
-KOALA_INTEROP_V1(DestroyConfig, KNativePointer);
-
-KNativePointer impl_UpdateCallExpression(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer calleePtr,
-    KNativePointerArray argumentsPtr, KInt argumentsLen, KNativePointer typeParamsPtr, KBoolean optionalT,
-    KBoolean trailingCommaT)
-{
-    auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
-    auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
-    auto callee = reinterpret_cast<es2panda_AstNode*>(calleePtr);
-    auto arguments = reinterpret_cast<es2panda_AstNode**>(argumentsPtr);
-    auto typeParams = reinterpret_cast<es2panda_AstNode*>(typeParamsPtr);
-    auto optional = static_cast<bool>(optionalT);
-    auto trailingComma = static_cast<bool>(trailingCommaT);
-
-    auto nn =
-        GetImpl()->CreateCallExpression(context, callee, arguments, argumentsLen, typeParams, optional, trailingComma);
-    GetImpl()->AstNodeSetOriginalNode(context, nn, node);
-    return nn;
-}
-KOALA_INTEROP_8(UpdateCallExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer,
-    KNativePointerArray, KInt, KNativePointer, KBoolean, KBoolean)
-
-KInt impl_IdentifierIdentifierFlags(KNativePointer contextPtr, KNativePointer nodePtr)
-{
-    auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
-    auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
-
-    return (GetImpl()->IdentifierIsOptionalConst(context, node) ? (1 << 0) : 0) |
-           (GetImpl()->IdentifierIsReferenceConst(context, node) ? (1 << 1) : 0) |
-           (GetImpl()->IdentifierIsTdzConst(context, node) ? (1 << 2) : 0);
-}
-KOALA_INTEROP_2(IdentifierIdentifierFlags, KInt, KNativePointer, KNativePointer)
+KOALA_INTEROP_V1(DestroyConfig, KNativePointer)
 
 void impl_ClassDefinitionSetBody(
     KNativePointer context, KNativePointer receiver, KNativePointerArray body, KUInt bodyLength)
@@ -367,7 +337,7 @@ KNativePointer impl_AstNodeChildren(KNativePointer contextPtr, KNativePointer no
     cachedChildren.clear();
 
     GetImpl()->AstNodeIterateConst(context, node, visitChild);
-    return StageArena::clone(cachedChildren);
+    return StageArena::Clone(cachedChildren);
 }
 KOALA_INTEROP_2(AstNodeChildren, KNativePointer, KNativePointer, KNativePointer);
 
@@ -380,10 +350,29 @@ struct Pattern {
     std::regex regex;
 
     Pattern(const Pattern&) = delete;
+    Pattern& operator=(const Pattern&) = default;
+
+    Pattern(Pattern&& other) noexcept
+        : context(other.context),
+        key(std::move(other.key)),
+        value(std::move(other.value)),
+        impl(other.impl),
+        isWildcard(other.isWildcard),
+        regex(other.regex)
+        {
+            other.isWildcard = false;
+        }
 
-    Pattern(Pattern&& other) noexcept :
-        context(other.context), key(std::move(other.key)), value(std::move(other.value)), impl(other.impl), isWildcard(other.isWildcard), regex(other.regex) {
+    Pattern& operator=(Pattern&& other) noexcept
+    {
+        context = other.context;
+        key = std::move(other.key);
+        value = std::move(other.value);
+        impl = other.impl;
+        isWildcard = other.isWildcard;
+        regex = other.regex;
         other.isWildcard = false;
+        return *this;
     }
 
     Pattern(es2panda_Context* context, const std::string& part) : context(context), impl(GetImpl())
@@ -392,95 +381,104 @@ struct Pattern {
         std::getline(stream, key, '=');
         std::getline(stream, value, '=');
         isWildcard = value.find('*') != std::string::npos;
-
         if (isWildcard) {
             this->regex = std::regex(value);
         }
     }
-    
+
     ~Pattern() = default;
 
     bool match(es2panda_AstNode* node) const
     {
         if (key == "type") {
-            auto type = impl->AstNodeTypeConst(context, node);
-            switch (type) {
-                case Es2pandaAstNodeType::AST_NODE_TYPE_METHOD_DEFINITION:
-                    return value == "method";
-                case Es2pandaAstNodeType::AST_NODE_TYPE_SCRIPT_FUNCTION:
-                    return value == "function";
-                case Es2pandaAstNodeType::AST_NODE_TYPE_STRUCT_DECLARATION:
-                    return value == "struct";
-                case Es2pandaAstNodeType::AST_NODE_TYPE_CALL_EXPRESSION:
-                    return value == "call";
-                case Es2pandaAstNodeType::AST_NODE_TYPE_ASSIGNMENT_EXPRESSION:
-                    return value == "assignment";
-                default:
-                    return false;
-            }
+            return matchByType(node, impl->AstNodeTypeConst(context, node));
         }
         if (key == "annotation") {
-            std::size_t length = 0;
-            Es2pandaAstNodeType type = impl->AstNodeTypeConst(context, node);
-            es2panda_AstNode** result = nullptr;
-            switch (type) {
-                case Es2pandaAstNodeType::AST_NODE_TYPE_SCRIPT_FUNCTION: {
-                    result = impl->ScriptFunctionAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_FUNCTION_DECLARATION: {
-                    result = impl->FunctionDeclarationAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION: {
-                    result = impl->ArrowFunctionExpressionAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_FUNCTION_TYPE: {
-                    result = impl->TypeNodeAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION: {
-                    result = impl->TSTypeAliasDeclarationAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_VARIABLE_DECLARATION: {
-                    result = impl->VariableDeclarationAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_UNION_TYPE: {
-                    result = impl->TypeNodeAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_CLASS_PROPERTY: {
-                    result = impl->ClassPropertyAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION: {
-                    result = impl->ETSParameterExpressionAnnotations(context, node, &length);
-                    break;
-                }
-                default:
-                    return false;
+            return matchByAnnotation(node, impl->AstNodeTypeConst(context, node));
+        }
+        return false;
+    }
+
+    bool matchByType(es2panda_AstNode* node, Es2pandaAstNodeType type) const
+    {
+        switch (type) {
+            case Es2pandaAstNodeType::AST_NODE_TYPE_METHOD_DEFINITION:
+                return value == "method";
+            case Es2pandaAstNodeType::AST_NODE_TYPE_SCRIPT_FUNCTION:
+                return value == "function";
+            case Es2pandaAstNodeType::AST_NODE_TYPE_STRUCT_DECLARATION:
+                return value == "struct";
+            case Es2pandaAstNodeType::AST_NODE_TYPE_CALL_EXPRESSION:
+                return value == "call";
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_IMPORT_DECLARATION:
+                return value == "import";
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ASSIGNMENT_EXPRESSION:
+                return value == "assignment";
+            default:
+                return false;
+        }
+    }
+
+    bool matchByAnnotation(es2panda_AstNode* node, Es2pandaAstNodeType type) const
+    {
+        std::size_t length = 0;
+        es2panda_AstNode** result = nullptr;
+        switch (type) {
+            case Es2pandaAstNodeType::AST_NODE_TYPE_SCRIPT_FUNCTION: {
+                result = impl->ScriptFunctionAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_FUNCTION_DECLARATION: {
+                result = impl->FunctionDeclarationAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION: {
+                result = impl->ArrowFunctionExpressionAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_FUNCTION_TYPE: {
+                result = impl->TypeNodeAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION: {
+                result = impl->TSTypeAliasDeclarationAnnotations(context, node, &length);
+                break;
             }
-            bool found = false;
-            for (std::size_t i = 0; i < length && result; i++) {
-                es2panda_AstNode* ident = impl->AnnotationUsageIrGetBaseNameConst(context, result[i]);
-                const char* name = impl->IdentifierNameConst(context, ident);
-                found |= matchWildcard(value, name);
+            case Es2pandaAstNodeType::AST_NODE_TYPE_VARIABLE_DECLARATION: {
+                result = impl->VariableDeclarationAnnotations(context, node, &length);
+                break;
             }
-            return found;
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_UNION_TYPE: {
+                result = impl->TypeNodeAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_CLASS_PROPERTY: {
+                result = impl->ClassPropertyAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION: {
+                result = impl->ETSParameterExpressionAnnotations(context, node, &length);
+                break;
+            }
+            default:
+                return false;
         }
-        return false;
+
+        bool found = false;
+        for (std::size_t i = 0; i < length && result; i++) {
+            es2panda_AstNode* ident = impl->AnnotationUsageIrGetBaseNameConst(context, result[i]);
+            found |= MatchWildcard(value, impl->IdentifierNameConst(context, ident));
+        }
+        return found;
     }
 
-    bool matchWildcard(const std::string& pattern, const char* value) const
+    bool MatchWildcard(const std::string& pattern, const char* foundValue) const
     {
         if (!isWildcard) {
-            return pattern == value;
+            return pattern == foundValue;
         }
 
-        return std::regex_search(value, this->regex);
+        return std::regex_search(foundValue, this->regex);
     }
 };
 
@@ -507,11 +505,11 @@ struct Matcher {
     }
 };
 
-KNativePointer impl_FilterNodes(KNativePointer context, KNativePointer node, const KStringPtr& filters, KBoolean deeperAfterMatch)
+static KNativePointer DoFilterNodes(es2panda_Context* _context,
+                                    es2panda_AstNode* _node,
+                                    const char* _filters,
+                                    bool deeperAfterMatch)
 {
-    auto _node = reinterpret_cast<es2panda_AstNode*>(node);
-    auto _context = reinterpret_cast<es2panda_Context*>(context);
-    const char* _filters = filters.c_str();
     std::vector<es2panda_AstNode*> result;
     es2panda_Impl* impl = GetImpl();
     Matcher matcher(_context, _filters);
@@ -526,18 +524,23 @@ KNativePointer impl_FilterNodes(KNativePointer context, KNativePointer node, con
         }
         if (!isMatch || deeperAfterMatch) {
             impl->AstNodeIterateConst(_context, current, visitChild);
-            // We want to retain match order, so add children in reverse order.
             for (auto it = cachedChildren.rbegin(); it != cachedChildren.rend(); ++it) {
                 queue.push_back(*it);
             }
             cachedChildren.clear();
         }
     }
-    return StageArena::cloneVector(result.data(), result.size());
+    return StageArena::CloneVector(result.data(), result.size());
 }
-KOALA_INTEROP_4(FilterNodes, KNativePointer, KNativePointer, KNativePointer, KStringPtr, KBoolean)
 
-constexpr int AST_NODE_TYPE_LIMIT = 256;
+KNativePointer impl_FilterNodes(
+    KNativePointer context, KNativePointer node, const KStringPtr& filters, KBoolean deeperAfterMatch)
+{
+    auto* _node = reinterpret_cast<es2panda_AstNode*>(node);
+    auto* _context = reinterpret_cast<es2panda_Context*>(context);
+    return DoFilterNodes(_context, _node, filters.c_str(), static_cast<bool>(deeperAfterMatch));
+}
+KOALA_INTEROP_4(FilterNodes, KNativePointer, KNativePointer, KNativePointer, KStringPtr, KBoolean)
 
 struct FilterArgs {
     es2panda_Impl *impl;
@@ -564,7 +567,7 @@ KNativePointer impl_FilterNodes2(KNativePointer context, KNativePointer node, KI
     std::vector<es2panda_AstNode *> result;
     FilterArgs args = { GetImpl(), _context, &typesMask, &result };
     GetImpl()->AstNodeForEach(_node, filterByType, &args);
-    return StageArena::cloneVector(result.data(), result.size());
+    return StageArena::CloneVector(result.data(), result.size());
 }
 KOALA_INTEROP_3(FilterNodes2, KNativePointer, KNativePointer, KNativePointer, KInt)
 
@@ -579,7 +582,7 @@ KNativePointer impl_FilterNodes3(KNativePointer context, KNativePointer node, KI
     std::vector<es2panda_AstNode *> result;
     FilterArgs args = { GetImpl(), _context, &typesMask, &result };
     GetImpl()->AstNodeForEach(_node, filterByType, &args);
-    return StageArena::cloneVector(result.data(), result.size());
+    return StageArena::CloneVector(result.data(), result.size());
 }
 KOALA_INTEROP_4(FilterNodes3, KNativePointer, KNativePointer, KNativePointer, KInt*, KInt)
 
@@ -590,18 +593,6 @@ KOALA_INTEROP_4(FilterNodes3, KNativePointer, KNativePointer, KNativePointer, KI
 // From koala-wrapper
 // Improve: check if some code should be generated
 
-void impl_MemInitialize()
-{
-    GetImpl()->MemInitialize();
-}
-KOALA_INTEROP_V0(MemInitialize)
-
-void impl_MemFinalize()
-{
-    GetImpl()->MemFinalize();
-}
-KOALA_INTEROP_V0(MemFinalize)
-
 static bool isUIHeaderFile(es2panda_Context* context, es2panda_Program* program)
 {
     auto result = GetImpl()->ProgramFileNameWithExtensionConst(context, program);
@@ -650,3 +641,49 @@ KNativePointer impl_AstNodeProgram(KNativePointer contextPtr, KNativePointer ins
     return impl_AstNodeProgram(_context, GetImpl()->AstNodeParent(_context, _receiver));
 }
 KOALA_INTEROP_2(AstNodeProgram, KNativePointer, KNativePointer, KNativePointer)
+
+// This api could be generated (as combination of 2 briges) after namespace util is generated
+KInt impl_GetCompilationMode(KNativePointer configPtr)
+{
+    auto _config = reinterpret_cast<es2panda_Config*>(configPtr);
+    auto _options = const_cast<es2panda_Options*>(GetImpl()->ConfigGetOptions(_config));
+    return GetImpl()->OptionsUtilGetCompilationModeConst(nullptr, _options);
+}
+KOALA_INTEROP_1(GetCompilationMode, KInt, KNativePointer)
+
+KNativePointer impl_CreateTypeNodeFromTsType(KNativePointer context, KNativePointer nodePtr)
+{
+    const auto _context = reinterpret_cast<es2panda_Context*>(context);
+    const auto _nodePtr = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+    auto _tsType = GetImpl()->TypedTsType(_context, _nodePtr);
+    if (_tsType == nullptr) {
+        _tsType = GetImpl()->ExpressionTsType(_context, _nodePtr);
+    }
+    if (_tsType == nullptr) {
+        return nullptr;
+    }
+    const auto _nodeTsType = reinterpret_cast<es2panda_Type*>(_tsType);
+    auto _typeAnnotation = GetImpl()->CreateOpaqueTypeNode(_context, _nodeTsType);
+    return _typeAnnotation;
+}
+KOALA_INTEROP_2(CreateTypeNodeFromTsType, KNativePointer, KNativePointer, KNativePointer)
+
+MemoryTracker tracker;
+void impl_MemoryTrackerReset(KNativePointer context)
+{
+    tracker.Reset();
+}
+KOALA_INTEROP_V1(MemoryTrackerReset, KNativePointer);
+
+void impl_MemoryTrackerGetDelta(KNativePointer context)
+{
+    tracker.Report(tracker.GetDelta());
+}
+KOALA_INTEROP_V1(MemoryTrackerGetDelta, KNativePointer);
+
+void impl_MemoryTrackerPrintCurrent(KNativePointer context)
+{
+    tracker.Report(GetMemoryStats());
+}
+KOALA_INTEROP_V1(MemoryTrackerPrintCurrent, KNativePointer);
+

package/build/libarkts-copy/native/src/common.h

@@ -16,21 +16,6 @@
 #ifndef COMMON_H
 #define COMMON_H
 
-/*
- * 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.
- */
-
 #include <iostream>
 #include <string>
 #include <vector>
@@ -82,52 +67,52 @@ class StageArena {
 public:
     StageArena();
     ~StageArena();
-    static StageArena* instance();
+    static StageArena* Instance();
     template<typename T>
-    static T* alloc()
+    static T* Alloc()
     {
-        auto* arena = StageArena::instance();
-        void* memory = arena->alloc(sizeof(T));
+        auto* arena = StageArena::Instance();
+        void* memory = arena->Alloc(sizeof(T));
         return new (memory) T();
     }
     template<class T, class T1>
-    static T* alloc(T1 arg1)
+    static T* Alloc(T1 arg1)
     {
-        auto* arena = StageArena::instance();
-        void* memory = arena->alloc(sizeof(T));
+        auto* arena = StageArena::Instance();
+        void* memory = arena->Alloc(sizeof(T));
         return new (memory) T(std::forward(arg1));
     }
     template<class T, class T1, class T2>
-    static T* alloc(T1 arg1, T2 arg2)
+    static T* Alloc(T1 arg1, T2 arg2)
     {
-        auto* arena = StageArena::instance();
-        void* memory = arena->alloc(sizeof(T));
+        auto* arena = StageArena::Instance();
+        void* memory = arena->Alloc(sizeof(T));
         return new (memory) T(arg1, arg2);
     }
     template<typename T>
-    static T* allocArray(size_t count)
+    static T* AllocArray(size_t count)
     {
-        auto* arena = StageArena::instance();
+        auto* arena = StageArena::Instance();
         // align?
-        void* memory = arena->alloc(sizeof(T) * count);
+        void* memory = arena->Alloc(sizeof(T) * count);
         return new (memory) T();
     }
     template<class T>
-    static T* clone(const T& arg)
+    static T* Clone(const T& arg)
     {
-        auto* arena = StageArena::instance();
-        void* memory = arena->alloc(sizeof(T));
+        auto* arena = StageArena::Instance();
+        void* memory = arena->Alloc(sizeof(T));
         return new (memory) T(arg);
     }
     template<class T>
-    static std::vector<const void*>* cloneVector(const T* arg, size_t count)
+    static std::vector<const void*>* CloneVector(const T* arg, size_t count)
     {
-        return alloc<std::vector<const void*>, const T*, const T*>(arg, arg + count);
+        return Alloc<std::vector<const void*>, const T*, const T*>(arg, arg + count);
     }
-    void* alloc(size_t size);
-    static char* strdup(const char* original);
-    void add(void* pointer);
-    void cleanup();
+    void* Alloc(size_t size);
+    static char* Strdup(const char* original);
+    void Add(void* pointer);
+    void Cleanup();
 };
 
 #endif // COMMON_H

package/build/libarkts-copy/native/src/{memoryTracker.cc → memoryTracker.cpp}

@@ -163,9 +163,15 @@ void MemoryTracker::Report(MemoryStats stats)
         const double mb = kb * BYTES_PER_KB;
         const double gb = mb * BYTES_PER_KB;
 
-        if (bytes > gb) return std::to_string(bytes / gb) + " GB";
-        if (bytes > mb) return std::to_string(bytes / mb) + " MB";
-        if (bytes > kb) return std::to_string(bytes / kb) + " KB";
+        if (bytes > gb) {
+            return std::to_string(bytes / gb) + " GB";
+        }
+        if (bytes > mb) {
+            return std::to_string(bytes / mb) + " MB";
+        }
+        if (bytes > kb) {
+            return std::to_string(bytes / kb) + " KB";
+        }
         return std::to_string(bytes) + " B";
     };
 

package/build/libarkts-copy/package.json

@@ -4,9 +4,6 @@
     "main": "./lib/libarkts.js",
     "typesVersions": {
         "*": {
-            "./compat/*": [
-                "./lib/types/wrapper-compat/index.d.ts"
-            ],
             "*": [
                 "./lib/types/src/index.d.ts"
             ]
@@ -14,7 +11,6 @@
     },
     "exports": {
         ".": "./lib/libarkts.js",
-        "./compat": "./lib/libarkts-compat.js",
         "./plugins/*": "./lib/plugins/*.js"
     },
     "files": [
@@ -24,7 +20,7 @@
     ],
     "config": {
         "panda_sdk_path": "../incremental/tools/panda/node_modules/@panda/sdk",
-        "panda_sdk_version": "next"
+        "panda_sdk_version": "1.5.0-dev.53118"
     },
     "dependencies": {
         "@koalaui/compat": "1.7.10+devel",
@@ -42,7 +38,7 @@
         "tsconfig-paths": "^4.2.0",
         "rimraf": "^6.0.1",
         "@koalaui/fast-arktsc": "1.7.10+devel",
-        "@idlizer/arktscgen": "2.1.10-arktscgen-5",
+        "@idlizer/arktscgen": "2.1.10-arktscgen-8",
         "mocha": "^9.2.2",
         "@koalaui/harness": "1.7.10+devel",
         "@koalaui/ets-tsc": "4.9.5-r6",
@@ -51,7 +47,7 @@
         "node-api-headers": "0.0.5"
     },
     "scripts": {
-        "clean": "rimraf generated build native/build* ./.rollup.cache tsconfig.tsbuildinfo lib",
+        "clean": "rimraf generated build native/mingw_build native/build* ./.rollup.cache tsconfig.tsbuildinfo lib",
         "clean:plugins": "rimraf plugins/build",
         "compile:koala:interop": "npm run --prefix ../interop compile",
         "compile:meson": "cd native && meson setup build && meson compile -C build",
@@ -63,7 +59,7 @@
         "compile": "npm run regenerate && npm run compile:native && npm run compile:js",
         "compile:current": "npm run regenerate:current && npm run compile:native && npm run compile:js",
         "compile:release": "npm run regenerate && npm run crosscompile:native && npm run compile:js",
-        "compile:js": "rm -rf lib/ && rollup -c rollup.lib.mjs && rollup -c rollup.es2panda.mjs",
+        "compile:js": "rm -rf lib/ && rollup -c rollup.libarkts.mjs && rollup -c rollup.es2panda.mjs",
         "compile:plugins": "rollup -c ./rollup.printer-plugin.mjs",
         "direct": "fast-arktsc --config arktsconfig.json --compiler ../incremental/tools/panda/arkts/ui2abc --link-name ./build/abc/main.abc && ninja -f build/abc/build.ninja",
         "simultaneous": "mkdir -p build/abc && bash ../incremental/tools/panda/arkts/ui2abc --simultaneous --arktsconfig arktsconfig.json --output ./build/abc/main.abc:./build/abc/library.abc plugins/input/main.ets:plugins/input/library.ets",
@@ -78,7 +74,7 @@
         "compile:playground": "cd playground && meson setup build && meson compile -C build",
         "run:playground": "npm run compile:playground && mkdir -p build && ./playground/build/playground _ --extension ets --stdlib ../incremental/tools/panda/node_modules/@panda/sdk/ets/stdlib --output build/playground.abc ./playground/src/main.ets",
         "panda:sdk:clean": "cd ../incremental/tools/panda && rimraf node_modules",
-        "panda:sdk:install": "cd ../incremental/tools/panda && echo \"Installing panda sdk $npm_package_config_panda_sdk_version\" && PANDA_SDK_VERSION=$npm_package_config_panda_sdk_version npm run panda:sdk:install",
+        "panda:sdk:install": "cd ../incremental/tools/panda && echo \"Installing panda sdk $npm_package_config_panda_sdk_version\" && PANDA_SDK_VERSION=${PANDA_SDK_VERSION:-$npm_package_config_panda_sdk_version} npm run panda:sdk:install",
         "panda:sdk:reinstall": "npm run panda:sdk:clean && npm run panda:sdk:install",
         "regenerate:current": "rimraf -rf ./generated && npm run compile -C ../../arktscgen && node ../../arktscgen --panda-sdk-path $npm_package_config_panda_sdk_path --output-dir ../ --options-file ./generator/options.json5 --no-initialize --debug",
         "regenerate": "rimraf -rf ./generated && arktscgen --panda-sdk-path ${PANDA_SDK_PATH:=$npm_package_config_panda_sdk_path} --output-dir ../ --options-file ./generator/options.json5 --no-initialize",