@arkadia/data 0.1.7 → 0.1.8

package/src/core/Parser.ts

@@ -1,150 +1,150 @@
-import { Node } from '../models/Node';
+import { Node, Primitive } from '../models/Node';
 import { Schema, SchemaKind } from '../models/Schema';
 
 export class EncodingError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = "EncodingError";
-    }
+  constructor(message: string) {
+    super(message);
+    this.name = 'EncodingError';
+  }
 }
 
 // --------------------------------------------------------------
 // Helper: Type Wrapper
 // --------------------------------------------------------------
-const TYPE_STRING = "string";
-const TYPE_NUMBER = "number";
-const TYPE_BOOL = "bool";
-const TYPE_NULL = "null";
+const TYPE_STRING = 'string';
+const TYPE_NUMBER = 'number';
+const TYPE_BOOL = 'bool';
+const TYPE_NULL = 'null';
 // const TYPE_ANY = "any";
 
 // --------------------------------------------------------------
 // Primitive -> Node(primitive)
 // --------------------------------------------------------------
 
-function parsePrimitive(v: any): Node {
-    let schema: Schema;
-
-    if (typeof v === 'string') {
-        schema = new Schema(SchemaKind.PRIMITIVE, { typeName: TYPE_STRING });
-    } else if (typeof v === 'boolean') {
-        schema = new Schema(SchemaKind.PRIMITIVE, { typeName: TYPE_BOOL });
-    } else if (typeof v === 'number') {
-        schema = new Schema(SchemaKind.PRIMITIVE, { typeName: TYPE_NUMBER });
-    } else if (v === null || v === undefined) {
-        schema = new Schema(SchemaKind.PRIMITIVE, { typeName: TYPE_NULL });
-    } else {
-        throw new EncodingError(`Unsupported primitive: ${v}`);
-    }
-
-    return new Node(schema, { value: v });
+function parsePrimitive(v: Primitive): Node {
+  let schema: Schema;
+
+  if (typeof v === 'string') {
+    schema = new Schema(SchemaKind.PRIMITIVE, { typeName: TYPE_STRING });
+  } else if (typeof v === 'boolean') {
+    schema = new Schema(SchemaKind.PRIMITIVE, { typeName: TYPE_BOOL });
+  } else if (typeof v === 'number') {
+    schema = new Schema(SchemaKind.PRIMITIVE, { typeName: TYPE_NUMBER });
+  } else if (v === null || v === undefined) {
+    schema = new Schema(SchemaKind.PRIMITIVE, { typeName: TYPE_NULL });
+  } else {
+    throw new EncodingError(`Unsupported primitive: ${v}`);
+  }
+
+  return new Node(schema, { value: v });
 }
 
 // --------------------------------------------------------------
 // List -> Node(list)
 // --------------------------------------------------------------
 
-function parseList(arr: any[]): Node {
-    // 1. EMPTY LIST
-    if (arr.length === 0) {
-        const elementSchema = new Schema(SchemaKind.PRIMITIVE, { typeName: "any" });
-        const listSchema = new Schema(SchemaKind.LIST, { element: elementSchema });
-        return new Node(listSchema, { elements: [] });
-    }
-
-    // 2. PARSE ALL ITEMS
-    const parsedItems: Node[] = arr.map(v => parseDataToNode(v));
-
-    // Use the first element as the baseline
-    const firstSchema = parsedItems[0].schema;
-    const isListOfRecords = (firstSchema.kind === SchemaKind.RECORD);
-
-    let unifiedElementSchema: Schema;
-
-    // 3. DETERMINE ELEMENT SCHEMA
-    if (isListOfRecords) {
-        // RECORDS: Create a unified schema containing ALL fields from ALL items.
-        unifiedElementSchema = new Schema(SchemaKind.RECORD, { typeName: "record" });
-        const seenFields = new Set<string>();
-
-        for (const item of parsedItems) {
-            // Skip non-record items if mixed list (or handle as error depending on strictness)
-            if (item.schema.kind === SchemaKind.RECORD) {
-                for (const field of item.schema.fields) {
-                    if (!seenFields.has(field.name)) {
-                        unifiedElementSchema.addField(field);
-                        seenFields.add(field.name);
-                    }
-                }
-            }
+function parseList(arr: unknown[]): Node {
+  // 1. EMPTY LIST
+  if (arr.length === 0) {
+    const elementSchema = new Schema(SchemaKind.PRIMITIVE, { typeName: 'any' });
+    const listSchema = new Schema(SchemaKind.LIST, { element: elementSchema });
+    return new Node(listSchema, { elements: [] });
+  }
+
+  // 2. PARSE ALL ITEMS
+  const parsedItems: Node[] = arr.map((v) => parseDataToNode(v));
+
+  // Use the first element as the baseline
+  const firstSchema = parsedItems[0].schema;
+  const isListOfRecords = firstSchema.kind === SchemaKind.RECORD;
+
+  let unifiedElementSchema: Schema;
+
+  // 3. DETERMINE ELEMENT SCHEMA
+  if (isListOfRecords) {
+    // RECORDS: Create a unified schema containing ALL fields from ALL items.
+    unifiedElementSchema = new Schema(SchemaKind.RECORD, { typeName: 'record' });
+    const seenFields = new Set<string>();
+
+    for (const item of parsedItems) {
+      // Skip non-record items if mixed list (or handle as error depending on strictness)
+      if (item.schema.kind === SchemaKind.RECORD) {
+        for (const field of item.schema.fields) {
+          if (!seenFields.has(field.name)) {
+            unifiedElementSchema.addField(field);
+            seenFields.add(field.name);
+          }
         }
-    } else {
-        // PRIMITIVES: Simply take the schema of the first element.
-        // We assume the list is homogeneous based on the first item.
-        unifiedElementSchema = firstSchema;
+      }
     }
-
-    // 4. FINALIZE
-    const listSchema = new Schema(SchemaKind.LIST, { 
-        typeName: "list", 
-        element: unifiedElementSchema 
-    });
-
-    return new Node(listSchema, { elements: parsedItems });
+  } else {
+    // PRIMITIVES: Simply take the schema of the first element.
+    // We assume the list is homogeneous based on the first item.
+    unifiedElementSchema = firstSchema;
+  }
+
+  // 4. FINALIZE
+  const listSchema = new Schema(SchemaKind.LIST, {
+    typeName: 'list',
+    element: unifiedElementSchema,
+  });
+
+  return new Node(listSchema, { elements: parsedItems });
 }
 
 // --------------------------------------------------------------
 // Dict -> Node(record)
 // --------------------------------------------------------------
 
-function parseDict(obj: Record<string, any>): Node {
-    /**
-     * JSON objects -> named records.
-     */
-    const fieldsData: Record<string, Node> = {};
-    const schema = new Schema(SchemaKind.RECORD);
+function parseDict(obj: Record<string, unknown>): Node {
+  /**
+   * JSON objects -> named records.
+   */
+  const fieldsData: Record<string, Node> = {};
+  const schema = new Schema(SchemaKind.RECORD);
 
-    for (const [key, rawValue] of Object.entries(obj)) {
-        const childNode = parseDataToNode(rawValue);
+  for (const [key, rawValue] of Object.entries(obj)) {
+    const childNode = parseDataToNode(rawValue);
 
-        // Assign field name to the child's schema so it knows it is a field
-        childNode.schema.name = key;
+    // Assign field name to the child's schema so it knows it is a field
+    childNode.schema.name = key;
 
-        fieldsData[key] = childNode;
-        schema.addField(childNode.schema);
-    }
+    fieldsData[key] = childNode;
+    schema.addField(childNode.schema);
+  }
 
-    return new Node(schema, { fields: fieldsData });
+  return new Node(schema, { fields: fieldsData });
 }
 
 // --------------------------------------------------------------
 // Main entrypoint
 // --------------------------------------------------------------
 
-export function parseDataToNode(value: any): Node {
-    if (value instanceof Node) {
-        return value;
-    }
-    
-    // 1. Primitive Check
-    if (
-        value === null || 
-        value === undefined || 
-        typeof value === 'string' || 
-        typeof value === 'number' || 
-        typeof value === 'boolean'
-    ) {
-        return parsePrimitive(value);
-    }
-
-    // 2. List Check
-    if (Array.isArray(value)) {
-        return parseList(value);
-    }
-
-    // 3. Object Check (Dict)
-    if (typeof value === 'object') {
-        return parseDict(value);
-    }
-
-    throw new EncodingError(`Unsupported structure type: ${typeof value}`);
-}
+export function parseDataToNode(value: Node | unknown): Node {
+  if (value instanceof Node) {
+    return value;
+  }
+
+  // 1. Primitive Check
+  if (
+    value === null ||
+    value === undefined ||
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'boolean'
+  ) {
+    return parsePrimitive(value);
+  }
+
+  // 2. List Check
+  if (Array.isArray(value)) {
+    return parseList(value);
+  }
+
+  // 3. Object Check (Dict)
+  if (typeof value === 'object') {
+    return parseDict(value as Record<string, unknown>);
+  }
+
+  throw new EncodingError(`Unsupported structure type: ${typeof value}`);
+}

package/src/index.ts

@@ -1,14 +1,13 @@
-import { EncoderConfig, DEFAULT_CONFIG } from './config';
-import { Encoder } from './core/Encoder';
+import { DEFAULT_CONFIG, EncoderConfig } from './config';
 import { Decoder, DecodeResult } from './core/Decoder';
+import { Encoder } from './core/Encoder';
 import { parseDataToNode } from './core/Parser';
+import { Meta, MetaInfo, MetaProps } from './models/Meta';
 import { Node } from './models/Node';
 import { Schema, SchemaKind } from './models/Schema';
-import { MetaInfo, Meta, MetaProps } from './models/Meta';
 
 // Re-export types and classes
-export { Node, Schema, SchemaKind, DecodeResult, EncoderConfig, 
-    Meta, MetaInfo, MetaProps };
+export { DecodeResult, EncoderConfig, Meta, MetaInfo, MetaProps, Node, Schema, SchemaKind };
 
 // =============================================================
 // PUBLIC API
@@ -17,30 +16,29 @@ export { Node, Schema, SchemaKind, DecodeResult, EncoderConfig,
 /**
  * Encode input data into valid **AK Data** format.
  */
-export function encode(data: any | Node, config: Partial<EncoderConfig> = {}): string {
-    let node: Node;
-    node = parseDataToNode(data);
-    const finalConfig: EncoderConfig = { ...DEFAULT_CONFIG, ...config };
-    const encoder = new Encoder(finalConfig);
-    return encoder.encode(node);
+export function encode(data: Node | unknown, config: Partial<EncoderConfig> = {}): string {
+  const node = parseDataToNode(data);
+  const finalConfig: EncoderConfig = { ...DEFAULT_CONFIG, ...config };
+  const encoder = new Encoder(finalConfig);
+  return encoder.encode(node);
 }
 
 /**
  * Decode AK Data format text into a Node structure.
  */
 export function decode(
-    text: string,
-    options: { removeAnsiColors?: boolean; debug?: boolean } = {},
-    schema: string = ""
+  text: string,
+  options: { removeAnsiColors?: boolean; debug?: boolean } = {},
+  schema: string = '',
 ): DecodeResult {
-    const { removeAnsiColors = false, debug = false } = options;
-    const decoder = new Decoder(text, schema, removeAnsiColors, debug);
-    return decoder.decode();
+  const { removeAnsiColors = false, debug = false } = options;
+  const decoder = new Decoder(text, schema, removeAnsiColors, debug);
+  return decoder.decode();
 }
 
 /**
  * Convert raw JavaScript object/value into a Node.
  */
-export function parse(data: any): Node {
-    return parseDataToNode(data);
-}
+export function parse(data: unknown): Node {
+  return parseDataToNode(data);
+}

package/src/models/Meta.ts

@@ -1,53 +1,54 @@
+import { Primitive } from './Node';
 
 export interface MetaProps {
-    comments?: string[];
-    attr?: Record<string, any>;
-    tags?: string[];
+  comments?: string[];
+  attr?: Record<string, Primitive>;
+  tags?: string[];
 }
 
 /**
  * Mixin/Base class that adds metadata storage capabilities to Node and Schema.
  */
 export class Meta {
-    comments: string[];
-    attr: Record<string, any>;
-    tags: string[];
-
-    constructor({ comments, attr, tags }: MetaProps = {}) {
-        this.comments = comments ? [...comments] : [];
-        this.attr = attr ? { ...attr } : {};
-        this.tags = tags ? [...tags] : [];
+  comments: string[];
+  attr: Record<string, Primitive>;
+  tags: string[];
+
+  constructor({ comments, attr, tags }: MetaProps = {}) {
+    this.comments = comments ? [...comments] : [];
+    this.attr = attr ? { ...attr } : {};
+    this.tags = tags ? [...tags] : [];
+  }
+
+  /**
+   * Clears ALL metadata (comments, attributes, tags).
+   */
+  clearCommonMeta(): void {
+    this.comments = [];
+    this.attr = {};
+    this.tags = [];
+  }
+
+  /**
+   * Merges only the common fields (attributes, comments, tags)
+   * from a MetaInfo object. Safe for both Node and Schema.
+   */
+  applyCommonMeta(info: Meta): void {
+    // Append comments
+    if (info.comments.length > 0) {
+      this.comments.push(...info.comments);
     }
 
-    /**
-     * Clears ALL metadata (comments, attributes, tags).
-     */
-    clearCommonMeta(): void {
-        this.comments = [];
-        this.attr = {};
-        this.tags = [];
+    // Merge attributes ($key=value)
+    if (Object.keys(info.attr).length > 0) {
+      Object.assign(this.attr, info.attr);
     }
 
-    /**
-     * Merges only the common fields (attributes, comments, tags)
-     * from a MetaInfo object. Safe for both Node and Schema.
-     */
-    applyCommonMeta(info: Meta): void {
-        // Append comments
-        if (info.comments.length > 0) {
-            this.comments.push(...info.comments);
-        }
-
-        // Merge attributes ($key=value)
-        if (Object.keys(info.attr).length > 0) {
-            Object.assign(this.attr, info.attr);
-        }
-
-        // Append tags
-        if (info.tags.length > 0) {
-            this.tags.push(...info.tags);
-        }
+    // Append tags
+    if (info.tags.length > 0) {
+      this.tags.push(...info.tags);
     }
+  }
 }
 
 /**
@@ -55,81 +56,80 @@ export class Meta {
  * It contains BOTH Schema constraints (!required) and Node attributes ($key=val).
  */
 export class MetaInfo extends Meta {
-    required: boolean;
-
-    constructor(props: MetaProps & { required?: boolean } = {}) {
-        super(props);
-        this.required = props.required || false;
+  required: boolean;
+
+  constructor(props: MetaProps & { required?: boolean } = {}) {
+    super(props);
+    this.required = props.required || false;
+  }
+
+  /**
+   * Merges everything from another MetaInfo object, including 'required' flag.
+   */
+  applyMeta(info: MetaInfo): void {
+    // Apply common fields (comments, attr, tags)
+    this.applyCommonMeta(info);
+
+    // Override required meta (Schema Only)
+    if (info.required) {
+      this.required = true;
+    }
+  }
+
+  /**
+   * Allows usage checks like 'if meta.isEmpty()' to see if any metadata was collected.
+   * Equivalent to Python's __bool__.
+   */
+  isEmpty(): boolean {
+    return (
+      this.comments.length === 0 &&
+      Object.keys(this.attr).length === 0 &&
+      this.tags.length === 0 &&
+      !this.required
+    );
+  }
+
+  /**
+   * Debug representation mimicking the actual ADF format style.
+   * Example: <MetaInfo !required #tag $key=val >
+   */
+  toString(): string {
+    const parts: string[] = [];
+
+    // 1. Flags
+    if (this.required) {
+      parts.push('!required');
     }
 
-    /**
-     * Merges everything from another MetaInfo object, including 'required' flag.
-     */
-    applyMeta(info: MetaInfo): void {
-        // Apply common fields (comments, attr, tags)
-        this.applyCommonMeta(info);
-
-        // Override required meta (Schema Only)
-        if (info.required) {
-            this.required = true;
-        }
+    // 2. Tags
+    for (const t of this.tags) {
+      parts.push(`#${t}`);
     }
 
-    /**
-     * Allows usage checks like 'if meta.isEmpty()' to see if any metadata was collected.
-     * Equivalent to Python's __bool__.
-     */
-    isEmpty(): boolean {
-        return (
-            this.comments.length === 0 &&
-            Object.keys(this.attr).length === 0 &&
-            this.tags.length === 0 &&
-            !this.required
-        );
+    // 3. Attributes
+    for (const [k, v] of Object.entries(this.attr)) {
+      // Simplistic value repr for debug
+      let valStr: string;
+      if (typeof v === 'string') {
+        valStr = `"${v}"`;
+      } else {
+        valStr = String(v);
+      }
+      parts.push(`$${k}=${valStr}`);
     }
 
-    /**
-     * Debug representation mimicking the actual ADF format style.
-     * Example: <MetaInfo !required #tag $key=val >
-     */
-    toString(): string {
-        const parts: string[] = [];
-
-        // 1. Flags
-        if (this.required) {
-            parts.push("!required");
-        }
-
-        // 2. Tags
-        for (const t of this.tags) {
-            parts.push(`#${t}`);
-        }
-
-        // 3. Attributes
-        for (const [k, v] of Object.entries(this.attr)) {
-            // Simplistic value repr for debug
-            let valStr: string;
-            if (typeof v === 'string') {
-                valStr = `"${v}"`;
-            } else {
-                valStr = String(v);
-            }
-            parts.push(`$${k}=${valStr}`);
-        }
-
-        // 4. Comments (Summary)
-        if (this.comments.length > 0) {
-            if (this.comments.length === 1) {
-                const c = this.comments[0];
-                const preview = c.length > 15 ? c.substring(0, 15) + '..' : c;
-                parts.push(`/* ${preview} */`);
-            } else {
-                parts.push(`/* ${this.comments.length} comments */`);
-            }
-        }
-
-        const content = parts.join(" ");
-        return content ? `<MetaInfo ${content}>` : "<MetaInfo (empty)>";
+    // 4. Comments (Summary)
+    if (this.comments.length > 0) {
+      if (this.comments.length === 1) {
+        const c = this.comments[0];
+        const preview = c.length > 15 ? c.substring(0, 15) + '..' : c;
+        parts.push(`/* ${preview} */`);
+      } else {
+        parts.push(`/* ${this.comments.length} comments */`);
+      }
     }
 
-}
+    const content = parts.join(' ');
+    return content ? `<MetaInfo ${content}>` : '<MetaInfo (empty)>';
+  }
+}