@nette/neon 1.0.0 → 1.0.1

package/dist/editing.js

@@ -34,12 +34,22 @@ export function setItemValue(item, value) {
     else {
         replaceValue(item, styledScalar(old, value) ?? Builder.value(value, placeOf(item, old, value)));
     }
-    guardDashSubblocks(item.parent);
+    guardGrammar(item.parent);
 }
 /** Puts the node into the value slot or empties it, without the comparison and styling of setItemValue(). */
 export function setItemNode(item, node) {
     replaceValue(item, node);
-    guardDashSubblocks(item.parent);
+    guardGrammar(item.parent);
+}
+/** Repairs what the grammar would read differently in the array after an edit. */
+function guardGrammar(array) {
+    if (array instanceof BlockArrayNode) {
+        guardEnd(array);
+        guardDashSubblocks(array);
+    }
+    else if (array instanceof InlineArrayNode) {
+        guardKeysWithoutValue(array);
+    }
 }
 /**
  * A dash right after a key at the same indentation reads as a dash subblock of that key.
@@ -47,10 +57,6 @@ export function setItemNode(item, node) {
  * subblock gets its key written out, which ends the subblock.
  */
 function guardDashSubblocks(block) {
-    if (!(block instanceof BlockArrayNode)) {
-        return;
-    }
-    guardEnd(block);
     block.items.forEach((item, i) => {
         const next = block.items[i + 1];
         if (!item.key || !next?.bullet) {
@@ -64,6 +70,15 @@ function guardDashSubblocks(block) {
         }
     });
 }
+/** Keeps an item without a key from reading as the value of a key without a value on the line above. */
+function guardKeysWithoutValue(array) {
+    array.items.forEach((item, i) => {
+        const next = array.items[i + 1];
+        if (item.key && item.value === null && !item.separator && next && !next.key) {
+            replaceValue(item, literal('null'));
+        }
+    });
+}
 /** Spaces on the last line of the input would be read as the indentation of a missing value at the end. */
 function guardEnd(at) {
     let root = at;
@@ -292,7 +307,7 @@ export function addItem(array, key, value, position) {
         ? addToBlock(array, key, value, at)
         : addToInline(array, key, value, at);
     keepKeys(array, before, key === null);
-    guardDashSubblocks(array);
+    guardGrammar(array);
     return item;
 }
 /** The keys of the items before an edit, and whether they made a list. */
@@ -464,7 +479,7 @@ export function insertItem(array, item, at) {
         }
     }
     keepKeys(array, before, key === null);
-    guardDashSubblocks(array);
+    guardGrammar(array);
 }
 /**
  * The comments an item owns at its edges, which an inline array cannot keep in place: the comment lines
@@ -643,7 +658,7 @@ export function removeItem(item, comments, nullable, mergeBlankLines = false) {
     }
     array[setItems](remaining);
     keepKeys(array, before, true); // an item removed from a list renumbers the rest, whatever its key
-    guardDashSubblocks(array);
+    guardGrammar(array);
 }
 function removeFromBlock(item, comments, mergeBlankLines) {
     const { preamble, owned } = splitLeading(item.getFirstToken().leadingTrivia);
@@ -704,7 +719,7 @@ function emptyBlock(block, last, leaveNull) {
     if (!leaveNull) {
         replaceValue(owner, emptyArray(last.key ? '{}' : '[]'));
     }
-    guardDashSubblocks(owner.parent);
+    guardGrammar(owner.parent);
 }
 /** The document lost its last item: the empty array, or nothing, keeps what stood above the item. */
 function emptyDocument(document, last, comments, leaveNull) {
@@ -806,7 +821,7 @@ export function setItemKey(item, key) {
     if (array && before) {
         before.keys.set(item, value);
         keepKeys(array, before, false);
-        guardDashSubblocks(array);
+        guardGrammar(array);
     }
 }
 // ---- nodes in slots
@@ -993,8 +1008,9 @@ export function setByPath(document, path, value, create) {
         setItemValue(existing, value);
         return;
     }
-    else if (!create || typeof last === 'object') {
-        throw new NeonError(`No item '${segmentText(last)}' in the path ${pathText(path)}, and create is false`);
+    else if (!create || typeof last === 'object') { // an item by its order is never made
+        const missing = `No item '${segmentText(last)}' in the path ${pathText(path)}`;
+        throw new NeonError(create ? missing : missing + ', and create is false');
     }
     const key = String(last);
     if (array) {

package/dist/parser.js

@@ -228,26 +228,47 @@ class Parser {
         const end = Pairs[open.kind];
         const items = [];
         const keys = new KeyCheck(this);
+        let next = null; // the key and the colon of the next item, read on the line after a key without a value
         while (true) {
-            while (this.consume('Newline')) {
-                ;
+            let head;
+            let colon;
+            if (next) {
+                [head, colon] = next;
+                next = null;
             }
-            const close = this.consumeToken(end);
-            if (close) {
-                return new InlineArrayNode(open, items, close);
+            else {
+                while (this.consume('Newline')) {
+                    ;
+                }
+                const close = this.consumeToken(end);
+                if (close) {
+                    return new InlineArrayNode(open, items, close);
+                }
+                head = this.parseValue();
+                colon = this.consumeColon();
             }
-            const head = this.parseValue();
             let item;
-            const colon = this.consumeToken('Colon', 'Equals');
             if (colon) {
                 const key = keys.add(head);
-                const value = this.isNext('Newline', 'Comma', end) ? null : this.parseValue();
+                let value = null;
+                const lineEnd = this.consume('Newline');
+                if (!this.isNext('Comma', end)) {
+                    value = this.parseValue();
+                    const nextColon = lineEnd ? this.consumeColon() : null;
+                    if (nextColon) {
+                        next = [value, nextColon];
+                        value = null;
+                    }
+                }
                 item = keys.item(null, key, colon, value);
             }
             else {
                 item = keys.item(null, null, null, head);
             }
             items.push(item);
+            if (next) {
+                continue;
+            }
             const before = this.mark();
             while (this.consume('Newline')) {
                 ;
@@ -264,6 +285,19 @@ class Parser {
             }
         }
     }
+    /** The colon or the equals sign after a key in an inline array, which may stand on a later line. */
+    consumeColon() {
+        const mark = this.mark();
+        while (this.consume('Newline')) {
+            ;
+        }
+        const colon = this.consumeToken('Colon', 'Equals');
+        if (!colon) {
+            this.#i = mark.i;
+            this.#newlineTaken = mark.newlineTaken;
+        }
+        return colon;
+    }
     /** One level deeper into arrays. */
     enter(token) {
         if (++this.#depth > MaxDepth) {

package/dist/values.d.ts

@@ -37,7 +37,7 @@ export declare class NeonDate {
     static parse(text: string): NeonDate | null;
     /** Converts the date to an instant; a local date needs the time zone offset in minutes or 'UTC'. */
     toDate(zone?: 'UTC' | number): Date;
-    /** The date as the encoder writes it. */
+    /** The date as the encoder writes it, without the fraction of a second. */
     toString(): string;
     /** Equality of components, including the presence of an offset and the written fraction. */
     equals(other: NeonDate): boolean;

package/dist/values.js

@@ -93,15 +93,12 @@ export class NeonDate {
         res.setUTCHours(this.hour ?? 0, (this.minute ?? 0) - offset, this.second ?? 0, ms);
         return res;
     }
-    /** The date as the encoder writes it. */
+    /** The date as the encoder writes it, without the fraction of a second. */
     toString() {
         const pad = (n, width = 2) => String(n).padStart(width, '0');
         let res = `${pad(this.year, 4)}-${pad(this.month)}-${pad(this.day)}`;
         if (this.hour !== null) {
             res += ` ${pad(this.hour)}:${pad(this.minute)}:${pad(this.second)}`;
-            if (this.fraction) {
-                res += '.' + this.fraction;
-            }
         }
         if (this.offset) {
             res += ' ' + this.offset.replace(':', '');

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nette/neon",
-	"version": "1.0.0",
+	"version": "1.0.1",
 	"description": "NEON parser, encoder and lossless editor: change a value in a config file and keep its comments and formatting.",
 	"keywords": [
 		"neon",
@@ -28,7 +28,7 @@
 		}
 	},
 	"bin": {
-		"neon-lint": "./bin/neon-lint.js"
+		"neon-lint": "bin/neon-lint.js"
 	},
 	"files": [
 		"dist",

package/readme.md

@@ -71,8 +71,9 @@ note: '''
 '''
 ```
 
-JSON is a subset of NEON. The format is described at [ne-on.org](https://ne-on.org) and in the
-[manual](https://doc.nette.org/en/neon/format).
+JSON is a subset of NEON, except for a colon at the start of a line glued to its value
+(`"a"` + new line + `:1`), which NEON reads as a literal. The format is described at
+[ne-on.org](https://ne-on.org) and in the [manual](https://doc.nette.org/en/neon/format).
 
 ▶ Runnable examples: [examples/edge-cases](examples/edge-cases/)