@xmobitea/gn-typescript-client 2.6.12 → 2.6.13-tsc

package/dist/runtime/helper/ConverterService.js

@@ -0,0 +1,275 @@
+import { GNFieldDataType, getGNObjectMetadata } from "./../entity/DataMember";
+import { GNArray, GNData, GNHashtable } from "./../common/GNData";
+class DataMemberFieldInfoTypeMapper {
+    getGNEnhancedObjectFieldMetadata(cls) {
+        let declaredFields;
+        if (this.declaredFieldsMap.has(cls)) {
+            declaredFields = this.declaredFieldsMap.get(cls);
+        }
+        else {
+            let gnObjectMetadata = getGNObjectMetadata(cls);
+            declaredFields = gnObjectMetadata != null ? gnObjectMetadata.fields : [];
+            this.declaredFieldsMap.set(cls, declaredFields);
+        }
+        return declaredFields;
+    }
+    constructor() {
+        this.declaredFieldsMap = new Map();
+    }
+}
+class DeserializeConverter {
+    deserializeObject(gnHashtable, cls) {
+        if (gnHashtable == null)
+            return null;
+        let declaredFields = this.dataMemberFieldInfoMapper.getGNEnhancedObjectFieldMetadata(cls);
+        let answer = new cls();
+        declaredFields.forEach(declaredField => {
+            let value = gnHashtable.getObject(declaredField.code);
+            let typeOfValue = typeof value;
+            if (declaredField.gnFieldType == GNFieldDataType.String) {
+                if (value == null)
+                    answer[declaredField.name] = declaredField.defaultValue;
+                else if (typeOfValue == "string")
+                    answer[declaredField.name] = value;
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.Boolean) {
+                if (value == null)
+                    answer[declaredField.name] = declaredField.defaultValue;
+                else if (typeOfValue == "boolean")
+                    answer[declaredField.name] = value;
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.GNHashtable) {
+                if (value == null) {
+                    if (declaredField.defaultValue != null) {
+                        if (declaredField.cls == GNHashtable)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (typeof declaredField.cls == "object")
+                            answer[declaredField.name] = declaredField.defaultValue.toData();
+                        else
+                            answer[declaredField.name] = this.deserializeObject(declaredField.defaultValue, declaredField.cls);
+                    }
+                }
+                else {
+                    if (declaredField.cls == GNHashtable)
+                        answer[declaredField.name] = value;
+                    else if (typeof declaredField.cls == "object")
+                        answer[declaredField.name] = value.toData();
+                    else
+                        answer[declaredField.name] = this.deserializeObject(value, declaredField.cls);
+                }
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.GNArray) {
+                if (value == null) {
+                    if (declaredField.defaultValue != null) {
+                        if (declaredField.cls == GNArray)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (typeof declaredField.cls == "object")
+                            answer[declaredField.name] = declaredField.defaultValue.toData();
+                        else
+                            answer[declaredField.name] = this.deserializeArray(declaredField.defaultValue, declaredField.cls);
+                    }
+                }
+                else {
+                    if (declaredField.cls == GNArray)
+                        answer[declaredField.name] = value;
+                    else if (typeof declaredField.cls == "object")
+                        answer[declaredField.name] = value.toData();
+                    else
+                        answer[declaredField.name] = this.deserializeArray(value, declaredField.cls);
+                }
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.Number) {
+                if (value == null)
+                    answer[declaredField.name] = declaredField.defaultValue;
+                else if (typeOfValue == "number")
+                    answer[declaredField.name] = value;
+            }
+            else {
+                if (value == null) {
+                    if (declaredField.defaultValue != null) {
+                        if (declaredField.cls == Number)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (declaredField.cls == String)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (declaredField.cls == Boolean)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (declaredField.cls == GNHashtable)
+                            answer[declaredField.name] = this.deserializeObject(declaredField.defaultValue, declaredField.cls);
+                        else if (declaredField.cls == GNArray)
+                            answer[declaredField.name] = this.deserializeArray(declaredField.defaultValue, declaredField.cls);
+                        else
+                            answer[declaredField.name] = declaredField.defaultValue;
+                    }
+                }
+                else {
+                    if (declaredField.cls == Number)
+                        answer[declaredField.name] = value;
+                    else if (declaredField.cls == String)
+                        answer[declaredField.name] = value;
+                    else if (declaredField.cls == Boolean)
+                        answer[declaredField.name] = value;
+                    else if (declaredField.cls == GNHashtable)
+                        answer[declaredField.name] = this.deserializeObject(value, declaredField.cls);
+                    else if (declaredField.cls == GNArray)
+                        answer[declaredField.name] = this.deserializeArray(value, declaredField.cls);
+                    else
+                        answer[declaredField.name] = value;
+                }
+            }
+        });
+        return answer;
+    }
+    deserializeArray(gnArray, cls) {
+        if (gnArray == null)
+            return null;
+        let answer = [];
+        for (let i = 0; i < gnArray.count(); i++) {
+            let value = gnArray.getObject(i);
+            if (value == null)
+                answer.push(null);
+            else {
+                let typeOfValue = typeof value;
+                if (typeOfValue == "number")
+                    answer.push(value);
+                else if (typeOfValue == "string")
+                    answer.push(value);
+                else if (typeOfValue == "boolean")
+                    answer.push(value);
+                else if (cls == GNArray)
+                    answer.push(value);
+                else if (cls == GNData)
+                    answer.push(value);
+                else if (typeOfValue == "object") {
+                    if (Array.isArray(value)) {
+                        answer.push(this.deserializeArray(gnArray.getGNArray(i), cls));
+                    }
+                    else {
+                        answer.push(this.deserializeObject(gnArray.getGNHashtable(i), cls));
+                    }
+                }
+            }
+        }
+        return answer;
+    }
+    constructor(dataMemberFieldInfoMapper) {
+        this.dataMemberFieldInfoMapper = dataMemberFieldInfoMapper;
+    }
+}
+class SerializeConverter {
+    serializeObject(obj, cls) {
+        if (obj == null)
+            return null;
+        let fieldInfos = this.dataMemberFieldInfoMapper.getGNEnhancedObjectFieldMetadata(cls);
+        let answer = new GNHashtable();
+        fieldInfos.forEach((field) => {
+            let dataMemberAnno = field;
+            let value = obj[dataMemberAnno.name];
+            if (value == null) {
+                if (!dataMemberAnno.isOptional)
+                    answer.add(dataMemberAnno.code, null);
+            }
+            else {
+                let typeOfValue = typeof value;
+                if (dataMemberAnno.gnFieldType == GNFieldDataType.String) {
+                    if (typeOfValue == "string")
+                        answer.add(dataMemberAnno.code, value);
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.Boolean) {
+                    if (typeOfValue == "boolean")
+                        answer.add(dataMemberAnno.code, value);
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.GNHashtable) {
+                    if (value instanceof GNHashtable)
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue === "object") {
+                        if (!Array.isArray(value))
+                            answer.add(dataMemberAnno.code, this.serializeObject(value, dataMemberAnno.cls));
+                    }
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.GNArray) {
+                    if (value instanceof GNArray)
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue === "object") {
+                        if (Array.isArray(value))
+                            answer.add(dataMemberAnno.code, this.serializeArray(value, dataMemberAnno.cls));
+                    }
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.Number) {
+                    if (typeOfValue == "number")
+                        answer.add(dataMemberAnno.code, value);
+                }
+                else {
+                    if (typeOfValue == "string")
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue == "boolean")
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue == "number")
+                        answer.add(dataMemberAnno.code, value);
+                    else if (value instanceof GNData)
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue == "object") {
+                        if (Array.isArray(value))
+                            answer.add(dataMemberAnno.code, this.serializeArray(value, dataMemberAnno.cls));
+                        else
+                            answer.add(dataMemberAnno.code, GNHashtable.builder().addAll(value).build());
+                    }
+                    else
+                        answer.add(dataMemberAnno.code, this.serializeObject(value, dataMemberAnno.cls));
+                }
+            }
+        });
+        return answer;
+    }
+    serializeArray(objLst, cls) {
+        if (objLst == null)
+            return null;
+        let answer = new GNArray();
+        for (let i = 0; i < objLst.length; i++) {
+            let obj = objLst[i];
+            if (obj == null)
+                answer.add(null);
+            else {
+                let typeOfValue = typeof obj;
+                if (typeOfValue === "string")
+                    answer.add(obj);
+                else if (typeOfValue === "boolean")
+                    answer.add(obj);
+                else if (typeOfValue === "number")
+                    answer.add(obj);
+                else if (obj instanceof GNData)
+                    answer.add(obj);
+                else {
+                    if (typeOfValue === "object") {
+                        if (Array.isArray(obj))
+                            answer.add(this.serializeArray(obj, cls));
+                        else
+                            answer.add(this.serializeObject(obj, cls));
+                    }
+                }
+            }
+        }
+        return answer;
+    }
+    constructor(dataMemberFieldInfoMapper) {
+        this.dataMemberFieldInfoMapper = dataMemberFieldInfoMapper;
+    }
+}
+export class ConverterService {
+    static deserializeObject(gnHashtable, cls) {
+        return ConverterService.deserializeConverter.deserializeObject(gnHashtable, cls);
+    }
+    static deserializeArray(gnArray, cls) {
+        return ConverterService.deserializeConverter.deserializeArray(gnArray, cls);
+    }
+    static serializeObject(obj, cls) {
+        return ConverterService.serializeConverter.serializeObject(obj, cls);
+    }
+    static serializeArray(objLst, cls) {
+        return ConverterService.serializeConverter.serializeArray(objLst, cls);
+    }
+    static init() {
+        let dataMemberFieldInfoMapper = new DataMemberFieldInfoTypeMapper();
+        ConverterService.serializeConverter = new SerializeConverter(dataMemberFieldInfoMapper);
+        ConverterService.deserializeConverter = new DeserializeConverter(dataMemberFieldInfoMapper);
+    }
+}

package/dist/runtime/helper/EnumUtility.js

@@ -0,0 +1,33 @@
+export class EnumUtility {
+    static getEnumKeys(enumType) {
+        let keys = this.enumKeyCache.get(enumType);
+        if (!keys) {
+            keys = Object.keys(enumType).filter(key => isNaN(Number(key)));
+            this.enumKeyCache.set(enumType, keys);
+        }
+        return keys;
+    }
+    static parse(enumType, value, ignoreCase) {
+        if (!ignoreCase) {
+            if (value in enumType) {
+                return enumType[value];
+            }
+        }
+        else {
+            let normalizedValue = value.toUpperCase();
+            let enumKeys = this.getEnumKeys(enumType);
+            for (const key of enumKeys) {
+                if (key.toUpperCase() === normalizedValue) {
+                    return enumType[key];
+                }
+            }
+        }
+        return null;
+    }
+    static toString(enumType, value) {
+        let enumKeys = this.getEnumKeys(enumType);
+        const key = enumKeys.find(k => enumType[k] === value);
+        return key !== null && key !== void 0 ? key : null;
+    }
+}
+EnumUtility.enumKeyCache = new Map();

package/dist/runtime/helper/GNSupport.d.ts

@@ -1,5 +1,25 @@
+type PlatformType = "cocos" | "browser" | "nodejs";
 export declare class GNSupport {
     private static _isBrowser;
+    private static _isCocosCreator;
+    private static _platformType;
+    private static _initialized;
     static init(): void;
+    /**
+     * Check if running in standard browser environment
+     */
     static isBrowser(): boolean;
+    /**
+     * Check if running in Cocos Creator 3.x environment
+     */
+    static isCocosCreator(): boolean;
+    /**
+     * Check if running in Node.js environment
+     */
+    static isNodeJS(): boolean;
+    /**
+     * Get the current platform type
+     */
+    static getPlatformType(): PlatformType;
 }
+export {};

package/dist/runtime/helper/GNSupport.js

@@ -0,0 +1,47 @@
+// Types from ../types/cocos.d.ts are automatically available
+export class GNSupport {
+    static init() {
+        if (this._initialized)
+            return;
+        // Check for Cocos Creator 3.x first (has cc.sys)
+        this._isCocosCreator = (typeof cc !== "undefined" && cc.sys !== undefined);
+        // Browser check (has window but not Node.js)
+        this._isBrowser = (typeof window !== "undefined");
+        // Determine platform type
+        if (this._isCocosCreator) {
+            this._platformType = "cocos";
+        }
+        else if (this._isBrowser) {
+            this._platformType = "browser";
+        }
+        else {
+            this._platformType = "nodejs";
+        }
+        this._initialized = true;
+    }
+    /**
+     * Check if running in standard browser environment
+     */
+    static isBrowser() {
+        return this._isBrowser;
+    }
+    /**
+     * Check if running in Cocos Creator 3.x environment
+     */
+    static isCocosCreator() {
+        return this._isCocosCreator;
+    }
+    /**
+     * Check if running in Node.js environment
+     */
+    static isNodeJS() {
+        return this._platformType === "nodejs";
+    }
+    /**
+     * Get the current platform type
+     */
+    static getPlatformType() {
+        return this._platformType;
+    }
+}
+GNSupport._initialized = false;

package/dist/runtime/helper/GNUtils.js

@@ -0,0 +1,72 @@
+export class GNUtils {
+    static toDatasDictionary(datas) {
+        if (datas == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < datas.length; i++) {
+            let data = datas[i];
+            answer.set(data.key, data);
+        }
+        return answer;
+    }
+    static toTagsDictionary(tags) {
+        if (tags == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < tags.length; i++) {
+            let tag = tags[i];
+            answer.set(tag.key, tag);
+        }
+        return answer;
+    }
+    static toCurrenciesDictionary(currencies) {
+        if (currencies == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < currencies.length; i++) {
+            let currency = currencies[i];
+            answer.set(currency.key, currency);
+        }
+        return answer;
+    }
+    static toStatisticsDictionary(statistics) {
+        if (statistics == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < statistics.length; i++) {
+            let statistic = statistics[i];
+            answer.set(statistic.key, statistic);
+        }
+        return answer;
+    }
+    static toInventoriesDictionary(inventories) {
+        if (inventories == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < inventories.length; i++) {
+            let inventory = inventories[i];
+            answer.set(inventory.itemId, inventory);
+        }
+        return answer;
+    }
+    static toGroupDictionary(groups) {
+        if (groups == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < groups.length; i++) {
+            let group = groups[i];
+            answer.set(group.groupId, group);
+        }
+        return answer;
+    }
+    static toFriendDictionary(friends) {
+        if (friends == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < friends.length; i++) {
+            let friend = friends[i];
+            answer.set(friend.friendId, friend);
+        }
+        return answer;
+    }
+}

package/dist/runtime/helper/MessagePackConverterService.js

@@ -0,0 +1,9 @@
+import { encode, decode } from "@msgpack/msgpack";
+export class MessagePackConverterService {
+    static serialize(tObj) {
+        return encode(tObj);
+    }
+    static deserialize(data) {
+        return decode(data);
+    }
+}

package/dist/runtime/{entity → helper}/OperationHelper.d.ts

@@ -1,6 +1,6 @@
 import { RequestRole } from "./../constant/enumType/RequestRole";
 import { RequestType } from "./../constant/enumType/RequestType";
-import { OperationRequest } from "./OperationRequest";
+import { OperationRequest } from "./../entity/OperationRequest";
 export declare class OperationHelper {
     static toSocketData(requestType: RequestType, role: RequestRole, request: OperationRequest): any;
     static toHttpData(requestType: RequestType, role: RequestRole, request: OperationRequest): any;

package/dist/runtime/helper/OperationHelper.js

@@ -0,0 +1,24 @@
+import { CodeHelper } from "./CodeHelper";
+export class OperationHelper {
+    static toSocketData(requestType, role, request) {
+        let requestId = request.getRequestId();
+        if (requestId == -1)
+            return [
+                CodeHelper.getRequestTypeName(requestType),
+                CodeHelper.getRequestRoleName(role),
+                request.getOperationCode(),
+                (request.getParameters() == null) ? null : request.getParameters().toData()
+            ];
+        else
+            return [
+                CodeHelper.getRequestTypeName(requestType),
+                CodeHelper.getRequestRoleName(role),
+                request.getOperationCode(),
+                (request.getParameters() == null) ? null : request.getParameters().toData(),
+                requestId
+            ];
+    }
+    static toHttpData(requestType, role, request) {
+        return null;
+    }
+}

package/dist/runtime/helper/StorageService.d.ts

@@ -0,0 +1,18 @@
+/**
+ * StorageService - Cross-platform storage abstraction for GearN SDK
+ * Supports: Browser localStorage, Node.js, Cocos Creator 3.x
+ */
+export declare class StorageService {
+    /**
+     * Get a value from storage
+     * @param key Storage key
+     * @param defaultValue Default value if key doesn't exist
+     */
+    static getString(key: string, defaultValue?: string): any;
+    /**
+     * Set a value in storage
+     * @param key Storage key
+     * @param value Value to store
+     */
+    static setString(key: string, value: string): void;
+}

package/dist/runtime/helper/StorageService.js

@@ -0,0 +1,62 @@
+/**
+ * StorageService - Cross-platform storage abstraction for GearN SDK
+ * Supports: Browser localStorage, Node.js, Cocos Creator 3.x
+ */
+import store from "store";
+import { GNSupport } from "./GNSupport";
+// Types from ../types/cocos.d.ts are automatically available
+export class StorageService {
+    /**
+     * Get a value from storage
+     * @param key Storage key
+     * @param defaultValue Default value if key doesn't exist
+     */
+    static getString(key, defaultValue = "") {
+        try {
+            const _platform = GNSupport.getPlatformType();
+            let value = null;
+            switch (_platform) {
+                case "cocos":
+                    value = cc.sys.localStorage.getItem(key);
+                    break;
+                case "browser":
+                    value = window.localStorage.getItem(key);
+                    break;
+                case "nodejs":
+                    return store.get(key, defaultValue);
+            }
+            if (value === null || value === undefined) {
+                return defaultValue;
+            }
+            return value;
+        }
+        catch (error) {
+            console.warn("[StorageService] Error getting value for key:", key, error);
+            return defaultValue;
+        }
+    }
+    /**
+     * Set a value in storage
+     * @param key Storage key
+     * @param value Value to store
+     */
+    static setString(key, value) {
+        try {
+            const _platform = GNSupport.getPlatformType();
+            switch (_platform) {
+                case "cocos":
+                    cc.sys.localStorage.setItem(key, value);
+                    break;
+                case "browser":
+                    window.localStorage.setItem(key, value);
+                    break;
+                case "nodejs":
+                    store.set(key, value);
+                    break;
+            }
+        }
+        catch (error) {
+            console.warn("[StorageService] Error setting value for key:", key, error);
+        }
+    }
+}

package/dist/runtime/logger/GNDebug.js

@@ -0,0 +1,29 @@
+export var LogType;
+(function (LogType) {
+    LogType[LogType["Off"] = 0] = "Off";
+    LogType[LogType["Exception"] = 1] = "Exception";
+    LogType[LogType["Error"] = 2] = "Error";
+    LogType[LogType["Warning"] = 3] = "Warning";
+    LogType[LogType["All"] = 4] = "All";
+})(LogType || (LogType = {}));
+export class GNDebug {
+    static setLogType(logType) {
+        this._logType = logType;
+    }
+    static log(message) {
+        if (this._logType >= LogType.All)
+            console.log(message);
+    }
+    static logException(exception) {
+        if (this._logType >= LogType.Exception)
+            console.error(exception);
+    }
+    static logWarning(message) {
+        if (this._logType >= LogType.Warning)
+            console.warn(message);
+    }
+    static logError(message) {
+        if (this._logType >= LogType.Error)
+            console.error(message);
+    }
+}

package/dist/runtime/networking/AuthenticateStatus.js

@@ -0,0 +1,14 @@
+export class AuthenticateStatus {
+    getAuthToken() {
+        return this.authToken;
+    }
+    setAuthToken(authToken) {
+        this.authToken = authToken;
+    }
+    getUserId() {
+        return this.userId;
+    }
+    setUserId(userId) {
+        this.userId = userId;
+    }
+}

package/dist/runtime/networking/IPeer.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/networking/NetworkingPeer.d.ts

@@ -10,7 +10,7 @@ import { RequestType } from "./../constant/enumType/RequestType";
 import { RequestRole } from "./../constant/enumType/RequestRole";
 import { GetAuthInfoResponse } from "./../entity/response/GetAuthInfoResponse";
 import { UploadFileResponse } from "./../entity/response/UploadFileResponse";
-import { HealthCheckResponse } from "../entity/response/HealthCheckResponse";
+import { HealthCheckResponse } from "./../entity/response/HealthCheckResponse";
 export declare class NetworkingPeer {
     static readonly SYNC_TS: string;
     static readonly GET_AUTH_INFO: string;