@yr-lang/yr 0.1.1 → 0.2.0

package/BUGS.md

@@ -3,21 +3,10 @@
 This file documents known bugs and limitations in yr.
 The project is under active development.
 
-### Wrapper-only section closure can fail
+### Wrapper-only section closure ✓ Fixed in 0.2.0
 
-In some cases, a section cannot be closed using only a wrapper, and must instead be closed explicitly with an element (_).
-
-For example, the following may result in an error:
-
-```
-++
-_ .teste
-  _wrapper/test
-    _ .teste2
-    _wrapper/test2
-```
-
-However, explicitly closing the section with elements works as expected:
+Previously, a section could not always be closed using only a wrapper and required an explicit
+`_` element. This has been resolved — the following now works as expected:
 
 ```
 ++
@@ -25,11 +14,4 @@ _ .teste
   _wrapper/test
     _ .teste2
     _wrapper/test2
-    _
-  _
 ```
-
-#### Notes
-
-* This appears to be related to how section termination is detected when the last node is a wrapper.
-* The parser may not recognize wrappers as valid closing tokens in some nesting scenarios.

package/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+## [0.2.0] - 2026-03-01
+
+### Fixed
+
+- **Wrapper-only section closure** — Sections containing nested wrappers no longer require an
+  explicit `_` to close. The parser now correctly closes open layers when a wrapper is terminated
+  by indentation, producing balanced HTML in all nesting scenarios. Resolves the issue documented
+  in `BUGS.md`.
+
+- **Multiple wrapper closure on a single line** — When an element's indentation requires closing
+  more than one wrapper at once, the parser now closes all of them (changed `if` to `while` in
+  the html parser wrapper check). Previously only the innermost wrapper was closed, causing
+  sibling elements to be rendered inside the wrong wrapper.
+
+- **Section change leaves wrappers open** — When a namespace token (e.g. `><` → `##`) was
+  encountered while one or more wrappers were active, only the outermost wrapper was cleaned up
+  via `shift()`. Now all open wrappers are properly closed innermost-first.
+
+- **Closing tag indentation** — `getWhiteSpace()` was designed to receive a hierarchy level but
+  was called with a raw character-count indentation, producing increasingly wrong whitespace for
+  deeper elements. Closing tags now mirror the indentation of their opening tags.
+
+- **`throw -1` loses file/project context** — A stray semicolon caused the error message for
+  odd-indentation errors to drop the filename and project name. The `-1` error message now
+  matches the `-2` error message in completeness.
+
+- **`getElementAttributes` spurious empty key** — When an `att={{}}` block ended with a trailing
+  comma, an empty string key was unconditionally added to the parsed attributes object. Now only
+  added if `parseKey` is non-empty.
+
+- **Self-importing wrapper causes infinite recursion** — A wrapper that listed itself via `!!`
+  in its own `++` section would loop indefinitely. The extension is now registered in
+  `sections.extensions` before its content is parsed, so the guard fires correctly on
+  re-entry.
+
+- **Wrapper without `++` section does not invoke JS function** — A wrapper that had a
+  `_@wrapper(Category, Option)` function in `@>` but no `++` body would have its div created
+  but the JS function never called. The `wrapperjs` entry is now added independently of whether
+  a `++` section exists.
+
+## [0.1.1] - prior
+
+Initial public releases.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yr-lang/yr",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Yr is a modern structural language and parser",
   "main": "./node.js",
   "exports": {
@@ -9,6 +9,6 @@
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
-    "url": "https://github.com/yr-lang/yr"
+    "url": "git+https://github.com/yr-lang/yr.git"
   }
 }

package/yr.js

@@ -17,10 +17,11 @@ const utils = {
 };
 
 const common = {
+  // Bug fix: was using new Array((i*2)-1).join which was designed for 'level' units,
+  // but is called with raw indentation (char count). Use simple repeat instead.
   getWhiteSpace(indentation) {
-    try {
-      return new Array((indentation * 2) - 1).join(' ');
-    } catch(error) { return ''; }
+    if (!indentation || indentation < 0) return '';
+    return ' '.repeat(indentation);
   }
 };
 
@@ -140,7 +141,9 @@ function getElementAttributes(line) {
     lastChar = value;
   }
 
-  parse[parseKey.trim()] = parseValue.trim();
+  // Bug fix: only add the last key-value if parseKey is non-empty
+  // (avoids adding a spurious empty key when attrs end with a trailing comma)
+  if (parseKey.trim()) parse[parseKey.trim()] = parseValue.trim();
   parseKey = '', parseValue = '';
   return { ...attributes, ...parse };
 }
@@ -234,16 +237,32 @@ const parserFns = {
     }
     yrParsedLine = addIdToElement(yrParsedLine, config, elementId);
     let yrIndentation = 0, ignoreYr, wildCard = '', replaceYr;
-    if (state.wrapper.length > 0) {
+    // Bug fix: use while loop to close ALL wrappers that need closing (not just one)
+    // A single element may need to close multiple nested wrappers at once
+    while (state.wrapper.length > 0) {
       let wrapper = state.wrapper[state.wrapper.length - 1];
       if (parsedLine.indentation >= wrapper.reference) {
         yrIndentation = wrapper.new - wrapper.reference + 2;
         replaceYr = sections.yr[section].includes('#@#\n');
+        break; // Still inside this wrapper, stop closing
       } else {
-        wrapper = state.wrapper[state.wrapper.length - 1];
         sections.yr[section] = sections.yr[section].replace(/#@#\n/, '');
+        // Close any layers that were opened inside this wrapper before popping it
+        for (let j = state.layers.length - 1; j >= 0; j--) {
+          const layer = state.layers[j];
+          if (!layer) continue;
+          // Only close layers that belong inside this wrapper (indentation >= wrapper.reference)
+          if (layer.indentation >= wrapper.reference) {
+            sections[layer.section] +=
+              layer.whiteSpace + `</${layer.tag}>\n`;
+            state.layers.pop();
+          } else {
+            break;
+          }
+        }
         if (wrapper.wildCard) sections[section] += wrapper.wildCard + '\n';
         state.wrapper.pop();
+        // After popping, loop again to check if we need to close more wrappers
       }
     }
     if (yrIndentation < 0) yrIndentation = 0;
@@ -257,7 +276,7 @@ const parserFns = {
     }
     if (parsedLine.indentation !== -1) {
       if (parsedLine.indentation % 2 !== 0)
-        throw `-1: indentation error at line ${lineNumber}` + '';
+        throw `-1: indentation error at line ${lineNumber}` + '' +
           ` (${config.name}.yr, ${config.project}):\n\n"""\n${line}\n"""`;
       if (parsedLine.level > state.level + 1)
         throw `-2: indentation error at line ${lineNumber}` + '' +
@@ -333,33 +352,28 @@ const parserFns = {
           state.wrapper.push(newWrapper);
           wrapperIndentation = parsedLine.indentation;
         }
+        // Always set up element attributes for wrapperjs call,
+        // even if wrapper has no ++ section (no wrapperbody)
+        elementAttributes.id = elementId;
+        elementAttributes.category = wrapper[0];
+        elementAttributes.option = wrapper[1];
+        let attributes = [];
+        try {
+          attributes = sections.wrappers[wrapperName]
+            ? sections.wrappers[wrapperName].vars.attributes
+            : sections.vars.attributes;
+        } catch(error) {/* pass */}
+        if (!attributes) attributes = sections.vars.attributes;
+        elementAttributes.attributes = attributes;
+        // Call the JS wrapper function if it exists, regardless of whether ++ is present
+        if (sections.jsheader
+        .includes(`function __${wrapperName.replace(/\//, '_')}(`)
+        && !sections.wrapperjs.includes(`"id":"${elementId}"`)) {
+          const wrapperjs =
+            `__${wrapperName.replace(/\//, '_')}(${JSON.stringify(elementAttributes)});\n`;
+          sections.wrapperjs += wrapperjs;
+        }
         if (sections.wrappers[wrapperName]) {
-          elementAttributes.id = elementId;
-          elementAttributes.category = wrapper[0];
-          elementAttributes.option = wrapper[1];
-          let attributes = [];
-          try {
-            attributes = sections.wrappers[wrapperName].vars.attributes;
-          } catch(error) {
-            console.log(wrapperName);
-            console.log(sections.wrappers[wrapperName]);
-            console.log(parsedLine);
-            console.log(error);
-            throw error;
-          }
-          if (!attributes) attributes = sections.vars.attributes;
-          elementAttributes.attributes = attributes;
-          let redone;
-          try {
-            redone = !sections.wrappers[wrapperName].redone;
-          } catch(error) {/* pass */}
-          if (sections.jsheader
-          .includes(`function __${wrapperName.replace(/\//, '_')}(`)
-          && !sections.wrapperjs.includes(`"id":"${elementId}"`)) {
-            const wrapperjs =
-              `__${wrapperName.replace(/\//, '_')}(${JSON.stringify(elementAttributes)});\n`;
-            sections.wrapperjs += wrapperjs;
-          }
           if (!tag.includes('!')) {
             if (sections.wrappers[wrapperName].yrwrapperbody) {
               for (let value of sections.wrappers[wrapperName]
@@ -627,6 +641,10 @@ const core = {
         return;
       }
 
+      // Bug fix: register extension BEFORE parsing its content
+      // to prevent infinite recursion when a wrapper imports itself via !!
+      sections.extensions += '!! ' + wrapperName + '\n';
+
       const _yr = sections.yr;
       sections.yr = {};
 
@@ -640,8 +658,6 @@ const core = {
         sections, wrapper: `${wrapper.join('/')}`, ...config
       });
 
-      sections.extensions += '!! ' + wrapperName + '\n';
-
         if (!sections.wrappers[wrapperName])
           sections.wrappers[wrapperName] = {};
 
@@ -715,16 +731,25 @@ const core = {
         section = parsers.namespaces[line].name;
         state.sectionChanged = true;
 
-        if (state.wrapper.length > 0) {
-          const wrapper = state.wrapper[0];
+        // Bug fix: close ALL open wrappers when section changes, innermost first (pop, not shift)
+        while (state.wrapper.length > 0) {
+          const wrapper = state.wrapper[state.wrapper.length - 1];
 
           sections.yr[wrapper.section] =
             sections.yr[wrapper.section].replace(/#@#\n/, '');
 
+          // Close layers created inside this wrapper
+          for (let j = state.layers.length - 1; j >= 0; j--) {
+            const layer = state.layers[j];
+            if (!layer || layer.indentation < wrapper.reference) break;
+            sections[layer.section] += layer.whiteSpace + `</${layer.tag}>\n`;
+            state.layers.pop();
+          }
+
           if (wrapper.wildCard)
             sections[wrapper.section] += wrapper.wildCard + '\n';
 
-          state.wrapper.shift();
+          state.wrapper.pop();
         }
 
         continue;
@@ -861,15 +886,17 @@ const core = {
         sections[wrapper.section] += wrapper.wildCard + '\n';
 
 
-      for (let j = wrapper.layers.length - 1; j >= 0; j--) {
-        const layer = wrapper.layers[j];
+      // Only close layers that were created INSIDE this wrapper (indentation >= wrapper.reference)
+      // External layers (pre-existing before the wrapper) should NOT be closed here
+      for (let j = state.layers.length - 1; j >= 0; j--) {
+        const layer = state.layers[j];
         if (!layer) continue;
+        if (layer.indentation < wrapper.reference) break;
 
         sections[layer.section] +=
-          common.getWhiteSpace(layer.indentation) + `</${layer.tag}>\n`;
+          layer.whiteSpace + `</${layer.tag}>\n`;
 
-        wrapper.layers.pop();
-        state.layers = state.layers.filter(e => e !== layer);
+        state.layers.pop();
       }
 
       state.wrapper.pop();