@jondotsoy/don 0.0.2

package/README.md

@@ -0,0 +1,416 @@
+# DON: Directive Object Notation
+
+DON es un formato de serialización de datos legible por humanos, diseñado alrededor del concepto de directivas y subdirectivas. Combina la simplicidad de una sintaxis declarativa con la flexibilidad de estructuras anidadas, permitiendo definir configuraciones jerárquicas usando bloques de directivas intuitivos. Cada directiva puede aceptar argumentos y contener subdirectivas anidadas, haciéndolo ideal para archivos de configuración, definiciones de infraestructura y representación de datos estructurados donde la legibilidad y expresividad son prioridades.
+
+## Características Principales
+
+- **Sintaxis Minimalista**: Menos caracteres especiales, más legibilidad
+- **Procesamiento Secuencial**: Las directivas se procesan como un pipeline, permitiendo sobrescritura y composición incremental
+- **Anidación Flexible**: Soporta jerarquías de cualquier profundidad
+- **Múltiples Tipos de Datos**: Keywords, strings, numbers, booleans y null
+- **Comentarios**: Soporta comentarios de línea (`//`, `#`) y multilínea (`/* */`)
+- **Sin Ambigüedades**: Reglas claras de parsing y delimitación
+
+## Instalación
+
+```bash
+npm install @jondotsoy/don
+```
+
+```bash
+bun add @jondotsoy/don
+```
+
+## Uso Básico
+
+```typescript
+import { DocumentEncoder, LexerEncoder } from "@jondotsoy/don";
+
+// Parsear un documento DON
+const source = `
+name "my-app"
+version 1.0.0
+container {
+  image "nginx"
+  port 8080
+}
+`;
+
+const lexer = new LexerEncoder();
+const tokens = lexer.encode(source);
+
+const document = new DocumentEncoder();
+const directives = document.encode(tokens);
+
+console.log(directives);
+```
+
+## Sintaxis Básica
+
+### Estructura de una Directiva
+
+Una directiva tiene la siguiente estructura:
+
+```
+<nombre> [argumentos...] [{ subdirectivas }]
+```
+
+**Componentes:**
+
+- **Nombre**: Identificador de la directiva (keyword, string, number o boolean)
+- **Argumentos**: Cero o más valores separados por espacios
+- **Bloque**: Opcional, contiene subdirectivas entre llaves `{ }`
+
+### Ejemplos
+
+**Directivas simples:**
+
+```don
+name "my-app"
+version 1.0.0
+enabled true
+port 8080
+```
+
+**Directivas con bloques:**
+
+```don
+container {
+  image "nginx"
+  port 8080
+}
+```
+
+**Directivas con argumentos y bloques:**
+
+```don
+service "web" replicas 3 {
+  container "nginx" {
+    port 80
+    image "nginx:latest"
+  }
+}
+```
+
+**Directivas repetidas:**
+
+```don
+container {
+  image "nginx"
+  port 80
+}
+
+container {
+  image "redis"
+  port 6379
+}
+```
+
+## Tipos de Datos
+
+DON reconoce los siguientes tipos de tokens:
+
+- **Keywords**: Identificadores que comienzan con letra o guion bajo (`name`, `version`, `container`)
+- **Strings**: Cadenas de texto entre comillas dobles o simples (`"texto"`, `'texto'`)
+  - Soportan caracteres escapados: `\"`, `\'`, `\\`
+- **Numbers**: Enteros o decimales (`123`, `45.67`)
+  - Pueden incluir guiones bajos como separadores: `1_000_000`
+- **Booleans**: Valores `true` o `false`
+- **Null**: Valor nulo `null`
+- **Punctuators**: Símbolos delimitadores: `{`, `}`, `[`, `]`, `,`, `+`, `-`, `/`, `*`, `<`, `>`
+- **Comments**:
+  - Línea: `// comentario` o `# comentario`
+  - Multilínea: `/* comentario */`
+
+## Reglas de Sintaxis
+
+1. **Nombre de directiva**: Puede ser un keyword, string, number o boolean
+2. **Argumentos**: Cero o más tokens separados por espacios
+3. **Bloque de subdirectivas**: Opcional, delimitado por llaves `{ }`
+4. **Delimitación**: Las directivas se separan por saltos de línea
+5. **Anidación**: Las subdirectivas siguen las mismas reglas
+6. **Restricción**: No puede haber tokens después de un bloque en la misma línea
+
+**Sintaxis válida:**
+
+```don
+// Directiva simple
+name "my-app"
+version 1.0.0
+
+// Directiva con bloque
+container {
+  image "nginx"
+  port 8080
+}
+
+// Comentarios
+# Comentario de línea
+/* Comentario multilínea */
+```
+
+**Sintaxis inválida:**
+
+```don
+// ❌ Tokens después del bloque
+container { image "nginx" } extra
+
+// ❌ String sin cerrar
+name "unclosed
+```
+
+## Casos de Uso
+
+### Archivos de Configuración
+
+```don
+app "my-service" {
+  version 2.1.0
+  environment "production"
+
+  database {
+    host "localhost"
+    port 5432
+    name "mydb"
+  }
+
+  cache {
+    enabled true
+    ttl 3600
+  }
+}
+```
+
+### Definiciones de Infraestructura (Kubernetes)
+
+```yaml
+apiVersion: v1
+kind: Pod
+metadata:
+  name: command-demo
+  labels:
+    purpose: demonstrate-command
+spec:
+  containers:
+    - name: command-demo-container
+      image: debian
+      command: ["printenv"]
+      args: ["HOSTNAME", "KUBERNETES_PORT"]
+  restartPolicy: OnFailure
+```
+
+```don
+apiVersion v1 {
+  pod {
+    metadata {
+      name "command-demo"
+      labels {
+        purpose "demonstrate-command"
+      }
+    }
+    spec {
+      restartPolicy "OnFailure"
+      container debian "command-demo-container" {
+        command printenv HOSTNAME KUBERNETES_PORT
+      }
+    }
+  }
+}
+```
+
+### Schemas de Datos
+
+```don
+schema "user" {
+  id integer primaryKey autoIncrement
+  email string unique required
+  name string required
+  createdAt timestamp default now
+}
+```
+
+### Reglas de Seguridad (Firebase)
+
+```don
+service "firebase.storage" {
+  match "/b/{bucket}/o" {
+    match "/someFolder/{fileName}" {
+      allow read write {
+        if "request.auth" "!=" null
+      }
+    }
+  }
+}
+```
+
+### Servicios con Múltiples Contenedores
+
+```don
+service "my-service" {
+  replicas 2
+  container {
+    image "my-image"
+    port 8080
+  }
+  container {
+    image "my-other-image"
+    port 8081
+  }
+}
+```
+
+## Equivalencias con JSON
+
+DON ofrece una sintaxis más limpia y legible para representar estructuras de datos comunes en JSON:
+
+**Propiedades simples:**
+
+- `{"name":"foo"}` → `name "foo"`
+- `{"version":1}` → `version 1`
+- `{"private": true}` → `private true`
+
+**Objetos anidados:**
+
+```json
+{ "name": "foo", "meta": { "format": "json", "version": 1 } }
+```
+
+```don
+name "foo"
+meta {
+  format "json"
+  version 1
+}
+```
+
+**Arrays o Listas:**
+
+```json
+{ "icons": ["foo", "taz"] }
+```
+
+```don
+icons {
+  icon "foo"
+  icon "taz"
+}
+```
+
+## Equivalencias con YAML
+
+DON puede representar estructuras YAML de manera más concisa. Los tags de YAML (como `!!date`, `!!str`, `!!int`) se convierten en nombres de directivas en DON:
+
+**Tags de tipo:**
+
+```yaml
+---
+createdAt: !!date 2002-04-28
+count: !!int 42
+description: !!str "Hello World"
+enabled: !!bool true
+```
+
+```don
+createdAt date "2002-04-28"
+count int 42
+description str "Hello World"
+enabled bool true
+```
+
+**Objetos anidados con tags:**
+
+```yaml
+---
+metadata:
+  createdAt: !!date 2002-04-28
+  version: !!int 1
+```
+
+```don
+metadata {
+  createdAt date "2002-04-28"
+  version int 1
+}
+```
+
+## Inspiración
+
+DON toma inspiración de la sintaxis de Python para el paso de argumentos, permitiendo tanto argumentos posicionales como argumentos con nombre:
+
+```python
+# Python - Argumentos posicionales
+print("foo")
+
+# Python - Argumentos con nombre
+dict(name="foo")
+
+# Python - Combinación
+Container("nginx", replicas=3, port=80)
+```
+
+```don
+# DON - Argumentos posicionales
+print "foo"
+
+# DON - Argumentos con nombre (mediante subdirectivas)
+dict {
+  name "foo"
+}
+
+# DON - Combinación
+Container "nginx" {
+  replicas 3
+  port 80
+}
+```
+
+## Desarrollo
+
+### Scripts Disponibles
+
+```bash
+# Compilar el proyecto
+npm run build
+
+# Limpiar archivos compilados
+npm run clean
+
+# Formatear código
+npm run fmt
+
+# Verificar formato
+npm run lint
+```
+
+### Estructura del Proyecto
+
+```
+.
+├── src/              # Código fuente TypeScript
+│   ├── lexer.ts      # Analizador léxico
+│   ├── document.ts   # Parser de documentos
+│   ├── chunk.ts      # Manejo de chunks
+│   └── utils/        # Utilidades
+├── lib/              # Código compilado
+│   └── esm/          # Módulos ES
+├── docs/             # Documentación
+└── index.ts          # Punto de entrada
+```
+
+## Documentación
+
+Para más información sobre DON, consulta la [documentación completa](./docs/index.md):
+
+- [Formato .DON](./docs/don-file.md): Especificación completa del formato
+- [Directivas](./docs/concepts/directive.md): Anatomía y uso de directivas
+- [Heredocs](./docs/concepts/heredoc.md): Contenido multilínea
+- [Tipos de Datos](./docs/concepts/types/): Especificación de tipos soportados
+- [Inspiración](./docs/inspiration.md): Objetivos y visión del proyecto
+
+## Licencia
+
+MIT
+
+## Autor
+
+[@jondotsoy](https://github.com/jondotsoy)

package/lib/esm/chunk.d.ts

@@ -0,0 +1,28 @@
+export declare class Chunk {
+    readonly pos: number;
+    readonly length: number;
+    readonly value: Iterable<number>;
+    readonly debug_str: string;
+    constructor(pos: number, length: number, value: Iterable<number>, debug_str?: string);
+}
+export declare class ChunkList {
+    readonly length: number;
+    readonly chunks: Iterable<Chunk>;
+    constructor(length: number, chunks: Iterable<Chunk>);
+}
+export declare class Expression {
+    readonly m: number[];
+    constructor(m: number[]);
+    test(buff: number[], fromIndex: number): boolean;
+    exec(buff: number[], fromIndex: number): number[];
+    static keywordExpression: Expression;
+    static spaceExpression: Expression;
+}
+type LexerEncoderOptions = {};
+export declare class ChunkEncoder {
+    private options?;
+    constructor(options?: LexerEncoderOptions | undefined);
+    encode(buff: string | Iterable<number>): ChunkList;
+}
+export {};
+//# sourceMappingURL=chunk.d.ts.map

package/lib/esm/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../src/chunk.ts"],"names":[],"mappings":"AAAA,qBAAa,KAAK;IAEd,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS;gBAHT,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,SAAS,SAEjB;CAEJ;AAED,qBAAa,SAAS;IAElB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC;gBADvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC;CAEnC;AAKD,qBAAa,UAAU;IACT,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE;gBAAX,CAAC,EAAE,MAAM,EAAE;IAEhC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAMhD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IAUjD,MAAM,CAAC,iBAAiB,aASrB;IAEH,MAAM,CAAC,eAAe,aAAwB;CAC/C;AAED,KAAK,mBAAmB,GAAG,EAAE,CAAC;AAE9B,qBAAa,YAAY;IACX,OAAO,CAAC,OAAO,CAAC;gBAAR,OAAO,CAAC,EAAE,mBAAmB,YAAA;IAEjD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS;CAiCnD"}

package/lib/esm/chunk.js

@@ -0,0 +1,84 @@
+export class Chunk {
+    pos;
+    length;
+    value;
+    debug_str;
+    constructor(pos, length, value, debug_str = JSON.stringify(new TextDecoder().decode(new Uint8Array(value)))) {
+        this.pos = pos;
+        this.length = length;
+        this.value = value;
+        this.debug_str = debug_str;
+    }
+}
+export class ChunkList {
+    length;
+    chunks;
+    constructor(length, chunks) {
+        this.length = length;
+        this.chunks = chunks;
+    }
+}
+const range = (start, end) => Array.from({ length: -start + end + 1 }, (_, i) => i + start);
+export class Expression {
+    m;
+    constructor(m) {
+        this.m = m;
+    }
+    test(buff, fromIndex) {
+        const charCode = buff[fromIndex];
+        if (charCode === undefined)
+            return false;
+        return this.m.includes(charCode);
+    }
+    exec(buff, fromIndex) {
+        let end = fromIndex;
+        while (end < buff.length && this.test(buff, end)) {
+            end++;
+        }
+        return buff.slice(fromIndex, end);
+    }
+    static keywordExpression = new Expression([
+        // a-z (97 ... 122)
+        ...range(97, 122),
+        // A-Z (65 ... 90)
+        ...range(65, 90),
+        // _ (95)
+        95,
+        // 0-9 (48 ... 57)
+        ...range(48, 57),
+    ]);
+    static spaceExpression = new Expression([32]);
+}
+export class ChunkEncoder {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    encode(buff) {
+        const numberIterable = typeof buff === "string" ? new TextEncoder().encode(buff) : buff;
+        const bytes = Array.from(numberIterable);
+        const tokens = [];
+        let pos = 0;
+        const expressions = [
+            Expression.keywordExpression,
+            Expression.spaceExpression,
+        ];
+        while (pos < bytes.length) {
+            const charCode = bytes[pos];
+            if (charCode === undefined)
+                break;
+            const expression = expressions.find((expression) => expression.test(bytes, pos));
+            if (expression) {
+                const value = expression.exec(bytes, pos);
+                tokens.push(new Chunk(pos, value.length, value));
+                pos += value.length;
+                continue;
+            }
+            // Symbols
+            tokens.push(new Chunk(pos, 1, [charCode]));
+            pos++;
+        }
+        return new ChunkList(tokens.length, tokens);
+    }
+}
+//# sourceMappingURL=chunk.js.map

package/lib/esm/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.js","sourceRoot":"","sources":["../../src/chunk.ts"],"names":[],"mappings":"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"}

package/lib/esm/document.d.ts

@@ -0,0 +1,20 @@
+import { ChunkList } from "./chunk";
+import { Lexema, Token } from "./lexer";
+export declare class Directive {
+    readonly name: Token;
+    readonly args: Token[];
+    readonly children: Directive[];
+    constructor(name: Token, args: Token[], children: Directive[]);
+    static isDirective(doc: unknown): doc is Directive;
+}
+export declare class Document {
+    readonly children: Directive[];
+    constructor(children: Directive[]);
+    static isDocument(doc: unknown): doc is Document;
+}
+export declare class DocumentEncoder {
+    encode(input: string | Iterable<number> | ChunkList | Lexema): Document;
+    private segmentByBrackets;
+    private parseDirectives;
+}
+//# sourceMappingURL=document.d.ts.map

package/lib/esm/document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../src/document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAgB,MAAM,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEtD,qBAAa,SAAS;IAElB,QAAQ,CAAC,IAAI,EAAE,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,KAAK,EAAE;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE;gBAFrB,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,KAAK,EAAE,EACb,QAAQ,EAAE,SAAS,EAAE;IAGhC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,SAAS;CAGnD;AAED,qBAAa,QAAQ;IACP,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE;gBAArB,QAAQ,EAAE,SAAS,EAAE;IAE1C,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,QAAQ;CAGjD;AAUD,qBAAa,eAAe;IAC1B,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ;IAavE,OAAO,CAAC,iBAAiB;IAsCzB,OAAO,CAAC,eAAe;CAiGxB"}

package/lib/esm/document.js

@@ -0,0 +1,138 @@
+import { LexerEncoder, Lexema } from "./lexer";
+export class Directive {
+    name;
+    args;
+    children;
+    constructor(name, args, children) {
+        this.name = name;
+        this.args = args;
+        this.children = children;
+    }
+    static isDirective(doc) {
+        return doc instanceof Directive;
+    }
+}
+export class Document {
+    children;
+    constructor(children) {
+        this.children = children;
+    }
+    static isDocument(doc) {
+        return doc instanceof Document;
+    }
+}
+export class DocumentEncoder {
+    encode(input) {
+        const lexema = input instanceof Lexema ? input : new LexerEncoder().encode(input);
+        const tokens = Array.from(lexema.tokens);
+        // Segmentar por grupos de brackets
+        const groups = this.segmentByBrackets(tokens);
+        // Parsear las directivas
+        const directives = this.parseDirectives(tokens, 0, tokens.length, groups);
+        return new Document(directives);
+    }
+    segmentByBrackets(tokens) {
+        const groups = [];
+        const stack = [];
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (!token || token.type !== "punctuator")
+                continue;
+            const value = token.raw;
+            if (value === "{") {
+                stack.push({ type: "braces", openIndex: i });
+            }
+            else if (value === "}") {
+                const open = stack.pop();
+                if (open && open.type === "braces") {
+                    groups.push({
+                        openIndex: open.openIndex,
+                        closeIndex: i,
+                        type: "braces",
+                    });
+                }
+            }
+            else if (value === "[") {
+                stack.push({ type: "brackets", openIndex: i });
+            }
+            else if (value === "]") {
+                const open = stack.pop();
+                if (open && open.type === "brackets") {
+                    groups.push({
+                        openIndex: open.openIndex,
+                        closeIndex: i,
+                        type: "brackets",
+                    });
+                }
+            }
+        }
+        return groups;
+    }
+    parseDirectives(tokens, startIndex, endIndex, groups) {
+        const directives = [];
+        let i = startIndex;
+        while (i < endIndex) {
+            const token = tokens[i];
+            if (!token)
+                break;
+            // Skip newlines
+            if (token.type === "newline") {
+                i++;
+                continue;
+            }
+            // Skip closing brackets (ya fueron procesados)
+            if (token.type === "punctuator" &&
+                (token.raw === "}" || token.raw === "]")) {
+                break;
+            }
+            // Parse directive: only keyword, string, number, or boolean can be directive names
+            if (token.type === "keyword" ||
+                token.type === "string" ||
+                token.type === "number" ||
+                token.type === "boolean") {
+                const name = token;
+                const args = [];
+                i++;
+                // Collect arguments until newline, block start, or end
+                while (i < endIndex) {
+                    const argToken = tokens[i];
+                    if (!argToken ||
+                        argToken.type === "newline" ||
+                        (argToken.type === "punctuator" && argToken.raw === "{") ||
+                        (argToken.type === "punctuator" && argToken.raw === "}")) {
+                        break;
+                    }
+                    args.push(argToken);
+                    i++;
+                    // If we just added a heredoc, stop collecting arguments
+                    // because heredoc already includes its own newline
+                    if (argToken.type === "heredoc") {
+                        break;
+                    }
+                }
+                // Check for block - buscar el grupo que empieza en la posición actual
+                let children = [];
+                const group = groups.find((g) => g.openIndex === i && g.type === "braces");
+                if (group) {
+                    // Parsear recursivamente el contenido del grupo
+                    children = this.parseDirectives(tokens, group.openIndex + 1, group.closeIndex, groups);
+                    i = group.closeIndex + 1; // Saltar al final del grupo
+                    // After a block, there should be no more tokens before newline
+                    if (i < endIndex) {
+                        const nextToken = tokens[i];
+                        if (nextToken && nextToken.type !== "newline") {
+                            throw new Error(`Syntax error: Unexpected token after block. Expected newline but got ${nextToken.type} "${nextToken.raw}"`);
+                        }
+                    }
+                }
+                directives.push(new Directive(name, args, children));
+            }
+            else {
+                // Invalid directive name - throw syntax error
+                throw new Error(`Syntax error: Invalid directive name. Expected keyword, string, number, or boolean, but got ${token.type} "${token.raw}"`);
+            }
+        }
+        return directives;
+    }
+}
+//# sourceMappingURL=document.js.map