@arkadia/data 0.1.7 → 0.1.9

package/tests/00.primitive.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest';
-import { encode, decode, MetaInfo, parse } from '../src/index';
+import { describe, expect, it } from 'vitest';
+import { decode, encode } from '../src/index';
 import { assertRoundtrip } from './utils';
 
 // ==================================================================================
@@ -7,102 +7,128 @@ import { assertRoundtrip } from './utils';
 // ==================================================================================
 
 describe('AK Data Primitives', () => {
-    it('should encode raw object', () => {
-        const input = { foo: "bar" };
-        const expected = '<foo:string>("bar")';
-        assertRoundtrip(input, expected);
-    });
+  it('should encode raw object', () => {
+    const input = { foo: 'bar' };
+    const expected = '<foo:string>("bar")';
+    assertRoundtrip(input, expected);
+  });
 
-    it.each([
-        // [Input Text, Expected Value, Expected Encoded Output]
-        ["123", 123, "<number>123"],
-        ["-50", -50, "<number>-50"],
-        ['"hello"', "hello", '<string>"hello"'],
-        ['"hello world"', "hello world", '<string>"hello world"'],
-        ["true", true, "<bool>true"],
-        ["false", false, "<bool>false"],
-        ["null", null, "<null>null"],
-    ])('should decode and encode primitive: %s', (text, expectedVal, expectedEnc) => {
-        // 1. DECODE
-        // We pass an options object (assuming the latest signature: decode(text, { debug: false }))
-        const res = decode(text, { debug: false });
-        
-        expect(res.errors, `Parsing failed for input: ${text}`).toHaveLength(0);
-        expect(res.node.value).toBe(expectedVal);
-        expect(res.node.isPrimitive).toBe(true);
-
-        // 2. ENCODE
-        const encodedStr = encode(res.node, { colorize: false, compact: true }).trim();
-        
-        expect(encodedStr).toBe(expectedEnc);
-    });
+  it.each([
+    // [Input Text, Expected Value, Expected Encoded Output]
+    ['123', 123, '<number>123'],
+    ['-50', -50, '<number>-50'],
+    ['"hello"', 'hello', '<string>"hello"'],
+    ['"hello world"', 'hello world', '<string>"hello world"'],
+    ['true', true, '<bool>true'],
+    ['false', false, '<bool>false'],
+    ['null', null, '<null>null'],
+  ])('should decode and encode primitive: %s', (text, expectedVal, expectedEnc) => {
+    // 1. DECODE
+    // We pass an options object (assuming the latest signature: decode(text, { debug: false }))
+    const res = decode(text, { debug: false });
 
-    it('should decode floats', () => {
-        const cases: [string, number][] = [
-            ["12.34", 12.34],
-            ["-0.005", -0.005],
-            ["0.0", 0.0]
-        ];
-
-        cases.forEach(([text, expected]) => {
-            const res = decode(text);
-            expect(res.errors).toHaveLength(0);
-            expect(res.node.value).toBe(expected);
-            expect(typeof res.node.value).toBe('number'); 
-        });
-    });
+    expect(res.errors, `Parsing failed for input: ${text}`).toHaveLength(0);
+    expect(res.node.value).toBe(expectedVal);
+    expect(res.node.isPrimitive).toBe(true);
 
-    it('should decode named record', () => {
-        const text = '{id: 1, name: "Test"}';
-        const res = decode(text, { debug: false });
-        expect(res.errors).toHaveLength(0);
-        
-        const node = res.node;
-
-        expect(node.isRecord).toBe(true);
-        expect(node.fields["id"].value).toBe(1);
-        expect(node.fields["name"].value).toBe("Test");
-
-        assertRoundtrip(
-            node, 
-            '<id:number,name:string>(1,"Test")', 
-            false
-        );
-    });
+    // 2. ENCODE
+    const encodedStr = encode(res.node, { colorize: false, compact: true }).trim();
 
-    it('should decode positional record', () => {
-        const text = '(10, "Alice")';
-        const res = decode(text, { debug: false });
-        expect(res.errors).toHaveLength(0);
-        
-        const node = res.node;
-
-        expect(node.isRecord).toBe(true);
-        
-        // Verify if the parser mapped positional fields to _0, _1
-        expect(node.fields["_0"].value).toBe(10);
-        expect(node.fields["_1"].value).toBe("Alice");
-
-        assertRoundtrip(
-            node, 
-            '<_0:number,_1:string>(10,"Alice")',
-            false
-        );
-    });
+    expect(encodedStr).toBe(expectedEnc);
+  });
+
+  it('should decode floats', () => {
+    const cases: [string, number][] = [
+      ['12.34', 12.34],
+      ['-0.005', -0.005],
+      ['0.0', 0.0],
+    ];
 
-    it('should decode raw string', () => {
-        const text = "{color: red, status: active}";
-        const res = decode(text, { debug: false });
-        expect(res.errors).toHaveLength(0);
-        
-        const node = res.node;
-        expect(node.fields["color"].value).toBe("red");
-        expect(node.fields["status"].value).toBe("active");
-
-        assertRoundtrip(
-            node, 
-            '<color:string,status:string>("red","active")',
-            false
-        );
+    cases.forEach(([text, expected]) => {
+      const res = decode(text);
+      expect(res.errors).toHaveLength(0);
+      expect(res.node.value).toBe(expected);
+      expect(typeof res.node.value).toBe('number');
     });
-});
+  });
+
+  it('should decode named record', () => {
+    const text = '{id: 1, name: "Test"}';
+    const res = decode(text, { debug: false });
+    expect(res.errors).toHaveLength(0);
+
+    const node = res.node;
+
+    expect(node.isRecord).toBe(true);
+    expect(node.fields['id'].value).toBe(1);
+    expect(node.fields['name'].value).toBe('Test');
+
+    assertRoundtrip(node, '<id:number,name:string>(1,"Test")', false);
+  });
+
+  it('should decode positional record', () => {
+    const text = '(10, "Alice")';
+    const res = decode(text, { debug: false });
+    expect(res.errors).toHaveLength(0);
+
+    const node = res.node;
+
+    expect(node.isRecord).toBe(true);
+
+    // Verify if the parser mapped positional fields to _0, _1
+    expect(node.fields['_0'].value).toBe(10);
+    expect(node.fields['_1'].value).toBe('Alice');
+
+    assertRoundtrip(node, '<_0:number,_1:string>(10,"Alice")', false);
+  });
+
+  it('should decode raw string', () => {
+    const text = '{color: red, status: active}';
+    const res = decode(text, { debug: false });
+    expect(res.errors).toHaveLength(0);
+
+    const node = res.node;
+    expect(node.fields['color'].value).toBe('red');
+    expect(node.fields['status'].value).toBe('active');
+
+    assertRoundtrip(node, '<color:string,status:string>("red","active")', false);
+  });
+});
+
+describe('String Escaping', () => {
+  it('should decode string with escaped quotes', () => {
+    // Input: { text: "say \"hello\"" }
+    // In-memory value: say "hello"
+    // Note: In JS string literals, we need extra backslashes to represent a literal backslash.
+    const text = '{ text: "say \\"hello\\"" }';
+
+    const res = decode(text, { debug: false });
+    expect(res.errors).toHaveLength(0);
+
+    const node = res.node;
+    // Check in-memory value
+    expect(node.fields['text'].value).toBe('say "hello"');
+
+    // Roundtrip check:
+    // Encoder must add backslashes before quotes: "say \"hello\""
+    assertRoundtrip(node, '<text:string>("say \\"hello\\"")', false);
+  });
+
+  it('should decode string with escaped backslashes', () => {
+    // Input: { path: "C:\\Program Files" }
+    // In-memory value: C:\Program Files
+    // Note: "C:\\\\Program Files" in JS literal becomes C:\\Program Files in the string
+    const text = '{ path: "C:\\\\Program Files" }';
+
+    const res = decode(text, { debug: false });
+    expect(res.errors).toHaveLength(0);
+
+    const node = res.node;
+    // Check in-memory value (single backslash)
+    expect(node.fields['path'].value).toBe('C:\\Program Files');
+
+    // Roundtrip check:
+    // Encoder must escape the backslash: "C:\\Program Files"
+    assertRoundtrip(node, '<path:string>("C:\\\\Program Files")', false);
+  });
+});

package/tests/00.schema.test.ts

@@ -2,40 +2,33 @@ import { describe, it, expect } from 'vitest';
 import { Schema, SchemaKind } from '../src/index';
 
 describe('AI Schema test', () => {
-    it('should encode raw object', () => {
-        const schema = new Schema(
-            SchemaKind.DICT,
-            {
-                name: "TestSchema",
-                comments: ["This is a comment"],
-                attr: { foo: "bar" },
-                tags: ["tag1", "tag2"],
-                required: true
-
-            });
-        const expected = '<Schema(DICT) name="TestSchema" !required attr=["foo"] tags=[tag1, tag2] comments=1>';
-        const expected_val = {
-            "comments": [
-                "This is a comment"
-            ],
-            "attr": {
-                "foo": "bar"
-            },
-            "tags": [
-                "tag1",
-                "tag2"
-            ],
-            "_fieldsList": [],
-            "_fieldsMap": {},
-            "kind": "DICT",
-            "typeName": "any",
-            "name": "TestSchema",
-            "element": null,
-            "key": null,
-            "value": null,
-            "required": true
-        }
-        expect(schema).toMatchObject(expected_val);
-        expect(schema.toString()).toBe(expected);
+  it('should encode raw object', () => {
+    const schema = new Schema(SchemaKind.DICT, {
+      name: 'TestSchema',
+      comments: ['This is a comment'],
+      attr: { foo: 'bar' },
+      tags: ['tag1', 'tag2'],
+      required: true,
     });
+    const expected =
+      '<Schema(DICT) name="TestSchema" !required attr=["foo"] tags=[tag1, tag2] comments=1>';
+    const expected_val = {
+      comments: ['This is a comment'],
+      attr: {
+        foo: 'bar',
+      },
+      tags: ['tag1', 'tag2'],
+      _fieldsList: [],
+      _fieldsMap: {},
+      kind: 'DICT',
+      typeName: 'any',
+      name: 'TestSchema',
+      element: null,
+      key: null,
+      value: null,
+      required: true,
+    };
+    expect(schema).toMatchObject(expected_val);
+    expect(schema.toString()).toBe(expected);
+  });
 });

package/tests/01.schema.test.ts

@@ -7,64 +7,54 @@ import { assertRoundtrip } from './utils';
 // ==================================================================================
 
 describe('AK Data Schema Definitions', () => {
-
-    it('should handle schema definition and usage', () => {
-        /**
-         * Validates that a type defined with @Type<...> is correctly applied
-         * to the following value.
-         */
-        // Define schema first, then use it explicitly
-        const fullText = '@User<id:int, name:string> @User(1, "Admin")';
-        const res = decode(fullText, { debug: false });
-
-        expect(res.errors).toHaveLength(0);
-        
-        const node = res.node;
-        // Check if schema is linked correctly
-        expect(node.schema).not.toBeNull();
-        expect(node.schema?.typeName).toBe("User");
-
-        // Since we have a schema, positional arguments should be mapped to fields
-        // Check by key (Decoder maps positional to fields if schema exists)
-        expect(node.fields["id"].value).toBe(1);
-        expect(node.fields["name"].value).toBe("Admin");
-
-        assertRoundtrip(
-            node, 
-            '@User<id:number,name:string>(1,"Admin")',
-            false
-        );
-    });
-
-    it('should handle nested schema structure', () => {
-        /**
-         * Validates nested structural types.
-         */
-        // We define Profile, then User uses it.
-        const text = `
+  it('should handle schema definition and usage', () => {
+    /**
+     * Validates that a type defined with @Type<...> is correctly applied
+     * to the following value.
+     */
+    // Define schema first, then use it explicitly
+    const fullText = '@User<id:int, name:string> @User(1, "Admin")';
+    const res = decode(fullText, { debug: false });
+
+    expect(res.errors).toHaveLength(0);
+
+    const node = res.node;
+    // Check if schema is linked correctly
+    expect(node.schema).not.toBeNull();
+    expect(node.schema?.typeName).toBe('User');
+
+    // Since we have a schema, positional arguments should be mapped to fields
+    // Check by key (Decoder maps positional to fields if schema exists)
+    expect(node.fields['id'].value).toBe(1);
+    expect(node.fields['name'].value).toBe('Admin');
+
+    assertRoundtrip(node, '@User<id:number,name:string>(1,"Admin")', false);
+  });
+
+  it('should handle nested schema structure', () => {
+    /**
+     * Validates nested structural types.
+     */
+    // We define Profile, then User uses it.
+    const text = `
         @Profile<level:int>
         @User<id:int, profile: @Profile>
         @User(1, {level: 99})
         `;
-        
-        const res = decode(text, { debug: false });
 
-        expect(res.errors).toHaveLength(0);
-        const node = res.node;
+    const res = decode(text, { debug: false });
 
-        // id should be 1
-        expect(node.fields["id"].value).toBe(1);
+    expect(res.errors).toHaveLength(0);
+    const node = res.node;
 
-        // profile should be a node
-        const profileNode = node.fields["profile"];
-        expect(profileNode).toBeDefined();
-        expect(profileNode.fields["level"].value).toBe(99);
+    // id should be 1
+    expect(node.fields['id'].value).toBe(1);
 
-        assertRoundtrip(
-            node, 
-            "@User<id:number,profile:@Profile<level:number>>(1,(99))",
-            false
-        );
-    });
+    // profile should be a node
+    const profileNode = node.fields['profile'];
+    expect(profileNode).toBeDefined();
+    expect(profileNode.fields['level'].value).toBe(99);
 
-});
+    assertRoundtrip(node, '@User<id:number,profile:@Profile<level:number>>(1,(99))', false);
+  });
+});

package/tests/02.data.test.ts

@@ -7,83 +7,77 @@ import { assertRoundtrip } from './utils';
 // ==================================================================================
 
 describe('AK Data Encoding', () => {
+  it('should encode simple dict', () => {
+    /**
+     * Validates encoding a JS Object to AI.DATA format.
+     */
+    const data = { x: 10, y: 20 };
 
-    it('should encode simple dict', () => {
-        /**
-         * Validates encoding a JS Object to AI.DATA format.
-         */
-        const data = { x: 10, y: 20 };
-        
-        const result = encode(data, { compact: true });
-        const expected = '<x:number,y:number>(10,20)';
-        
-        expect(result).toBe(expected);
-        
-        assertRoundtrip(
-            result, 
-            expected, 
-            false
-        );
-    });
+    const result = encode(data, { compact: true });
+    const expected = '<x:number,y:number>(10,20)';
 
-    it('should encode list of objects', () => {
-        /**
-         * Validates encoding a list of objects.
-         */
-        const data = [{ name: "A", val: 1 }, { name: "B", val: 2 }];
-        
-        const result = encode(data, { compact: true, colorize: false });
-        const expected = '<[name:string,val:number]>[("A",1),("B",2)]';
-        
-        expect(result).toBe(expected);
-
-        assertRoundtrip(
-            result, 
-            expected,
-            false
-        );
-    });
+    expect(result).toBe(expected);
+
+    assertRoundtrip(result, expected, false);
+  });
+
+  it('should encode list of objects', () => {
+    /**
+     * Validates encoding a list of objects.
+     */
+    const data = [
+      { name: 'A', val: 1 },
+      { name: 'B', val: 2 },
+    ];
+
+    const result = encode(data, { compact: true, colorize: false });
+    const expected = '<[name:string,val:number]>[("A",1),("B",2)]';
+
+    expect(result).toBe(expected);
+
+    assertRoundtrip(result, expected, false);
+  });
+
+  it('should handle round trip consistency', () => {
+    /**
+     * Golden Test: Encode -> Decode -> Compare.
+     */
+    const originalData = [
+      { id: 1, active: true, tags: ['a', 'b'] },
+      { id: 2, active: false, tags: ['c'] },
+    ];
 
-    it('should handle round trip consistency', () => {
-        /**
-         * Golden Test: Encode -> Decode -> Compare.
-         */
-        const originalData = [
-            { id: 1, active: true, tags: ["a", "b"] },
-            { id: 2, active: false, tags: ["c"] },
-        ];
-        
-        const expected = '<[id:number,active:bool,tags:[string]]>[(1,true,["a","b"]),(2,false,["c"])]';
-
-        // 1. Encode
-        // Note: converted snake_case config keys to camelCase for TS
-        const encodedText = encode(
-            originalData,
-            { compact: true, includeSchema: true, colorize: false }
-        );
-
-        expect(encodedText).toBe(expected);
-        assertRoundtrip(encodedText, expected, false);
-
-        // 2. Decode
-        const res = decode(encodedText, { debug: false });
-        
-        // Optional: inspect schema structure
-
-        expect(res.errors).toHaveLength(0);
-
-        // 3. Convert back to JS object (equivalent to .dict() in Python)
-        const decodedData = res.node.dict()
-
-        // 4. Compare
-        expect(decodedData).toHaveLength(2);
-        expect(decodedData[0].id).toBe(1);
-        expect(decodedData[0].active).toBe(true);
-        expect(decodedData[0].tags).toEqual(["a", "b"]);
-        expect(decodedData[1].active).toBe(false);
-
-        // Deep equality check
-        expect(decodedData).toEqual(originalData);
+    const expected = '<[id:number,active:bool,tags:[string]]>[(1,true,["a","b"]),(2,false,["c"])]';
+
+    // 1. Encode
+    // Note: converted snake_case config keys to camelCase for TS
+    const encodedText = encode(originalData, {
+      compact: true,
+      includeSchema: true,
+      colorize: false,
     });
 
-});
+    expect(encodedText).toBe(expected);
+    assertRoundtrip(encodedText, expected, false);
+
+    // 2. Decode
+    const res = decode(encodedText, { debug: false });
+
+    // Optional: inspect schema structure
+
+    expect(res.errors).toHaveLength(0);
+
+    // 3. Convert back to JS object (equivalent to .dict() in Python)
+    const decodedData = res.node.dict();
+
+    // 4. Compare
+    expect(decodedData).toHaveLength(2);
+    expect(decodedData[0].id).toBe(1);
+    expect(decodedData[0].active).toBe(true);
+    expect(decodedData[0].tags).toEqual(['a', 'b']);
+    expect(decodedData[1].active).toBe(false);
+
+    // Deep equality check
+    expect(decodedData).toEqual(originalData);
+  });
+});