@jack120/test 0.2.0 → 0.2.2

package/package.json

@@ -1,13 +1,13 @@
 {
 	"name": "@jack120/test",
-	"version": "0.2.0",
+	"version": "0.2.2",
 	"description": "Adamas Typescript interface",
 	"main": "dist/index.js",
 	"scripts": {
 		"compile": "npx cmake-js compile",
 		"start": "npx ts-node index.ts",
 		"format": "npx prettier . --write",
-		"esbuild": "npx esbuild library/index.ts --bundle --format=esm --outfile=dist/index.js --platform=node  --external:\"*.node\" --packages=external",
+		"esbuild": "npx esbuild library/index.ts --bundle --minify --format=esm --outfile=dist/index.js --platform=node  --external:\"*.node\" --packages=external",
 		"dts": "npx dts-bundle-generator -o dist/index.d.ts library/index.ts"
 	},
 	"repository": {
@@ -18,6 +18,11 @@
 	"bugs": {
 		"url": "https://github.com/adamas-vr/prefab-interface/issues"
 	},
+	"types": "./types/index.d.ts",
+	"files": [
+		"dist",
+		"types"
+	],
 	"homepage": "https://github.com/adamas-vr/prefab-interface#readme",
 	"dependencies": {
 		"gl-matrix": "^3.4.4"

package/{library/adamas-types.d.ts → types/index.d.ts}

@@ -1,5 +1,3 @@
-
-
 declare module "*.mat" {
 	type UUID = `${string}-${string}-${string}-${string}-${string}`;
 	const value: {
@@ -45,14 +43,13 @@ declare module "*.mat" {
 }
 
 declare module "*.tex" {
-    import { TextureFilterMode, TextureWrapMode } from "@adamas/render/texture";
 	const value: {
 		assetType: "Texture";
 
 		base64Image: string;
 		mineType: string;
-		filterMode: TextureFilterMode;
-		wrapMode: TextureWrapMode;
+		filterMode: number;
+		wrapMode: number;
 	};
 	export default value;
 }

package/.gitmodules

@@ -1,3 +0,0 @@
-[submodule "external/Unity-NodeJS-RPC"]
-	path = external/Unity-NodeJS-RPC
-	url = git@github.com:adamas-vr/Unity-NodeJS-RPC.git

package/.prettierrc

@@ -1,6 +0,0 @@
-{
-	"useTabs": true,
-	"semi": true,
-	"singleQuote": false,
-	"trailingComma": "all"
-}

package/.vscode/c_cpp_properties.json

@@ -1,14 +0,0 @@
-{
-	"configurations": [
-		{
-			"name": "MacOS",
-			"includePath": [
-				"${workspaceFolder}/**",
-				"${workspaceFolder}/node_modules/node-addon-api",
-				"~/.cmake-js/node-arm64/v22.14.0/include/node"
-			],
-			"defines": ["NAPI_VERSION=8"]
-		}
-	],
-	"version": 4
-}

package/.vscode/launch.json

@@ -1,24 +0,0 @@
-{
-	// Use IntelliSense to learn about possible attributes.
-	// Hover to view descriptions of existing attributes.
-	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-	"version": "0.2.0",
-	"configurations": [
-		{
-			"type": "cppdbg",
-			"request": "launch",
-			"name": "Debug",
-			"program": "/usr/local/bin/node",
-			"args": [
-				"-r",
-				"tsconfig-paths/register",
-				"-r",
-				"ts-node/register",
-				"--force-node-api-uncaught-exceptions-policy=true",
-				"index.ts"
-			],
-			"cwd": "${workspaceFolder}",
-			"MIMode": "lldb"
-		}
-	]
-}

package/.vscode/settings.json

@@ -1,8 +0,0 @@
-{
-	"editor.defaultFormatter": "esbenp.prettier-vscode",
-	"prettier.configPath": ".prettierrc",
-	"editor.formatOnSave": true,
-	"editor.insertSpaces": false, // Use tabs instead of spaces
-	"editor.tabSize": 4, // Set tab size to 4
-	"editor.detectIndentation": false
-}

package/CMakeLists.txt

@@ -1,52 +0,0 @@
-cmake_minimum_required(VERSION 3.9)
-cmake_policy(SET CMP0042 NEW)
-set (CMAKE_CXX_STANDARD 20)
-
-project (native-bindings)
-include_directories(${CMAKE_JS_INC})
-file(GLOB SOURCE_FILES "native.cc")
-add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES} ${CMAKE_JS_SRC})
-set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
-target_link_libraries(${PROJECT_NAME} ${CMAKE_JS_LIB})
-
-# Include Node-API wrappers
-execute_process(COMMAND node -p "require('node-addon-api').include"
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        OUTPUT_VARIABLE NODE_ADDON_API_DIR
-        )
-string(REGEX REPLACE "[\r\n\"]" "" NODE_ADDON_API_DIR ${NODE_ADDON_API_DIR})
-
-target_include_directories(${PROJECT_NAME} PRIVATE ${NODE_ADDON_API_DIR})
-
-message("-- CMAKE_JS_INC: ${CMAKE_JS_INC}")
-message("-- NODE_ADDON_API_DIR: ${NODE_ADDON_API_DIR}")
-
-# define NAPI_VERSION
-add_definitions(-DNAPI_VERSION=8)
-
-# Set output directory for post-build copy
-set(OUTPUT_DIR "${CMAKE_SOURCE_DIR}/library")
-
-# Ensure the output directory exists
-file(MAKE_DIRECTORY ${OUTPUT_DIR})
-
-if(WIN32)
-    set(PLATFORM_SUFFIX "-win")
-elseif(APPLE)
-    set(PLATFORM_SUFFIX "-osx")
-endif()
-
-# Define a new name with suffix
-set(PROJECT_NAME_WITH_SUFFIX "${PROJECT_NAME}${PLATFORM_SUFFIX}")
-
-# Copy the built .node file to the output directory after build
-add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy
-        $<TARGET_FILE:${PROJECT_NAME}>
-        ${OUTPUT_DIR}/${PROJECT_NAME_WITH_SUFFIX}.node
-    COMMENT "Copying ${PROJECT_NAME}.node to ${OUTPUT_DIR}"
-)
-
-add_subdirectory(external)
-target_link_libraries(${PROJECT_NAME} rpcClient)
-

package/adamas-config.json

@@ -1,5 +0,0 @@
-{
-	"name": "Project name",
-	"public": true,
-	"description": "The description of the prefab."
-}

package/external/CMakeLists.txt

@@ -1 +0,0 @@
-add_subdirectory(Unity-NodeJS-RPC)

package/external/Unity-NodeJS-RPC/CMakeLists.txt

@@ -1,13 +0,0 @@
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-
-option(BUILD_RPC_CLIENT_TEST "Option of building RPC client test" OFF)
-
-add_library(rpcClient RpcClient.cpp)
-target_include_directories(rpcClient PUBLIC include .)
-
-if (BUILD_RPC_CLIENT_TEST)
-    add_executable(rpcMain main.cpp)
-    target_link_libraries(rpcMain rpcClient)
-endif()

package/external/Unity-NodeJS-RPC/README.md

@@ -1 +0,0 @@
-## Works on Windows only

package/external/Unity-NodeJS-RPC/RpcClient.cpp

@@ -1,265 +0,0 @@
-#include "RpcClient.h"
-
-#ifdef _WIN32
-#include <algorithm>
-#else
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <unistd.h>
-#endif
-
-#include <iostream>
-
-#define SOCKET_CHECK(status) if (status < 0)    \
-    {                                           \
-        perror("Failed: " #status "\n");        \
-        exit(EXIT_FAILURE);                     \
-    }
-
-#define STATUS_CHECK(status, msg) if (status)   \
-    {                                           \
-        perror("ERROR: " #msg "\n");            \
-        exit(EXIT_FAILURE);                     \
-    }
-
-RpcClient::RpcClient(int port, bool isNode): isNode(isNode)
-{
-#ifdef _WIN32
-    WSADATA wsaData;
-    int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
-    if (iResult != 0) {
-        throw std::runtime_error("WSAStartup failed.\n");
-    }
-    clientSocket = socket(AF_INET, SOCK_STREAM, 0);
-    if (clientSocket == INVALID_SOCKET) {
-        WSACleanup();
-        throw std::runtime_error("Error at socket creation.\n");
-    }
-
-    sockaddr_in serverAddr;
-    serverAddr.sin_family = AF_INET;
-    serverAddr.sin_port = htons(port);
-    serverAddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-
-    if (connect(clientSocket, (SOCKADDR*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
-        throw std::runtime_error("Socket connection failed.\n");
-    }
-#else
-    sockaddr_in address = {};
-    address.sin_family = AF_INET;
-    address.sin_port = htons(port);
-    address.sin_addr.s_addr = INADDR_ANY;
-
-    SOCKET_CHECK((clientSocket = socket(AF_INET, SOCK_STREAM, 0)) < 0);
-    SOCKET_CHECK((connect(clientSocket, (struct sockaddr*)&address, sizeof(address))) < 0);
-#endif
-
-    size_t sizeRecv = recv(clientSocket, (char*)&responseHeader, sizeof(ResponseHeader), 0);
-    STATUS_CHECK(
-        sizeRecv != sizeof(ResponseHeader) || responseHeader.bufferSize != 0, 
-        "DEBUG: Error receiving client ID."
-    );
-
-    rpcReturnValueReady.store(false);
-    running.store(true);
-    clientId = responseHeader.clientId;
-    printf("Client ID: %d\n", clientId);
-
-    receiver = std::thread([&, isNode]()
-    {
-        while (running)
-        {
-            while (rpcReturnValueReady == true)
-                continue;
-
-            size_t sizeRecv = recv(clientSocket, (char*)&responseHeader, sizeof(ResponseHeader), MSG_WAITALL);
-            STATUS_CHECK(sizeRecv != sizeof(ResponseHeader) && running, "DEBUG: failed to recv callback header");
-            
-            if (!running)
-                return;
-        
-            if (responseHeader.bufferSize != 0)
-            {
-                responseArgsJson.resize(responseHeader.bufferSize);
-            
-                int bytesReceived = 0;
-                while (bytesReceived < responseHeader.bufferSize)
-                {
-                    int chunkSize = std::min<int>(1024, responseHeader.bufferSize - bytesReceived);
-                    char* dataPtr = responseArgsJson.data() + bytesReceived;
-                    int chunkBytesReceived = recv(clientSocket, dataPtr, chunkSize, 0);
-        
-                    STATUS_CHECK(chunkBytesReceived == -1, "Error receiving message data");
-                    bytesReceived += chunkBytesReceived;
-                }
-            }
-
-            if (responseHeader.msgType == ResponseHeader::MsgType::MSG_CALLBACK)
-            {
-                if (isNode)
-                    std::thread(callbackHandler, responseHeader.u.callbackId, responseArgsJson).detach();
-                else
-                    std::thread(ProcessCallback, callbackRegistry, responseHeader, responseArgsJson).detach();
-            }
-            else if (responseHeader.msgType == ResponseHeader::MsgType::MSG_RETURN)
-            {                
-                rpcReturnValueReady = true;
-            }
-            else
-            {
-                std::runtime_error("[RPC Client] ERROR: Corrupted response header.");
-            }
-        }
-    });
-}
-
-RpcClient::~RpcClient()
-{
-    running.store(false);
-#ifdef _WIN32
-    closesocket(clientSocket);
-    WSACleanup();
-#else
-    close(clientSocket);
-#endif
-    receiver.join();
-}
-
-nlohmann::json RpcClient::Call(
-    const std::string& functionName,
-    const std::vector<std::pair<std::string, nlohmann::json>>& dataArgs,
-    const std::vector<std::pair<std::string, Callback>>& callbackArgs)
-{
-    std::vector<std::string> keys;
-    std::vector<std::string> values;
-
-    for (const auto& [k, v] : dataArgs) {
-        keys.push_back(k);
-        values.push_back(v.dump());  // Convert json to string
-    }
-
-    for (const auto& [k, cb] : callbackArgs) {
-        int id = RegisterCallback(cb);
-        keys.push_back(k);
-        values.push_back(std::to_string(id));
-    }
-
-    nlohmann::json args;
-    args["keys"] = keys;
-    args["values"] = values;
-
-    RpcRequest rpcRequest;
-    rpcRequest.header.clientId = clientId;
-    strncpy(
-        rpcRequest.header.functionName,
-        functionName.c_str(),
-        sizeof(rpcRequest.header.functionName) - 1
-    );
-    rpcRequest.jsonArgs = args.dump();
-    rpcRequest.header.bufferSize = rpcRequest.jsonArgs.size();
-
-    return ProcessRPC(rpcRequest);
-}
-
-std::string RpcClient::Call(const std::string& functionName, const std::string& jsonArgs)
-{
-    RpcRequest rpcRequest;
-    rpcRequest.header.clientId = clientId;
-    strncpy(
-        rpcRequest.header.functionName,
-        functionName.c_str(),
-        sizeof(rpcRequest.header.functionName) - 1
-    );
-    rpcRequest.jsonArgs = jsonArgs;
-    rpcRequest.header.bufferSize = rpcRequest.jsonArgs.size();
-
-    return ProcessRPC(rpcRequest);
-}
-
-void RpcClient::RegisterCallbackHandler(std::function<void(int, const std::string&)> fn)
-{
-    callbackHandler = fn;
-}
-
-int RpcClient::RegisterCallback(Callback cb)
-{
-    int id = Call("_RPC::AllocateCallback", {{"clientId", clientId}});
-    callbackRegistry[id] = std::move(cb);
-    return id;
-}
-
-void RpcClient::ProcessCallback(
-    const std::unordered_map<int, Callback>& cbRegistry,
-    const ResponseHeader& respHeader,
-    const std::string& respArgsJson)
-{
-    auto it = cbRegistry.find(respHeader.u.callbackId);
-
-    nlohmann::json wrapped = nlohmann::json::parse(respArgsJson, nullptr, false);
-    if (it != cbRegistry.end() && !wrapped.is_discarded() && 
-        wrapped.contains("keys") && wrapped.contains("values"))
-    {
-        nlohmann::json flat;
-
-        const auto& keys = wrapped["keys"];
-        const auto& values = wrapped["values"];
-        for (size_t i = 0; i < keys.size() && i < values.size(); ++i) {
-            std::string key = keys[i];
-            std::string valStr = values[i];
-
-            // Try to parse value string as JSON
-            nlohmann::json parsedVal = nlohmann::json::parse(valStr, nullptr, false);
-            if (!parsedVal.is_discarded()) {
-                flat[key] = parsedVal;
-            } else {
-                flat[key] = valStr;
-            }
-        }
-
-        it->second(flat); // Invoke callback with reconstructed flat object
-    }
-}
-
-nlohmann::json RpcClient::ProcessRPC(const RpcRequest& req)
-{
-    {
-        std::lock_guard<std::mutex> RpcLock(callMutex);
-        
-        size_t sizeSent = send(clientSocket, (char*)&req, sizeof(req.header), 0);
-        STATUS_CHECK(sizeSent != sizeof(req.header), "DEBUG: failed to send header");
-
-        if (req.header.bufferSize != 0)
-        {
-            int index = 0;
-            while (index < req.header.bufferSize)
-            {
-                int chunk_size = std::min<int>(1024, req.header.bufferSize - index);
-                const char* data_ptr = req.jsonArgs.c_str() + index;
-                int bytes_sent = send(clientSocket, data_ptr, chunk_size, 0);
-
-                STATUS_CHECK(bytes_sent == -1, "DEBUG: failed to send everything");
-                index += bytes_sent;
-            }
-        }
-    }
-    
-    while (rpcReturnValueReady == false)
-        continue;
-
-    printf("RPC: %s |-> %s\n", req.header.functionName, responseArgsJson.c_str());
-
-    if (isNode) 
-    {
-        std::string str = responseArgsJson;
-        rpcReturnValueReady = false;
-        return str;
-    }
-    auto str = nlohmann::json::parse(responseArgsJson)["result"].get<std::string>();
-    auto retval = nlohmann::json::parse(str, nullptr, false);
-    rpcReturnValueReady = false;
-
-    if (retval.is_discarded()) {
-        return str;
-    }
-    return retval;
-}

package/external/Unity-NodeJS-RPC/include/RpcClient.h

@@ -1,118 +0,0 @@
-#pragma once
-
-#ifdef _WIN32
-#define NOMINMAX
-#include <WinSock2.h>
-#pragma comment(lib, "Ws2_32.lib")  // Optional backup
-#define SOCKET_TYPE SOCKET
-#else
-#define SOCKET_TYPE int
-#endif
-
-#include <string>
-#include <functional>
-#include <unordered_map>
-#include <thread>
-#include <mutex>
-
-#include <nlohmann/json.hpp>
-
-
-struct RpcRequest
-{
-    struct {
-        int clientId;
-        char functionName[64];
-        int bufferSize;
-    } header;
-
-    std::string jsonArgs;
-};
-
-struct ResponseHeader
-{
-    enum class MsgType {
-        MSG_CALLBACK = 0,
-        MSG_RETURN = 1
-    };
-
-    int clientId;
-    MsgType msgType;
-    union {
-        int callbackId;
-        int statusCode;
-    } u;
-
-    int bufferSize;
-};
-
-class RpcClient
-{
-public:
-    static RpcClient& Get(int port = 6969, bool isNode = false)
-    {
-        static RpcClient rpcClient{GetPort(port), isNode};
-        return rpcClient;
-    }
-
-    using Callback = std::function<void(const nlohmann::json&)>;
-
-    // Make a call with arguments and optional callbacks
-    nlohmann::json Call(
-        const std::string& functionName,
-        const std::vector<std::pair<std::string, nlohmann::json>>& dataArgs = {},
-        const std::vector<std::pair<std::string, Callback>>& callbackArgs = {}
-    );
-
-    std::string Call(const std::string& functionName, const std::string& jsonArgs);
-
-    void RegisterCallbackHandler(std::function<void(int, const std::string&)> fn);
-
-    int GetClientId() { return clientId; }
-
-private:
-    RpcClient(int port, bool isNode);
-    ~RpcClient();
-
-    RpcClient(const RpcClient&) = delete;
-    const RpcClient& operator=(const RpcClient&) = delete;
-
-    nlohmann::json ProcessRPC(const RpcRequest& req);
-    int RegisterCallback(Callback cb);
-    
-    static void ProcessCallback(
-        const std::unordered_map<int, Callback>& cbRegistry,
-        const ResponseHeader& respHeader,
-        const std::string& respArgsJson
-    );
-
-    static int GetPort(int port)
-    {
-        const char* envPort = std::getenv("SERVER_PORT");
-        if (envPort != nullptr)
-        {
-            try {
-                return std::stoi(envPort);
-            } catch (...) {
-                // Invalid value in SERVER_PORT, fallback to default
-            }
-        }
-        return port;
-    }
-
-private:
-    SOCKET_TYPE clientSocket;
-    int clientId;
-    bool isNode;
-
-    ResponseHeader responseHeader;
-    std::string responseArgsJson;
-
-    std::atomic_bool rpcReturnValueReady;
-    std::mutex callMutex;
-    std::thread receiver;
-    std::atomic_bool running;
-    
-    std::function<void(int, const std::string&)> callbackHandler;
-    std::unordered_map<int, Callback> callbackRegistry;
-};

package/external/Unity-NodeJS-RPC/main.cpp

@@ -1,76 +0,0 @@
-
-#include "RpcClient.h"
-#include <iostream>
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <unistd.h>
-#endif
-
-int main() {
-    RpcClient rpcClient{};
-
-    nlohmann::json result;
-
-    result = rpcClient.Call("sub", {
-        {"a", 2},
-        {"b", 3}
-    });
-    std::cout << "[C++] sub Response: " << result << std::endl;
-
-    result = rpcClient.Call("mul", {
-        {"a", 2},
-        {"b", 23.2}
-    });
-    std::cout << "[C++] mul Response: " << result << std::endl;
-
-    result = rpcClient.Call("echo", {
-        {"text", "echo back"}
-    });
-    std::cout << "[C++] echo Response: " << result << std::endl;
-
-    result = rpcClient.Call("do_work",
-    {
-        {"input", "Hello from C++"},
-        {"delay", 3000} // simulate work on Unity side
-    },
-    {
-        {"onComplete", [](const nlohmann::json& result) {
-            std::cout << "[Callback] Received result from Unity: " << result.dump() << std::endl;
-        }}
-    });
-    std::cout <<  "[C++] do_work Response: " << result << std::endl;
-
-    int handle = rpcClient.Call("timer",
-    {
-        {"text", rpcClient.GetClientId()},
-        {"interval", 1000} // simulate work on Unity side
-    },
-    {
-        {"callback", [&](const nlohmann::json& result) {
-            rpcClient.Call("AddToCounter", {{"value", 1}});
-            std::cout << "[Callback] Received result from Unity: " << result.dump() << std::endl;
-        }}
-    });
-    std::cout <<  "[C++] Timer response: " << handle << std::endl;
-
-#ifdef _WIN32
-    Sleep(5000);
-#else    
-    sleep(5);
-#endif
-
-    printf("Handle ID: %d\n", handle);
-    rpcClient.Call("dispose_timer", {{"timerHandle", handle}});
-
-    return 0;
-
-    /**
-     * 1. RPC callback
-     * 2. Debug Window API
-     * 3. Basic Platform API support
-     * 4. Master process + child Process Spawn / deallocation
-     * 5. Multi-client communication using Semaphore
-     */
-}