nv-facutil-slct-ta 1.1.3 → 1.1.5

package/index.js

@@ -8,6 +8,80 @@ const tcate = (o)=> {
     return 'other'
 }
 
+// 判断是否为有符号整数类型（包括大整数）
+const is_signed_int_cls = (TypedArrayClass) => {
+    return (
+        TypedArrayClass === Int8Array || 
+        TypedArrayClass === Int16Array || 
+        TypedArrayClass === Int32Array || 
+        TypedArrayClass === BigInt64Array  // 有符号大整数（64位）
+    );
+};
+
+// 判断是否为无符号整数类型（包括大整数和 clamped 类型）
+const is_unsigned_int_cls = (TypedArrayClass) => {
+    return (
+        TypedArrayClass === Uint8Array ||          // 无符号8位整数
+        TypedArrayClass === Uint8ClampedArray ||   // 无符号8位钳位整数（特殊无符号）
+        TypedArrayClass === Uint16Array ||         // 无符号16位整数
+        TypedArrayClass === Uint32Array ||         // 无符号32位整数
+        TypedArrayClass === BigUint64Array         // 无符号大整数（64位）
+    );
+};
+
+function get_display_name_prefix(TypedArrayClass) {
+    const byteSize = TypedArrayClass.BYTES_PER_ELEMENT;
+    // 判断是否为有符号类型（需要添加"Half"前缀）
+
+
+    // 基础名称映射
+    let baseName;
+    if (byteSize === 1) {
+        baseName = "Tiny";
+    } else if (byteSize === 2) {
+        baseName = "Small";
+    } else if (byteSize === 4) {
+        baseName = "Normal";
+    } else {
+        baseName = "Large";
+    }
+
+    // 有符号类型添加"Half"前缀
+    return is_signed_int_cls(TypedArrayClass) ? `Half${baseName}` : baseName;
+}
+
+const DUMP_ONE_BYTE_TYPE_MP = {
+    0:   Uint8Array,
+    1:   Uint16Array,
+    2:   Uint32Array,
+    3:   BigUint64Array, // js version NOT supported
+    //-----------------------------------------------------
+    4:   Int8Array,
+    5:   Int16Array,
+    6:   Int32Array,
+    7:   BigInt64Array, // js version NOT supported
+    255: Float64Array,
+}
+
+const CLS2BYT = new Map([
+    [Uint8Array,0],
+    [Uint16Array,1],
+    [Uint32Array,2],
+    [BigUint64Array,3],
+    //-----------------------------------------------------------
+    [Int8Array,4],
+    [Int16Array,5],
+    [Int32Array,6],
+    [BigInt64Array,7],
+    [Float64Array,255]
+]);
+
+
+
+
+
+
+
 
 
 ////
@@ -137,24 +211,44 @@ function to_u8avw(ta) {
 function cp_rtrn_u8a(ta) {return to_u8avw(ta).slice(0)}
 
 
-
-
-function calc_max_incr_cnt(Cls,curr_cnt) {
-    if(Cls === Float64Array) {
-        return 2**53 - curr_cnt;
-    } else if(Cls === BigUint64Array) { //JS version NOT supported
-        var limit = 2n** (8n* BigInt(Cls.BYTES_PER_ELEMENT));
-        return limit - BigInt(curr_cnt);    
-    } else {
-        var limit = 2** (8*Cls.BYTES_PER_ELEMENT);
-        return limit - curr_cnt;
+function calc_max_incr_cnt(Cls, curr_cnt) {
+    // 处理 Float64Array
+    if (Cls === Float64Array) {
+        return Number.MAX_SAFE_INTEGER - curr_cnt; // 2^53-1 是最大安全整数
+    } 
+    // 处理 BigUint64Array
+    else if (Cls === BigUint64Array) {
+        const n = 8n * BigInt(Cls.BYTES_PER_ELEMENT); // 64
+        const limit = 2n ** n; // 2^64
+        return limit - 1n-  BigInt(curr_cnt);
+    } 
+    // 处理有符号整数类型
+    else if (Cls === Int8Array) {
+        return 127 - curr_cnt; // 2^7 - 1
+    } 
+    else if (Cls === Int16Array) {
+        return 32767 - curr_cnt; // 2^15 - 1
+    } 
+    else if (Cls === Int32Array) {
+        return 2147483647 - curr_cnt; // 2^31 - 1
+    } 
+    // 处理无符号整数类型（使用原逻辑）
+    else {
+        // 计算无符号整数最大值：2^(8*字节数) - 1
+        const n = 8 * Cls.BYTES_PER_ELEMENT;
+        const limit = 2 ** n; // 2^8, 2^16, 2^32
+        return limit -1 - curr_cnt;
     }
 }
 
+
 function get_ta_cls_with_max_cnt(cnt,using_u64_when_gt_safe_f64_int=false) {
     cnt = BigInt(cnt);
-    if(cnt<=255n)                { return Uint8Array;
+    if(cnt <= 127n)              { return Int8Array;          
+    } else if(cnt<=255n)         { return Uint8Array;
+    } else if(cnt<=32767n)       { return Int16Array;
     } else if(cnt<=65535n)       { return Uint16Array;
+    } else if(cnt<=2147483647n)  { return Int32Array;
     } else if(cnt<=(2n**32n-1n)) { return Uint32Array;
     } else if(cnt<=(2n**53n-1n)) {
         return using_u64_when_gt_safe_f64_int?BigUint64Array:Float64Array;
@@ -163,38 +257,21 @@ function get_ta_cls_with_max_cnt(cnt,using_u64_when_gt_safe_f64_int=false) {
     }
 }
 
-const DUMP_ONE_BYTE_TYPE_MP = {
-    0:   Uint8Array,
-    1:   Uint16Array,
-    2:   Uint32Array,
-    3:   BigUint64Array, // js version NOT supported
-    255: Float64Array,
-}
-
-const CLS2BYT = new Map([
-    [Uint8Array,0],
-    [Uint16Array,1],
-    [Uint32Array,2],
-    [BigUint64Array,3],
-    [Float64Array,255]
-]);
 
 function get_byt_from_cls(Cls) {
     return CLS2BYT.get(Cls)
 }
-
-function get_cls_from_dump_fst_byte(byt) {
+function get_cls_from_byt(byt) {
     return DUMP_ONE_BYTE_TYPE_MP[byt]??Float64Array
 }
-
-function get_fst_byte_for_dump(Cls) {
-    if(Cls === Uint8Array)  return 0;
-    if(Cls === Uint16Array) return 1;
-    if(Cls === Uint32Array) return 2;
-    if(Cls === BigUint64Array) return 3; // js version NOT supported 
-    return 255;
+function get_fst_byte_for_dump(Cls) { //旧代码兼容
+    return CLS2BYT.get(Cls)
+}
+function get_cls_from_dump_fst_byte(byt) { //旧代码兼容
+    return DUMP_ONE_BYTE_TYPE_MP[byt]??Float64Array
 }
 
+
 function set_fst_byte_for_dump(ta) {
     var u8a = new Uint8Array(ta.buffer,ta.byteOffset,1);
     u8a[0] = get_fst_byte_for_dump(ta.constructor);
@@ -211,14 +288,6 @@ function get_nth_byte(ta,I) {
 }
 
 
-function  get_display_name_prefix(TypedArrayClass) {
-    if(TypedArrayClass.BYTES_PER_ELEMENT === 1) {return "Tiny"}
-    if(TypedArrayClass.BYTES_PER_ELEMENT === 2) {return "Small"}
-    if(TypedArrayClass.BYTES_PER_ELEMENT === 4) {return "Normal"}
-    return "Large";
-}
-
-
 //------------------------------------------------------------------------------
 
 
@@ -484,8 +553,48 @@ const write_dv_with_cls = (dv, Cls, offset, value, little_endian = true) => {
 };
 
 
+const fmt_underlying = (underlying)=>{
+    if(underlying === null || underlying === undefined)               {
+        return {
+            src:null,
+            offset:0
+        }
+    } else if(is_ablike(underlying)) {
+        return {
+           src:underlying,
+           offset:0,
+        }
+    } else {
+        return {
+           src:underlying.src??null,
+           offset:underlying.offset??0
+        }
+    }
+}
+
+//inline 为true 时,会自动忽略 .ptr 此时ptr自动计算
+const fmt_data = (data)=>{
+    if(data === null || data === true || data === undefined || Boolean(data?.inline) === true) {
+        return {
+            ptr:   undefined, //自动计算
+            inline:true,
+        }
+    } else if(typeof(data) === "number" || typeof(data)==="bigint") { //只填写 ptr 后视作非inline
+        return {
+            ptr:   parseInt(Number(data)),
+            inline:false,
+        }
+    } else {
+        return {
+             ptr: parseInt(Number(data.ptr??0)),
+             inline: Boolean(data.inline)
+        }
+    }
+}
+
+
 module.exports = {
-    tcate,
+    tcate, is_signed_int_cls , is_unsigned_int_cls,
     ////
     check_sz_and_algn,
     calc_algn_si,
@@ -493,6 +602,7 @@ module.exports = {
     calc_max_incr_cnt,
     get_ta_cls_with_max_cnt,
     get_byt_from_cls,
+    get_cls_from_byt,
     get_cls_from_dump_fst_byte,
     get_fst_byte_for_dump,
     set_fst_byte_for_dump,
@@ -539,4 +649,7 @@ module.exports = {
     min_tacls,max_tacls,
     read_dv_with_cls,
     write_dv_with_cls,
+    ////
+    fmt_underlying,
+    fmt_data,
 }   

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nv-facutil-slct-ta",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"