links-notation 0.8.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "links-notation",
+  "version": "0.8.0",
+  "description": "Lino protocol parser for JavaScript",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "build": "bun run build:grammar && bun build src/index.js --outdir=dist --target=node",
+    "build:grammar": "peggy --format es -o src/parser-generated.js src/grammar.pegjs",
+    "test": "bun test",
+    "test:watch": "bun test --watch"
+  },
+  "keywords": [
+    "lino",
+    "parser",
+    "protocol",
+    "links"
+  ],
+  "author": "",
+  "license": "Unlicense",
+  "devDependencies": {
+    "bun-types": "^1.2.19",
+    "peggy": "^5.0.6"
+  },
+  "dependencies": {}
+}

package/src/Link.js

@@ -0,0 +1,155 @@
+export class Link {
+  constructor(id = null, values = null) {
+    this.id = id;
+    this.values = values || [];
+  }
+
+  toString() {
+    return this.format(false);
+  }
+
+  getValuesString() {
+    return (!this.values || this.values.length === 0) ? 
+      '' : this.values.map(v => Link.getValueString(v)).join(' ');
+  }
+
+  simplify() {
+    if (!this.values || this.values.length === 0) {
+      return this;
+    } else if (this.values.length === 1) {
+      return this.values[0];
+    } else {
+      const newValues = this.values.map(v => v.simplify());
+      return new Link(this.id, newValues);
+    }
+  }
+
+  combine(other) {
+    return new Link(null, [this, other]);
+  }
+
+  static getValueString(value) {
+    return value.toLinkOrIdString();
+  }
+
+  static escapeReference(reference) {
+    if (!reference || reference.trim() === '') {
+      return '';
+    }
+    
+    const needsSingleQuotes = 
+      reference.includes(':') ||
+      reference.includes('(') ||
+      reference.includes(')') ||
+      reference.includes(' ') ||
+      reference.includes('\t') ||
+      reference.includes('\n') ||
+      reference.includes('\r') ||
+      reference.includes('"');
+    
+    if (needsSingleQuotes) {
+      return `'${reference}'`;
+    } else if (reference.includes("'")) {
+      return `"${reference}"`;
+    } else {
+      return reference;
+    }
+  }
+
+  toLinkOrIdString() {
+    if (!this.values || this.values.length === 0) {
+      return this.id === null ? '' : Link.escapeReference(this.id);
+    }
+    return this.toString();
+  }
+
+  equals(other) {
+    if (!(other instanceof Link)) return false;
+    if (this.id !== other.id) return false;
+    if (this.values.length !== other.values.length) return false;
+    
+    for (let i = 0; i < this.values.length; i++) {
+      if (!this.values[i].equals(other.values[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  
+  format(lessParentheses = false, isCompoundValue = false) {
+    // Empty link
+    if (this.id === null && (!this.values || this.values.length === 0)) {
+      return lessParentheses ? '' : '()';
+    }
+    
+    // Link with only ID, no values
+    if (!this.values || this.values.length === 0) {
+      const escapedId = Link.escapeReference(this.id);
+      // When used as a value in a compound link (created from combining links), wrap in parentheses
+      if (isCompoundValue) {
+        return `(${escapedId})`;
+      }
+      return lessParentheses && !this.needsParentheses(this.id) ? escapedId : `(${escapedId})`;
+    }
+    
+    // Format values recursively  
+    const valuesStr = this.values.map(v => this.formatValue(v)).join(' ');
+    
+    // Link with values only (null id)
+    if (this.id === null) {
+      // For lessParentheses mode with simple values, don't wrap the whole thing
+      if (lessParentheses) {
+        // Check if all values are simple (no nested values)
+        const allSimple = this.values.every(v => !v.values || v.values.length === 0);
+        if (allSimple) {
+          // Format each value without extra wrapping
+          const simpleValuesStr = this.values.map(v => Link.escapeReference(v.id)).join(' ');
+          return simpleValuesStr;
+        }
+        // For mixed or complex values in lessParentheses mode, still avoid outer wrapper
+        // but keep the inner formatting
+        return valuesStr;
+      }
+      // For normal mode, wrap in parentheses
+      return `(${valuesStr})`;
+    }
+    
+    // Link with ID and values
+    const idStr = Link.escapeReference(this.id);
+    const withColon = `${idStr}: ${valuesStr}`;
+    return lessParentheses && !this.needsParentheses(this.id) ? withColon : `(${withColon})`;
+  }
+  
+  formatValue(value) {
+    if (!value.format) {
+      return Link.escapeReference(value.id || '');
+    }
+    
+    // Check if we're in a compound link that was created from path combinations
+    // This is indicated by having a parent context passed through
+    const isCompoundFromPaths = this._isFromPathCombination === true;
+    
+    // For compound links from paths, format values with parentheses
+    if (isCompoundFromPaths) {
+      return value.format(false, true);
+    }
+    
+    // Simple link with just an ID - don't wrap in parentheses when used as a value
+    if (!value.values || value.values.length === 0) {
+      return Link.escapeReference(value.id);
+    }
+    
+    // Complex value with its own structure - format it normally with parentheses
+    return value.format(false, false);
+  }
+  
+  needsParentheses(str) {
+    return str && (str.includes(' ') || str.includes(':') || str.includes('(') || str.includes(')'));
+  }
+}
+
+export function formatLinks(links, lessParentheses = false) {
+  if (!links || links.length === 0) return '';
+  return links.map(link => link.format(lessParentheses)).join('\n');
+}

package/src/LinksGroup.js

@@ -0,0 +1,30 @@
+export class LinksGroup {
+  constructor(element, children = []) {
+    this.element = element;
+    this.children = children;
+  }
+
+  toList() {
+    const result = [];
+    this._appendToList(result);
+    return result;
+  }
+
+  _appendToList(list) {
+    list.push(this.element);
+    if (this.children && this.children.length > 0) {
+      for (const child of this.children) {
+        if (child instanceof LinksGroup) {
+          child._appendToList(list);
+        } else {
+          list.push(child);
+        }
+      }
+    }
+  }
+
+  toString() {
+    const list = this.toList();
+    return list.map(item => `(${item.id || item})`).join(' ');
+  }
+}

package/src/Parser.js

@@ -0,0 +1,132 @@
+import { Link } from './Link.js';
+import * as parserModule from './parser-generated.js';
+
+export class Parser {
+  constructor() {
+  }
+
+  parse(input) {
+    try {
+      const rawResult = parserModule.parse(input);
+      return this.transformResult(rawResult);
+    } catch (error) {
+      throw new Error(`Parse error: ${error.message}`);
+    }
+  }
+
+  transformResult(rawResult) {
+    const links = [];
+    const items = Array.isArray(rawResult) ? rawResult : [rawResult];
+    
+    for (const item of items) {
+      if (item) {
+        this.collectLinks(item, [], links);
+      }
+    }
+    return links;
+  }
+
+  collectLinks(item, parentPath, result) {
+    if (!item) return;
+
+    // For items with children (indented structure)
+    if (item.children && item.children.length > 0) {
+      // Special case: If this is an ID with empty values but has children,
+      // the children should become the values of the link (indented ID syntax)
+      if (item.id && (!item.values || item.values.length === 0)) {
+        const childValues = item.children.map((child) => {
+          // For indented children, extract the actual reference from the child's values
+          if (child.values && child.values.length === 1) {
+            return this.transformLink(child.values[0]);
+          }
+          return this.transformLink(child);
+        });
+        const linkWithChildren = {
+          id: item.id,
+          values: childValues
+        };
+        const currentLink = this.transformLink(linkWithChildren);
+        
+        if (parentPath.length === 0) {
+          result.push(currentLink);
+        } else {
+          result.push(this.combinePathElements(parentPath, currentLink));
+        }
+      } else {
+        // Regular indented structure - process as before
+        const currentLink = this.transformLink(item);
+        
+        // Add the link combined with parent path
+        if (parentPath.length === 0) {
+          result.push(currentLink);
+        } else {
+          result.push(this.combinePathElements(parentPath, currentLink));
+        }
+        
+        // Process each child with this item in the path
+        const newPath = [...parentPath, currentLink];
+        
+        for (const child of item.children) {
+          this.collectLinks(child, newPath, result);
+        }
+      }
+    } else {
+      // Leaf item or item with inline values
+      const currentLink = this.transformLink(item);
+      
+      if (parentPath.length === 0) {
+        result.push(currentLink);
+      } else {
+        result.push(this.combinePathElements(parentPath, currentLink));
+      }
+    }
+  }
+  
+  combinePathElements(pathElements, current) {
+    if (pathElements.length === 0) return current;
+    if (pathElements.length === 1) {
+      const combined = new Link(null, [pathElements[0], current]);
+      combined._isFromPathCombination = true;
+      return combined;
+    }
+    
+    // For multiple path elements, we need to build proper nesting
+    // The last element in the path should be combined with its parent
+    const parentPath = pathElements.slice(0, -1);
+    const lastElement = pathElements[pathElements.length - 1];
+    
+    // Build the parent structure
+    let parent = this.combinePathElements(parentPath, lastElement);
+    
+    // Add current element to the built structure
+    const combined = new Link(null, [parent, current]);
+    combined._isFromPathCombination = true;
+    return combined;
+  }
+  
+
+  transformLink(item) {
+    if (!item) return null;
+    
+    if (item instanceof Link) {
+      return item;
+    }
+
+    // Handle simple reference objects like {id: 'a'}
+    if (item.id !== undefined && !item.values && !item.children) {
+      return new Link(item.id);
+    }
+
+    // For items with values, create a link with those values
+    if (item.values && Array.isArray(item.values)) {
+      // Create a link with id (if present) and transformed values
+      const link = new Link(item.id || null, []);
+      link.values = item.values.map(v => this.transformLink(v));
+      return link;
+    }
+    
+    // Default case
+    return new Link(item.id || null, []);
+  }
+
+}

package/src/grammar.pegjs

@@ -0,0 +1,86 @@
+{
+  let indentationStack = [0];
+  
+  function pushIndentation(spaces) {
+    indentationStack.push(spaces.length);
+  }
+  
+  function popIndentation() {
+    if (indentationStack.length > 1) {
+      indentationStack.pop();
+    }
+  }
+  
+  function checkIndentation(spaces) {
+    return spaces.length >= indentationStack[indentationStack.length - 1];
+  }
+  
+  function getCurrentIndentation() {
+    return indentationStack[indentationStack.length - 1];
+  }
+}
+
+document = _ links:links eof { return links; }
+  / _ eof { return []; }
+
+links = fl:firstLine list:line* { popIndentation(); return [fl].concat(list || []); }
+
+firstLine = l:element { return l; }
+
+line = CHECK_INDENTATION l:element { return l; }
+
+element = e:anyLink PUSH_INDENTATION l:links {
+    return { id: e.id, values: e.values, children: l };
+  }
+  / e:anyLink { return e; }
+
+referenceOrLink = l:multiLineAnyLink { return l; } / i:reference { return { id: i }; }
+
+anyLink = ml:multiLineAnyLink eol { return ml; } / il:indentedIdLink { return il; } / sl:singleLineAnyLink { return sl; }
+
+multiLineAnyLink = multiLineValueLink / multiLineLink
+
+singleLineAnyLink = fl:singleLineLink eol { return fl; }
+  / vl:singleLineValueLink eol { return vl; }
+
+multiLineValueAndWhitespace = value:referenceOrLink _ { return value; }
+
+multiLineValues = _ list:multiLineValueAndWhitespace* { return list; }
+
+singleLineValueAndWhitespace = __ value:referenceOrLink { return value; }
+
+singleLineValues = list:singleLineValueAndWhitespace+ { return list; }
+
+singleLineLink = __ id:reference __ ":" v:singleLineValues { return { id: id, values: v }; }
+
+multiLineLink = "(" _ id:reference _ ":" v:multiLineValues _ ")" { return { id: id, values: v }; }
+
+singleLineValueLink = v:singleLineValues { return { values: v }; }
+
+multiLineValueLink = "(" v:multiLineValues _ ")" { return { values: v }; }
+
+indentedIdLink = id:reference __ ":" eol { return { id: id, values: [] }; }
+
+reference = doubleQuotedReference / singleQuotedReference / simpleReference 
+
+simpleReference = chars:referenceSymbol+ { return chars.join(''); }
+
+doubleQuotedReference = '"' r:[^"]+ '"' { return r.join(''); }
+
+singleQuotedReference = "'" r:[^']+ "'" { return r.join(''); }
+
+PUSH_INDENTATION = spaces:" "* &{ return spaces.length > getCurrentIndentation(); } { pushIndentation(spaces); }
+
+CHECK_INDENTATION = spaces:" "* &{ return checkIndentation(spaces); }
+
+eol = __ ([\r\n]+ / eof)
+
+eof = !.
+
+__ = [ \t]*
+
+_ = whiteSpaceSymbol*
+
+whiteSpaceSymbol = [ \t\n\r]
+
+referenceSymbol = [^ \t\n\r(:)]

package/src/index.js

@@ -0,0 +1,3 @@
+export { Link, formatLinks } from './Link.js';
+export { LinksGroup } from './LinksGroup.js';
+export { Parser } from './Parser.js';