links-notation 0.30.0 → 0.30.1

package/dist/index.js

@@ -348,7 +348,7 @@ class Link {
       return this._formatWithOptions(lessParentheses, isCompoundValue);
     }
     if (this.id === null && (!this.values || this.values.length === 0)) {
-      return lessParentheses ? "" : "()";
+      return "()";
     }
     if (!this.values || this.values.length === 0) {
       const escapedId = Link.escapeReference(this.id);
@@ -359,7 +359,7 @@ class Link {
     }
     const valuesStr = this.values.map((v) => this.formatValue(v)).join(" ");
     if (this.id === null) {
-      if (lessParentheses) {
+      if (lessParentheses && !this._hasLoneNestedValue()) {
         const allSimple = this.values.every((v) => !v.values || v.values.length === 0);
         if (allSimple) {
           const simpleValuesStr = this.values.map((v) => Link.escapeReference(v.id)).join(" ");
@@ -389,9 +389,12 @@ class Link {
   needsParentheses(str) {
     return str && (str.includes(" ") || str.includes(":") || str.includes("(") || str.includes(")"));
   }
+  _hasLoneNestedValue() {
+    return this.values.length === 1 && this.values[0].values?.length > 0;
+  }
   _formatWithOptions(options, isCompoundValue = false) {
     if (this.id === null && (!this.values || this.values.length === 0)) {
-      return options.lessParentheses ? "" : "()";
+      return "()";
     }
     if (!this.values || this.values.length === 0) {
       const escapedId = Link.escapeReference(this.id);
@@ -410,7 +413,7 @@ class Link {
         const idStr = Link.escapeReference(this.id);
         testLine = options.lessParentheses ? `${idStr}: ${valuesStr}` : `(${idStr}: ${valuesStr})`;
       } else {
-        testLine = options.lessParentheses ? valuesStr : `(${valuesStr})`;
+        testLine = options.lessParentheses && !this._hasLoneNestedValue() ? valuesStr : `(${valuesStr})`;
       }
       if (options.shouldIndentByLength(testLine)) {
         shouldIndent = true;
@@ -421,7 +424,7 @@ class Link {
     }
     const valuesStr = this.values.map((v) => this.formatValue(v)).join(" ");
     if (this.id === null) {
-      if (options.lessParentheses) {
+      if (options.lessParentheses && !this._hasLoneNestedValue()) {
         const allSimple = this.values.every((v) => !v.values || v.values.length === 0);
         if (allSimple) {
           return this.values.map((v) => Link.escapeReference(v.id)).join(" ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "links-notation",
-  "version": "0.30.0",
+  "version": "0.30.1",
   "description": "Links Notation parser for JavaScript",
   "main": "dist/index.js",
   "types": "index.d.ts",

package/src/Link.js

@@ -196,7 +196,7 @@ export class Link {
     // Original implementation for backward compatibility
     // Empty link
     if (this.id === null && (!this.values || this.values.length === 0)) {
-      return lessParentheses ? '' : '()';
+      return '()';
     }
 
     // Link with only ID, no values
@@ -217,7 +217,7 @@ export class Link {
     // Link with values only (null id)
     if (this.id === null) {
       // For lessParentheses mode with simple values, don't wrap the whole thing
-      if (lessParentheses) {
+      if (lessParentheses && !this._hasLoneNestedValue()) {
         // Check if all values are simple (no nested values)
         const allSimple = this.values.every(
           (v) => !v.values || v.values.length === 0
@@ -288,6 +288,16 @@ export class Link {
     );
   }
 
+  /**
+   * Whether this link holds exactly one link that has values. The parentheses
+   * of an anonymous link are what nest such a value: `((b c))` without them is
+   * `(b c)`, a different link, so lessParentheses has to keep them.
+   * @returns {boolean} True if the only value has values of its own
+   */
+  _hasLoneNestedValue() {
+    return this.values.length === 1 && this.values[0].values?.length > 0;
+  }
+
   /**
    * Format the link using a FormatOptions object
    * @param {FormatOptions} options - FormatOptions object with formatting options
@@ -297,7 +307,7 @@ export class Link {
   _formatWithOptions(options, isCompoundValue = false) {
     // Empty link
     if (this.id === null && (!this.values || this.values.length === 0)) {
-      return options.lessParentheses ? '' : '()';
+      return '()';
     }
 
     // Link with only ID, no values
@@ -325,7 +335,10 @@ export class Link {
           ? `${idStr}: ${valuesStr}`
           : `(${idStr}: ${valuesStr})`;
       } else {
-        testLine = options.lessParentheses ? valuesStr : `(${valuesStr})`;
+        testLine =
+          options.lessParentheses && !this._hasLoneNestedValue()
+            ? valuesStr
+            : `(${valuesStr})`;
       }
 
       if (options.shouldIndentByLength(testLine)) {
@@ -343,7 +356,7 @@ export class Link {
 
     // Link with values only (null id)
     if (this.id === null) {
-      if (options.lessParentheses) {
+      if (options.lessParentheses && !this._hasLoneNestedValue()) {
         const allSimple = this.values.every(
           (v) => !v.values || v.values.length === 0
         );

package/tests/SharedTextParity.test.js

@@ -1,7 +1,13 @@
 import { readFileSync } from 'node:fs';
 import { URL } from 'node:url';
 import { expect, test } from 'bun:test';
-import { Parser, StreamParser, formatLinks } from '../src/index.js';
+import {
+  FormatOptions,
+  Link,
+  Parser,
+  StreamParser,
+  formatLinks,
+} from '../src/index.js';
 
 const fixtures = JSON.parse(
   readFileSync(
@@ -25,3 +31,49 @@ test('shared text parity', () => {
     expect(tree(stream.end()), fixture.id).toEqual(fixture.expected);
   }
 });
+
+test('shared less parentheses round trip', () => {
+  const options = new FormatOptions({ lessParentheses: true });
+  for (const fixture of fixtures) {
+    const parsed = new Parser().parse(fixture.input);
+    expect(formatLinks(parsed, true), fixture.id).toBe(fixture.lessParentheses);
+    expect(formatLinks(parsed, options), fixture.id).toBe(
+      fixture.lessParentheses
+    );
+    expect(
+      tree(new Parser().parse(fixture.lessParentheses)),
+      fixture.id
+    ).toEqual(fixture.expected);
+    for (const link of parsed) {
+      const [readBack] = new Parser().parse(link.format(true));
+      expect(link.equals(readBack), fixture.id).toBe(true);
+    }
+  }
+});
+
+test('less parentheses keeps the parentheses of a lone nested value', () => {
+  const nested = new Link(null, [new Link('b'), new Link('c')]);
+  expect(new Link(null, [nested]).format(true)).toBe('((b c))');
+  expect(new Link(null, [new Link('b')]).format(true)).toBe('b');
+  expect(new Link(null, [new Link('a'), nested]).format(true)).toBe('a (b c)');
+});
+
+test('less parentheses keeps the parentheses of an empty link', () => {
+  const options = new FormatOptions({ lessParentheses: true });
+  expect(new Link(null, []).format(true)).toBe('()');
+  expect(new Link(null, []).format(options)).toBe('()');
+  expect(formatLinks([], true)).toBe('');
+});
+
+test('line length is measured on the parentheses a lone nested value keeps', () => {
+  const link = new Link(null, [new Link(null, [new Link('b'), new Link('c')])]);
+  const options = (maxLineLength) =>
+    new FormatOptions({
+      lessParentheses: true,
+      indentLongLines: true,
+      maxLineLength,
+      preferInline: false,
+    });
+  expect(link.format(options(7))).toBe('((b c))');
+  expect(link.format(options(6))).toBe('  (b c)');
+});