@arkadia/data 0.1.9 → 0.1.11

package/src/core/Encoder.ts

@@ -12,7 +12,7 @@ class Colors {
   static TYPE = '\x1b[96m'; // cyan
   static KEY = '\x1b[93m'; // yellow
   static SCHEMA = '\x1b[91m'; // red (for @TypeName)
-  static TAG = '\x1b[91m';
+  static TAG = '\x1b[35m';
   static ATTR = '\x1b[93m';
 }
 
@@ -78,7 +78,8 @@ export class Encoder {
 
     // Avoid printing internal/default type names
     if (schema.typeName && schema.isRecord && !schema.isAny) {
-      prefix = this.c(`@${schema.typeName}`, Colors.SCHEMA);
+      const escapedName = this.escapeIdent(schema.typeName);
+      prefix = this.c(`@${escapedName}`, Colors.SCHEMA);
     }
 
     // Przygotowanie meta (ale jeszcze nie użycie, bo w liście może się zmienić)
@@ -90,7 +91,8 @@ export class Encoder {
       const metaPrefix = includeMeta ? this.metaInline(schema) : '';
       // Python: return ind + ((meta_prefix + " ") if meta_prefix else "") + self._c(...)
       const metaStr = metaPrefix ? metaPrefix + ' ' : '';
-      return ind + metaStr + this.c(schema.typeName, Colors.TYPE);
+      const escapedType = this.escapeIdent(schema.typeName);
+      return ind + metaStr + this.c(escapedType, Colors.TYPE);
     }
 
     // --- LIST ---
@@ -156,7 +158,7 @@ export class Encoder {
       }
 
       // 3. Field Name
-      str += this.c(field.name, Colors.KEY);
+      str += this.c(this.escapeIdent(field.name), Colors.KEY);
 
       // 4. Field Type
       const fieldType = this.encodeSchema(field, 0, false).trim();
@@ -196,13 +198,13 @@ export class Encoder {
   }
 
   private getTypeLabel(schema: Schema): string {
-    if (schema.isPrimitive) return schema.typeName || 'any';
+    if (schema.isPrimitive) return this.escapeIdent(schema.typeName || 'any');
     if (schema.isList) {
       const inner = schema.element ? this.getTypeLabel(schema.element) : 'any';
       return `[${inner}]`;
     }
     if (schema.isRecord && schema.typeName && schema.typeName !== 'any') {
-      return schema.typeName;
+      return this.escapeIdent(schema.typeName);
     }
     return 'any';
   }
@@ -240,15 +242,20 @@ export class Encoder {
 
     // 2. Modifiers
     if ((obj as Schema).required) {
-      items.push(this.c('!required', Colors.TAG));
+      items.push(this.c('$required', Colors.TAG));
     }
 
     // 3. Attributes & Tags
     if (this.config.includeMeta) {
       const currentAttr = obj.attr || {};
       for (const [k, v] of Object.entries(currentAttr)) {
-        const valStr = this.primitiveValue(v);
-        items.push(this.c(`$${k}=`, Colors.ATTR) + valStr);
+        const escapedKey = this.escapeIdent(k);
+        if (typeof v === 'boolean' && v === true) {
+          items.push(this.c(`$${escapedKey}`, Colors.ATTR));
+        } else {
+          const valStr = this.primitiveValue(v);
+          items.push(this.c(`$${escapedKey}=`, Colors.ATTR) + valStr);
+        }
       }
 
       const currentTags = obj.tags || [];
@@ -265,7 +272,7 @@ export class Encoder {
 
     if (wrapped) {
       const wrappedContent =
-        this.c(`/${pad}`, Colors.SCHEMA) + content + this.c(`${pad}/`, Colors.SCHEMA);
+        this.c(`//${pad}`, Colors.SCHEMA) + content + this.c(`${pad}//`, Colors.SCHEMA);
       return this.config.compact ? wrappedContent + ' ' : ' ' + wrappedContent + ' ';
     }
 
@@ -321,92 +328,111 @@ export class Encoder {
     return this.c(`"${content}"`, Colors.STRING);
   }
 
-  // -------------------------------------------------------------
-  // LIST
-  // -------------------------------------------------------------
+  /**
+   * Wraps identifier in backticks if it contains spaces or special characters.
+   * Regex: [a-zA-Z_][a-zA-Z0-9_]*
+   */
+  private escapeIdent(name: string): string {
+    if (!name) return '';
 
-  private listHeader(node: Node): string {
-    let header = '[';
-    if (this.config.includeArraySize) {
-      const size = node.elements.length;
-      header += `${this.c('$size', Colors.KEY)}=${this.c(String(size), Colors.NUMBER)}${this.c(':', Colors.TYPE)}`;
+    // Standard identifier pattern
+    const pattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+
+    if (pattern.test(name)) {
+      return name;
     }
-    return header;
-  }
 
-  private joinLines(items: string[], sep: string): string {
-    if (this.config.compact) return items.join(sep);
-    if (sep === '\n') return items.join(sep);
-    return items.join(`${sep} `);
+    // If it doesn't match, wrap it in backticks
+    return `\`${name}\``;
   }
 
+  // -------------------------------------------------------------
+  // LIST
+  // -------------------------------------------------------------
   private encodeList(node: Node, indent: number, includeSchema: boolean = false): string {
     const ind = ' '.repeat(indent);
     const childIndent = indent + this.config.indent;
+    const isPrompt = this.config.promptOutput;
 
+    if (this.config.includeArraySize) {
+      node.attr['size'] = node.elements.length;
+    }
     const innerMeta = this.metaWrapped(node);
 
-    // 1. Generate Header Schema (if requested)
+    // 1. Generate Header Schema (Standard only)
     let schemaHeader = '';
-    if (includeSchema && node.schema && node.schema.element) {
+    if (!isPrompt && includeSchema && node.schema && node.schema.element) {
       schemaHeader = this.encodeSchema(node.schema.element, 0).trim();
-    }
-    if (schemaHeader) {
-      schemaHeader = schemaHeader + ' ';
+      if (schemaHeader) schemaHeader += ' ';
     }
 
     const expectedChild = node.schema ? node.schema.element : null;
 
+    // --- PROMPT MODE (Full Structural Expansion) ---
+    if (isPrompt) {
+      let res = ind + '[\n';
+      if (innerMeta) {
+        res += ' '.repeat(childIndent) + innerMeta.trim() + '\n';
+      }
+
+      if (node.schema && node.schema.element) {
+        // Force recursion into the element's structure using a Dummy Node
+        const dummy = new Node(node.schema.element, { value: null });
+
+        // We trim() the blueprint because we manually handle child indentation
+        const blueprint = this.encode(dummy, childIndent, false).trim();
+
+        res += ' '.repeat(childIndent) + blueprint + ',\n';
+        res += ' '.repeat(childIndent) + '... /* repeat pattern for additional items */\n';
+      } else {
+        res += ' '.repeat(childIndent) + '/* any content */\n';
+      }
+
+      res += ind + ']';
+      return res;
+    }
+
     // --- COMPACT MODE ---
     if (this.config.compact) {
       const items: string[] = [];
-
       for (const el of node.elements) {
-        // IMPORTANT: We disable schema inclusion for elements to avoid duplication <...>
-        // unless types mismatch drastically.
         let val = this.encode(el, 0, false).trim();
-
-        // Check compatibility & Inject override if needed
         if (!this.schemasAreCompatible(el.schema, expectedChild)) {
           const label = el.schema ? this.getTypeLabel(el.schema) : 'any';
           const tag = this.c(`<${label}>`, Colors.SCHEMA);
           val = `${tag} ${val}`;
         }
-
         items.push(val);
       }
-
       return ind + '[' + innerMeta + schemaHeader + items.join(',') + ']';
     }
 
     // --- PRETTY MODE ---
-    const header = this.listHeader(node);
-    const out: string[] = [ind + header];
-
+    let res = ind + '[\n';
     if (innerMeta) {
-      out.push(' '.repeat(childIndent) + innerMeta.trim());
+      res += ' '.repeat(childIndent) + innerMeta.trim() + '\n';
     }
-
     if (schemaHeader) {
-      out.push(' '.repeat(childIndent) + schemaHeader.trim());
+      res += ' '.repeat(childIndent) + schemaHeader.trim() + '\n';
     }
 
+    const elementLines: string[] = [];
     for (const el of node.elements) {
-      // IMPORTANT: Disable schema for children
-      let val = this.encode(el, childIndent - this.config.startIndent, false).trim();
-
-      // Check compatibility & Inject override if needed
+      let val = this.encode(el, 0, false).trim();
       if (!this.schemasAreCompatible(el.schema, expectedChild)) {
         const label = el.schema ? this.getTypeLabel(el.schema) : 'any';
         const tag = this.c(`<${label}>`, Colors.SCHEMA);
         val = `${tag} ${val}`;
       }
+      elementLines.push(' '.repeat(childIndent) + val);
+    }
 
-      out.push(' '.repeat(childIndent) + val);
+    if (elementLines.length > 0) {
+      res += elementLines.join(',\n') + '\n';
     }
 
-    out.push(ind + ']');
-    return this.joinLines(out, '\n');
+    res += ind + ']';
+    return res;
   }
 
   // -------------------------------------------------------------
@@ -414,23 +440,57 @@ export class Encoder {
   // -------------------------------------------------------------
   private encodeRecord(node: Node, indent: number): string {
     const innerMeta = this.metaWrapped(node);
-
     const parts: string[] = [];
-    if (node.schema.fields && node.schema.fields.length > 0) {
+    const isPrompt = this.config.promptOutput;
+    const baseInd = ' '.repeat(indent);
+    const childInd = ' '.repeat(indent + this.config.indent);
+
+    if (node.schema && node.schema.fields && node.schema.fields.length > 0) {
       for (const fieldDef of node.schema.fields) {
-        const fieldNode = node.fields[fieldDef.name];
-        if (fieldNode) {
-          let val = this.encode(fieldNode, indent - this.config.startIndent, false).trim();
-          val = this.applyTypeTag(val, fieldNode.schema, fieldDef);
-          parts.push(val);
+        if (isPrompt) {
+          // --- PROMPT MODE: Type Label or Structural Expansion ---
+          const fieldName = this.escapeIdent(fieldDef.name);
+          let fieldValStructure: string;
+
+          if (fieldDef.isPrimitive) {
+            // For primitives, use the type name (e.g., "number")
+            fieldValStructure = this.c(this.getTypeLabel(fieldDef), Colors.TYPE);
+          } else {
+            // For structures (Records/Lists), recurse to get { } or [ ]
+            const dummyField = new Node(fieldDef, { value: null });
+            fieldValStructure = this.encode(dummyField, indent + this.config.indent, false).trim();
+          }
+
+          let line = `${this.c(fieldName, Colors.KEY)}: ${fieldValStructure}`;
+
+          if (fieldDef.comments && fieldDef.comments.length > 0) {
+            const comment = fieldDef.comments[0].trim();
+            line += ` ${this.c(`/* ${comment} */`, Colors.NULL)}`;
+          }
+          parts.push(line);
         } else {
-          parts.push(this.c('null', Colors.NULL));
+          // --- STANDARD MODE (Data values) ---
+          const fieldNode = node.fields[fieldDef.name];
+          if (fieldNode) {
+            let val = this.encode(fieldNode, 0, false).trim();
+            val = this.applyTypeTag(val, fieldNode.schema, fieldDef);
+            parts.push(val);
+          } else {
+            parts.push(this.c('null', Colors.NULL));
+          }
         }
       }
-      const sep = this.config.compact ? ',' : ', ';
-      return '(' + innerMeta + parts.join(sep) + ')';
     } else {
-      return '(' + innerMeta + this.c('null', Colors.NULL) + ')';
+      parts.push(this.c('null', Colors.NULL));
+    }
+
+    if (isPrompt) {
+      const body = parts.join(',\n' + childInd);
+      const metaStr = innerMeta ? childInd + innerMeta.trim() + '\n' : '';
+      return '{\n' + metaStr + childInd + body + '\n' + baseInd + '}';
     }
+
+    const sep = this.config.compact ? ',' : ', ';
+    return '(' + innerMeta + parts.join(sep) + ')';
   }
 }

package/src/models/Meta.ts

@@ -53,7 +53,7 @@ export class Meta {
 
 /**
  * A temporary container (DTO) holding parsed metadata from a / ... / block.
- * It contains BOTH Schema constraints (!required) and Node attributes ($key=val).
+ * It contains BOTH Schema constraints ($required) and Node attributes ($key=val).
  */
 export class MetaInfo extends Meta {
   required: boolean;
@@ -91,14 +91,14 @@ export class MetaInfo extends Meta {
 
   /**
    * Debug representation mimicking the actual ADF format style.
-   * Example: <MetaInfo !required #tag $key=val >
+   * Example: <MetaInfo $required #tag $key=val >
    */
   toString(): string {
     const parts: string[] = [];
 
     // 1. Flags
     if (this.required) {
-      parts.push('!required');
+      parts.push('$required');
     }
 
     // 2. Tags

package/src/models/Schema.ts

@@ -192,7 +192,7 @@ export class Schema extends Meta {
     // 3. Details
     const details: string[] = [];
 
-    if (this.required) details.push('!required');
+    if (this.required) details.push('$required');
 
     const attrKeys = Object.keys(this.attr);
     if (attrKeys.length > 0)

package/tests/00.meta.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { MetaInfo } from '../src/index';
 
 describe('AK Data Meta', () => {
@@ -9,7 +9,7 @@ describe('AK Data Meta', () => {
       tags: ['tag1', 'tag2'],
       required: true,
     });
-    const expected = '<MetaInfo !required #tag1 #tag2 $foo="bar" /* This is a comme.. */>';
+    const expected = '<MetaInfo $required #tag1 #tag2 $foo="bar" /* This is a comme.. */>';
     // const expectedJSON
     const expected_val = {
       comments: ['This is a comment'],

package/tests/00.primitive.test.ts

@@ -131,4 +131,42 @@ describe('String Escaping', () => {
     // Encoder must escape the backslash: "C:\\Program Files"
     assertRoundtrip(node, '<path:string>("C:\\\\Program Files")', false);
   });
+
+  it('should handle deeply nested escaped names and metadata keys', () => {
+    /**
+     * Validates that backticks work in nested schemas and metadata keys.
+     * This tests:
+     * 1. Schema name with spaces and symbols: @`User ID+`
+     * 2. Metadata keys with symbols: $`attributes*`
+     * 3. Field names with spaces and symbols: `ID of the user`
+     * 4. Standard identifiers: is_user (no backticks)
+     */
+    const text = `
+/* Use backticks for Schema names and Attributes with spaces */
+@\`User ID+\` <
+  // $\`attributes*\`="32" //
+  \`Is User?\`: bool,
+  $\`Attribute Special*\` \`ID of the user\`: string,
+  \`is - special?\`: bool,
+    is_user: bool
+>
+
+{
+  // $\`numbers of ids\`=4 //
+  $\`attr*\`=52  \`Is User?\`: true,
+  \`ID of the user\`: "ID",
+    \`is - special?\`: false,
+    is_user: false
+}`;
+
+    // The expected output follows the AK Data rules:
+    // - Metadata wrapped in // ... //
+    // - Record data in ( ... )
+    // - Booleans and Numbers as literals
+    // - Identifiers escaped only if necessary
+    const expected =
+      `@\`User ID+\`<///*Use backticks for Schema names and Attributes with spaces*/ $\`attributes*\`="32"// \`Is User?\`:bool,$\`Attribute Special*\` \`ID of the user\`:string,\`is - special?\`:bool,is_user:bool>(//$\`numbers of ids\`=4// $\`attr*\`=52 true,"ID",false,false)`.trim();
+
+    assertRoundtrip(text, expected, false);
+  });
 });

package/tests/00.schema.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { Schema, SchemaKind } from '../src/index';
 
 describe('AI Schema test', () => {
@@ -11,7 +11,7 @@ describe('AI Schema test', () => {
       required: true,
     });
     const expected =
-      '<Schema(DICT) name="TestSchema" !required attr=["foo"] tags=[tag1, tag2] comments=1>';
+      '<Schema(DICT) name="TestSchema" $required attr=["foo"] tags=[tag1, tag2] comments=1>';
     const expected_val = {
       comments: ['This is a comment'],
       attr: {

package/tests/04.list.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest';
-import { encode, decode, parse, SchemaKind } from '../src/index';
+import { describe, expect, it } from 'vitest';
+import { decode, encode, parse, SchemaKind } from '../src/index';
 import { assertRoundtrip } from './utils';
 
 describe('AK List Handling', () => {
@@ -221,4 +221,27 @@ describe('AK List Handling', () => {
     const expected = '<[[number]]>[[2,3,4],[5,6,7]]';
     assertRoundtrip(node, expected, false);
   });
+
+  it('should no compact with include_array_size', () => {
+    const akdText = `<[number]>[1,2,<string> "3"]`;
+
+    const result = decode(akdText, { debug: false });
+    const node = result.node;
+    expect(result.errors).toHaveLength(0);
+
+    // 'int' normalizes to 'number' in the TS implementation
+    const expected = `<[number]>
+[
+  // $size=3 //
+  1,
+  2,
+  <string> "3"
+]`;
+    const output = encode(node, {
+      includeArraySize: true,
+      compact: false,
+    });
+
+    expect(output).toBe(expected);
+  });
 });