nv-constexpr-simple-codify 1.0.0

package/README.md

@@ -0,0 +1,121 @@
+# nv-constexpr-simple-codify
+
+A slow but precise object-to-code converter designed specifically for **macro compilation tools** and compile-time code generation.
+
+Its a readable But less-suportted-type version of nv-buf-data-to-code.
+
+
+
+## ⚠️ Important Notice
+
+This library is **NOT optimized for performance**. It is intentionally slow because it generates executable JavaScript code rather than serialized data. Use it only when you need:
+
+- Compile-time constant evaluation
+- Macro expansion systems
+- Generating code from configuration objects
+- Static analysis tools that output executable code
+
+Do NOT use this for runtime serialization or high-frequency operations.
+
+## Supported Leaf Types (1:1 C++ Mapping)
+
+Every supported leaf type has a direct 1:1 counterpart in C++. This makes the output ideal for generating C++ constexpr-compatible code.
+
+| JavaScript Type | C++ Equivalent | Output Format | Example |
+|-----------------|----------------|---------------|---------|
+| `undefined` | Special NaN sentinel | `undefined` | `undefined` *(see note below)* |
+| `null` | `std::nullptr_t` / `NULL` | `null` | `null` |
+| `boolean` | `bool` | `true` / `false` | `true` |
+| `string` | `std::string` / `const char*` | JSON-stringified | `"hello\nworld"` |
+| `number` | `double` / `float` / `int` | String representation | `123.45` |
+| `bigint` | `std::int64_t` / `std::uint64_t` | `n` suffix notation | `9007199254740993n` |
+| `ArrayBuffer` | `std::array<uint8_t>` (raw buffer) | IIFE with byte array | `(()=>{ var ab = new ArrayBuffer(8);(new Uint8Array(ab)).set([0,32,64,96,128,160,192,224]);return(ab);})()` |
+| `SharedArrayBuffer` | `std::shared_ptr<std::array<uint8_t>>` | IIFE with byte array | Same format as ArrayBuffer |
+| `DataView` | `struct` with manual byte access | `new DataView(...)` | `(new DataView((new Uint8Array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])).buffer))` |
+| `Uint8Array` | `std::array<uint8_t>` | `new Uint8Array([...])` | `(new Uint8Array([1,2,255]))` |
+| `Uint8ClampedArray` | `std::array<uint8_t>` (clamped) | `new Uint8ClampedArray([...])` | `(new Uint8ClampedArray([0,128,255]))` |
+| `Int8Array` | `std::array<int8_t>` | `new Int8Array([...])` | `(new Int8Array([-128,0,127]))` |
+| `Uint16Array` | `std::array<uint16_t>` | `new Uint16Array([...])` | `(new Uint16Array([1,65535]))` |
+| `Int16Array` | `std::array<int16_t>` | `new Int16Array([...])` | `(new Int16Array([-32768,32767]))` |
+| `Uint32Array` | `std::array<uint32_t>` | `new Uint32Array([...])` | `(new Uint32Array([1,4294967295]))` |
+| `Int32Array` | `std::array<int32_t>` | `new Int32Array([...])` | `(new Int32Array([-2147483648,2147483647]))` |
+| `Float32Array` | `std::array<float>` | `new Float32Array([...])` | `(new Float32Array([1.5,-2.5,0]))` |
+| `Float64Array` | `std::array<double>` | `new Float64Array([...])` | `(new Float64Array([1.7976931348623157e+308,-Infinity,NaN]))` |
+| `BigUint64Array` | `std::array<uint64_t>` | `new BigUint64Array([...])` | `(new BigUint64Array([18446744073709551615n]))` |
+| `BigInt64Array` | `std::array<int64_t>` | `new BigInt64Array([...])` | `(new BigInt64Array([-9223372036854775808n]))` |
+| `Date` | `std::chrono::system_clock::time_point` | `new Date(timestamp)` | `(new Date(1705321845123))` |
+| `RegExp` | `do NOT use std::regex` | `/pattern/flags` | `/test\/pattern/gi` |
+
+### Special Note on `undefined`
+
+`undefined` does not have a direct C++ equivalent. In C++ code generation scenarios, it should be replaced with a **special NaN sentinel value** (nan is a range)`) or a designated invalid marker. The codifier outputs `undefined` as-is for transparency, leaving the C++ mapping decision to the downstream compiler logic.
+
+`RegExp` use a third-party library that supports compile-time regex (do NOT use std::regex)
+
+
+## Container Support
+
+**Only two container types are supported:**
+
+1. **Arrays `[]`** - Indexed collections
+2. **Plain Objects `{}`** - String-keyed collections
+
+Nested structures are fully supported (arrays within objects, objects within arrays, etc.).
+
+**Unsupported containers:**
+- `Map` - Not supported
+- `Set` - Not supported
+- `WeakMap` - Not supported
+- `WeakSet` - Not supported
+- `Array-like objects` - Not supported
+- Custom classes/constructors - Not supported
+
+## API
+
+### `codify(obj, space = 0)`
+
+Main entry point. Converts an object to a code string.
+
+- `obj` - The object to convert (must contain only supported types)
+- `space` - Optional indentation:
+  - `0` or `""` (empty string) - No indentation, compact output
+  - `number` - Number of spaces per level
+  - `string` - Custom indentation string
+
+Returns: `string` - Executable JavaScript code
+
+### Internal Functions
+
+For advanced use cases, the following internal functions are exported:
+
+- `_codify_leaf(o)` - Convert a single leaf value
+- `_codify_ary(ary, depth, space, recv, is_lst, key)` - Process arrays
+- `_codify_dict(dict, depth, space, recv, is_lst, key)` - Process objects
+- `_codify_typed_ary(o, Cls)` - Convert TypedArrays/DataView
+- `_codify_ab(o, ClsName)` - Convert ArrayBuffer/SharedArrayBuffer
+
+## Use Cases
+
+This tool is designed for:
+
+1. **Macro Compilation Systems** - Generate code at compile time
+2. **Static Configuration** - Convert config objects to constants
+3. **Code Generation Tools** - Build source code from templates
+4. **Build-time Optimizations** - Pre-compute values during build
+5. **Domain-Specific Languages** - Implement DSL compilers
+
+## Performance Note
+
+This library prioritizes **code fidelity** over **execution speed**. It is significantly slower than `JSON.stringify` because:
+
+- It generates executable code, not just data
+- It handles many more data types
+- It performs recursive processing with string building
+- It's not optimized for large datasets
+
+Do NOT use it For runtime serialization.
+
+## License
+Any
+
+

package/TEST/tst.js

@@ -0,0 +1,156 @@
+const codify = require('../index');
+
+var code0 = codify({
+        undef: undefined,
+        nil: null,
+        boolTrue: true,
+        boolFalse: false,
+        str: "hello\"world\n\t\\test",
+        num: 12345.6789,
+        bigint: 9007199254740993n,
+        // TypedArrays
+        uint8: new Uint8Array([1, 2, 255]),
+        uint8c: new Uint8ClampedArray([0, 128, 255]),
+        int8: new Int8Array([-128, 0, 127]),
+        uint16: new Uint16Array([1, 65535]),
+        int16: new Int16Array([-32768, 32767]),
+        uint32: new Uint32Array([1, 4294967295]),
+        int32: new Int32Array([-2147483648, 2147483647]),
+        float32: new Float32Array([1.5, -2.5, 0.0]),
+        float64: new Float64Array([1.7976931348623157e+308, -Infinity, NaN]),
+        biguint64: new BigUint64Array([18446744073709551615n]),
+        bigint64: new BigInt64Array([-9223372036854775808n]),
+
+        // ArrayBuffers 和 SharedArrayBuffer
+        arrBuf: new ArrayBuffer(8),
+        //sharedArrBuf: new SharedArrayBuffer ? new SharedArrayBuffer(8) : null,
+
+        // DateView 和 Date
+        dateView: new DataView(new ArrayBuffer(16)),
+        date: new Date('2024-01-15T12:30:45.123Z'),
+
+        // RegExp
+        regex: /test\/pattern/gi,
+}, 4);
+console.log(code0);
+
+var code1 = codify([
+        undefined,
+         null,
+        true,
+        false,
+        "hello\"world\n\t\\test",
+        12345.6789,
+         9007199254740993n,
+        // TypedArrays
+        new Uint8Array([1, 2, 255]),
+        new Uint8ClampedArray([0, 128, 255]),
+        new Int8Array([-128, 0, 127]),
+        new Uint16Array([1, 65535]),
+        new Int16Array([-32768, 32767]),
+        new Uint32Array([1, 4294967295]),
+        new Int32Array([-2147483648, 2147483647]),
+        new Float32Array([1.5, -2.5, 0.0]),
+        new Float64Array([1.7976931348623157e+308, -Infinity, NaN]),
+        new BigUint64Array([18446744073709551615n]),
+        new BigInt64Array([-9223372036854775808n]),
+
+        // ArrayBuffers 和 SharedArrayBuffer
+        new ArrayBuffer(8),
+        //sharedArrBuf: new SharedArrayBuffer ? new SharedArrayBuffer(8) : null,
+
+        // DateView 和 Date
+         new DataView(new ArrayBuffer(16)),
+        new Date('2024-01-15T12:30:45.123Z'),
+
+        // RegExp
+        /test\/pattern/gi,
+], 4);
+console.log(code1);
+
+console.log(codify({
+                    level3: 789n,
+                    arr: [1n, 2n, 3n]
+
+},2));
+
+// ============ 构造复杂测试对象 ============
+function createComplexTestObject() {
+    return {
+        // 基础类型
+        undef: undefined,
+        nil: null,
+        boolTrue: true,
+        boolFalse: false,
+        str: "hello\"world\n\t\\test",
+        num: 12345.6789,
+        bigint: 9007199254740993n,
+
+        // TypedArrays
+        uint8: new Uint8Array([1, 2, 255]),
+        uint8c: new Uint8ClampedArray([0, 128, 255]),
+        int8: new Int8Array([-128, 0, 127]),
+        uint16: new Uint16Array([1, 65535]),
+        int16: new Int16Array([-32768, 32767]),
+        uint32: new Uint32Array([1, 4294967295]),
+        int32: new Int32Array([-2147483648, 2147483647]),
+        float32: new Float32Array([1.5, -2.5, 0.0]),
+        float64: new Float64Array([1.7976931348623157e+308, -Infinity, NaN]),
+        biguint64: new BigUint64Array([18446744073709551615n]),
+        bigint64: new BigInt64Array([-9223372036854775808n]),
+
+        // ArrayBuffers 和 SharedArrayBuffer
+        arrBuf: new ArrayBuffer(8),
+        //sharedArrBuf: new SharedArrayBuffer ? new SharedArrayBuffer(8) : null,
+
+        // DateView 和 Date
+        dateView: new DataView(new ArrayBuffer(16)),
+        date: new Date('2024-01-15T12:30:45.123Z'),
+
+        // RegExp
+        regex: /test\/pattern/gi,
+
+        // 嵌套数组
+        nestedArr: [
+            1,
+            2n,
+            "string",
+            true,
+            [3, 4n, [5, 6n]],
+            { nested: "object" }
+        ],
+
+        // 嵌套对象
+        nestedObj: {
+            level1: {
+                level2: {
+                    level3: 789n,
+                    arr: [1n, 2n, 3n]
+                }
+            }
+        },
+
+        // 数组中包含对象
+        arrWithObjs: [
+            { id: 1, val: 10n },
+            { id: 2, val: 20n }
+        ]
+    };
+}
+
+// ============ 填充 ArrayBuffer 数据 ============
+function fillArrayBuffer(buf) {
+    const u8 = new Uint8Array(buf);
+    for (let i = 0; i < u8.length; i++) {
+        u8[i] = i * 32;
+    }
+    return buf;
+}
+
+const testObj = createComplexTestObject();
+fillArrayBuffer(testObj.arrBuf);
+console.dir(testObj,{depth:null});
+
+const generatedCode = codify(testObj, 2);
+console.log(generatedCode);
+

package/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Codify - A slow but precise object to code converter for macro compilation tools
+ * 
+ * This module converts JavaScript objects into executable code strings.
+ * It is designed for compile-time code generation, not runtime serialization.
+ * 
+ * @example
+ * const code = codify({ foo: 1n, bar: [1, 2, 3] }, 2);
+ * // Returns formatted code string that can be eval'd
+ */
+declare function codify(obj: unknown, space?: number | string): string;
+
+declare namespace codify {
+    /**
+     * Convert a TypedArray or DataView to a code representation
+     * @param o - The typed array or DataView instance
+     * @param Cls - The constructor class (e.g., Uint8Array, Int16Array)
+     * @returns Code string representing the array contents
+     */
+    function _codify_typed_ary(o: TypedArray | DataView, Cls: new (buffer: ArrayBuffer) => TypedArray): string;
+
+    /**
+     * Convert an ArrayBuffer or SharedArrayBuffer to executable code
+     * @param o - The buffer instance
+     * @param ClsName - Class name as string ("ArrayBuffer" or "SharedArrayBuffer")
+     * @returns Immediately invoked function expression that recreates the buffer
+     */
+    function _codify_ab(o: ArrayBuffer | SharedArrayBuffer, ClsName: string): string;
+
+    /**
+     * Convert leaf nodes (non-container values) to code representation
+     * @param o - Any leaf node value
+     * @returns Code string or undefined if value needs recursive processing
+     */
+    function _codify_leaf(o: unknown): string | undefined;
+
+    /**
+     * Process arrays recursively and build code string
+     * @param ary - Array to process
+     * @param depth - Current indentation depth
+     * @param space - Indentation string
+     * @param recv - Accumulated result string
+     * @param is_lst - Whether this is the last element in parent container
+     * @param key - Key name if processing as object property
+     * @returns Updated result string
+     */
+    function _codify_ary(
+        ary: unknown[],
+        depth: number,
+        space: string,
+        recv: string,
+        is_lst: boolean,
+        key?: string | undefined
+    ): string;
+
+    /**
+     * Process plain objects recursively and build code string
+     * @param dict - Plain object to process
+     * @param depth - Current indentation depth
+     * @param space - Indentation string
+     * @param recv - Accumulated result string
+     * @param is_lst - Whether this is the last element in parent container
+     * @param key - Key name if processing as nested property
+     * @returns Updated result string
+     */
+    function _codify_dict(
+        dict: Record<string, unknown>,
+        depth: number,
+        space: string,
+        recv: string,
+        is_lst: boolean,
+        key?: string | undefined
+    ): string;
+
+    /**
+     * Internal recursive codify implementation
+     * @param obj - Object to convert
+     * @param space - Indentation string
+     * @returns Generated code string
+     */
+    function _codify(obj: unknown, space: string): string;
+}
+
+export = codify;

package/index.js

@@ -0,0 +1,210 @@
+const _codify_typed_ary = (o,Cls)=>{
+    var si = o.byteOffset;
+    var ei = si + o.byteLength;
+    var ta = new Cls(o.buffer);
+    var subvw =    ta.subarray(si/Cls.BYTES_PER_ELEMENT,ei/Cls.BYTES_PER_ELEMENT);
+    var s ="[";
+    for(var i=0;i< subvw.length-1;++i) {
+        if(typeof(subvw[i]) === "bigint") {
+            s += subvw[i] + "n" + ","
+        } else {
+            s += subvw[i] + ","
+        }
+    }
+    if(subvw.length ===0) {
+    } else {
+        if(typeof(subvw[subvw.length-1]) === "bigint") {
+            s += subvw[subvw.length-1] + "n";
+        } else {
+            s += subvw[subvw.length-1]
+        }
+    }
+    s += "]"
+    return(s)
+}
+
+const _codify_ab = (o,ClsName) => {
+    var u8a        = new Uint8Array(o);
+    var u8a_str    = JSON.stringify(Array.from(u8a));
+    var ab_str     ;
+    if(o.resizable) {
+        ab_str = `new ${ClsName}(${o.byteLength},{maxByteLength:${o.maxByteLength}})`;
+    } else {
+        ab_str = `new ${ClsName}(${o.byteLength})`
+    }
+    return(`(()=>{ var ab = ${ab_str};(new Uint8Array(ab)).set(${u8a_str});return(ab);})()`);
+}
+
+const _codify_leaf = (o)=>{
+    if(o instanceof ArrayBuffer)                                   { 
+        return (_codify_ab(o,"ArrayBuffer"));
+    } else if(o?.constructor?.name === 'SharedArrayBuffer')        { 
+        return (_codify_ab(o,"SharedArrayBuffer"));
+    } else if(o instanceof DataView){
+        return(`(new DataView((new Uint8Array(${_codify_typed_ary(o,Uint8Array)})).buffer))`);
+    } else if(o instanceof Uint8Array){ 
+        return(`(new Uint8Array(${_codify_typed_ary(o,Uint8Array)}))`);
+    } else if(o instanceof Uint8ClampedArray)    {
+        return(`(new Uint8ClampedArray(${_codify_typed_ary(o,Uint8ClampedArray)}))`);
+    } else if(o instanceof Int8Array) {
+        return(`(new Int8Array(${_codify_typed_ary(o,Int8Array)}))`);
+    } else if(o instanceof Uint16Array) {
+        return(`(new Uint16Array(${_codify_typed_ary(o,Uint16Array)}))`);
+    } else if(o instanceof Int16Array)  {
+        return(`(new Int16Array(${_codify_typed_ary(o,Int16Array)}))`);
+    } else if (o instanceof Uint32Array) {
+        return(`(new Uint32Array(${_codify_typed_ary(o,Uint32Array)}))`);
+    } else if (o instanceof Int32Array) {
+        return(`(new Int32Array(${_codify_typed_ary(o,Int32Array)}))`);
+    } else if(o instanceof BigUint64Array) {
+        return(`(new BigUint64Array(${_codify_typed_ary(o,BigUint64Array)}))`);
+    } else if(o instanceof BigInt64Array) {
+        return(`(new BigInt64Array(${_codify_typed_ary(o,BigInt64Array)}))`);
+    } else if(o instanceof Float32Array) {
+        return(`(new Float32Array(${_codify_typed_ary(o,Float32Array)}))`);
+    } else if(o instanceof Float64Array) {
+        return(`(new Float64Array(${_codify_typed_ary(o,Float64Array)}))`);
+    } else if(o instanceof Date) {
+        var mts = o.getTime();
+        return(`(new Date(${String(mts)}))`);
+    } else if(o instanceof RegExp) {
+        var source = o.source;
+        var flags =  o.flags;
+        return `/${source}/${flags}`
+    } else if(o === undefined){
+        return "undefined"
+    } else if(o === null)     {
+        return "null";
+    } else {
+        var tnm = typeof(o);
+        if(tnm === "string") {
+            return JSON.stringify(o)
+        } else if(tnm === "number") {
+            return String(o)
+        } else if(tnm === "boolean") {
+            return o?"true":"false"
+        } else if(tnm === "bigint"){
+            return String(o) + "n";
+        } else {
+	    return undefined
+	}
+    }
+}
+
+
+function   _codify_ary(ary,depth,space,recv,is_lst,key) {
+    var indent_str = space.repeat(depth);
+    var nl         = space===""? "":"\n";
+    key = key===undefined?"":(JSON.stringify(key) + " : ");
+    if(ary.length === 0) {
+        recv += indent_str + key + "[]" + (is_lst?"":",") + nl; 
+    } else {
+	recv += indent_str + key+"[" + nl;
+        for(var i=0; i<ary.length-1;++i) {
+            var v = ary[i];
+            if(Array.isArray(v))  {
+	        recv = _codify_ary(v,depth+1,space,recv,false,undefined)
+            } else {
+                var cv =  _codify_leaf(v);
+		if(cv===undefined) {
+                    recv = _codify_dict(v,depth+1,space,recv,false,undefined)
+	        } else {
+                    var child_indent_str = space.repeat(depth+1);
+                    recv += child_indent_str + cv + "," + nl; 
+                }
+	    }
+        }
+        ////
+        {
+            var v = ary[ary.length-1];
+            if(Array.isArray(v))  {
+                recv = _codify_ary(v,depth+1,space,recv,true,undefined)
+            } else {
+		var cv =  _codify_leaf(v);
+		if(cv===undefined) {
+                    recv = _codify_dict(v,depth+1,space,recv,true,undefined)
+                } else {
+                    var child_indent_str = space.repeat(depth+1);
+                    recv += child_indent_str + cv +  nl;
+                }
+	    }
+        }
+	recv += indent_str + "]" + (is_lst?"":",") + nl;
+    }
+    return recv;
+}
+
+function _codify_dict(dict,depth,space,recv,is_lst,key) {
+    var indent_str = space.repeat(depth);
+    var nl         = space===""? "":"\n";
+    key = key===undefined?"":(JSON.stringify(key) + " : ");
+    var ks = Object.keys(dict);
+    if(ks.length === 0) {
+        recv += indent_str + key + "{}" + (is_lst?"":",") + nl;
+    } else {
+        recv += indent_str + key+"{" + nl;    
+        for(var i=0;i<ks.length-1;++i) {
+            var v = dict[ks[i]];
+            if(Array.isArray(v))  {
+                recv = _codify_ary(v,depth+1,space,recv,false,ks[i])
+            } else {
+		var cv =  _codify_leaf(v);
+		if(cv === undefined) {
+                    recv = _codify_dict(v,depth+1,space,recv,false,ks[i])
+                } else {
+                    var child_indent_str = space.repeat(depth+1);
+                    recv += child_indent_str +  JSON.stringify(ks[i]) + " : "  + cv + "," + nl;
+		}
+            }
+        }
+        ////
+        {
+	    var k = ks[ks.length-1];
+            var v = dict[k];
+            if(Array.isArray(v))  {
+                recv = _codify_ary(v,depth+1,space,recv,true,k)
+            } else {
+		var cv =  _codify_leaf(v);
+		if(cv === undefined) {
+                    recv = _codify_dict(v,depth+1,space,recv,true,k)
+                } else {
+                    var child_indent_str = space.repeat(depth+1);
+                    recv += child_indent_str +  JSON.stringify(ks[ks.length-1]) + " : "  + cv + nl;
+		}
+            }
+        }             
+	var end = indent_str + "}" + (is_lst?"":",") + nl;
+        recv += end;
+    }       
+    return recv;
+}
+
+function _codify(obj,space) {
+    if(Array.isArray(obj)) {
+        return _codify_ary(obj,0,space,"",true,undefined);
+    } else {
+	var cv =  _codify_leaf(obj);
+	if(cv === undefined) {
+            return _codify_dict(obj,0,space,"",true,undefined);
+        } else {
+            return _codify_leaf(obj)
+        }
+    }
+}
+
+function codify (obj,space=0){
+    if(typeof(space)==="number") {space = " ".repeat(space)} else {space = String(space)}
+    return _codify(obj,space); 
+}
+
+
+
+module.exports = codify;
+module.exports._codify_typed_ary   = _codify_typed_ary;
+module.exports._codify_ab          = _codify_ab;
+module.exports._codify_leaf        = _codify_leaf;
+module.exports._codify_ary         = _codify_ary;
+module.exports._codify_dict        = _codify_dict;
+module.exports._codify             = _codify;
+
+

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "nv-constexpr-simple-codify",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "A slow but precise object-to-code converter designed specifically for **macro compilation tools** and compile-time code generation.",
+  "types": "./index.d.ts"
+}