@vertekum/schema-builder 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @vertekum/schema-builder
 
+## 0.10.0
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @vertekum/core@0.10.0
+
 ## 0.9.0
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertekum/schema-builder",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Declare token vocabularies as grammar; build them into JSON Schema files",
   "license": "Apache-2.0",
   "keywords": [
@@ -37,13 +37,13 @@
     "./cli": "./src/cli.ts"
   },
   "peerDependencies": {
-    "@vertekum/core": "0.9.0"
+    "@vertekum/core": "0.10.0"
   },
   "dependencies": {
     "zod": "^3.25.76"
   },
   "devDependencies": {
-    "@vertekum/core": "0.9.0",
+    "@vertekum/core": "0.10.0",
     "@vertekum/schema-vocabulary": "0.3.0"
   }
 }

package/src/build.ts

@@ -169,7 +169,8 @@ function target(
       });
     }
   }
-  if (hits.length === 0) {
+  const [hit] = hits;
+  if (hit === undefined) {
     throw new DfnError(
       `no import provides '<@${ref.name}>'`,
       ref.line,
@@ -185,7 +186,7 @@ function target(
       file,
     );
   }
-  return hits[0];
+  return hit;
 }
 
 /**
@@ -276,9 +277,12 @@ function evaluate(node: Node, scope: Scope, tail: () => TreeNode): TreeNode {
       // Steps expand right to left: each step becomes the tail of the one before it. An
       // optional step (`?`) may be SKIPPED — its tail also attaches directly, so
       // `<role>.<emphasis>?.<interaction>?` grants the whole slot-collapse lattice.
+      const [first, ...rest] = node.steps;
+      if (first === undefined) {
+        throw new Error('internal: a path has at least one step');
+      }
       let next = tail;
-      for (let i = node.steps.length - 1; i > 0; i--) {
-        const step = node.steps[i];
+      for (const step of rest.reverse()) {
         const after = next;
         next = step.optional
           ? () => {
@@ -288,7 +292,6 @@ function evaluate(node: Node, scope: Scope, tail: () => TreeNode): TreeNode {
             }
           : () => evaluate(step.term, scope, after);
       }
-      const first = node.steps[0];
       const forest = evaluate(first.term, scope, next);
       if (first.optional) merge(forest, next());
       return forest;

package/src/format.ts

@@ -68,9 +68,11 @@ function separator(prev: Token, cur: Token, next: Token | undefined): string {
 /** Re-emit one line's tokens under the canonical spacing rules. */
 function printTokens(tokens: Token[]): string {
   let out = '';
-  for (let i = 0; i < tokens.length; i++) {
-    if (i > 0) out += separator(tokens[i - 1], tokens[i], tokens[i + 1]);
-    out += text(tokens[i]);
+  let prev: Token | undefined;
+  for (const [i, token] of tokens.entries()) {
+    if (prev) out += separator(prev, token, tokens[i + 1]);
+    out += text(token);
+    prev = token;
   }
   return out;
 }
@@ -109,8 +111,8 @@ export function formatSource(
   let level = 0;
   let blankRun = 0;
 
-  for (let i = 0; i < lines.length; i++) {
-    const { comment } = splitComment(lines[i]);
+  for (const [i, raw] of lines.entries()) {
+    const { comment } = splitComment(raw);
     const lineTokens = byLine.get(i + 1) ?? [];
 
     if (lineTokens.length === 0 && comment === null) {
@@ -184,9 +186,8 @@ export function resolveIndent(
     let applies = false;
     for (const raw of content.split('\n')) {
       const line = raw.trim();
-      const section = line.match(/^\[(.+)\]$/);
-      if (section) {
-        const glob = section[1];
+      const glob = line.match(/^\[(.+)\]$/)?.[1];
+      if (glob !== undefined) {
         applies =
           glob === '*' ||
           glob === '**' ||
@@ -194,10 +195,10 @@ export function resolveIndent(
         continue;
       }
       if (!applies) continue;
-      const pair = line.match(/^([A-Za-z_]+)\s*=\s*(.+)$/);
-      if (!pair) continue;
-      if (pair[1] === 'indent_style') style = pair[2].trim();
-      if (pair[1] === 'indent_size') size = pair[2].trim();
+      const [, key, value] = line.match(/^([A-Za-z_]+)\s*=\s*(.+)$/) ?? [];
+      if (key === undefined || value === undefined) continue;
+      if (key === 'indent_style') style = value.trim();
+      if (key === 'indent_size') size = value.trim();
     }
   }
 
@@ -245,6 +246,8 @@ export function fixSource(source: string): {
     for (let i = 0; i + 1 < lineTokens.length; i++) {
       const closer = lineTokens[i];
       const star = lineTokens[i + 1];
+      // The loop bound keeps both indices in range; the guard only narrows.
+      if (closer === undefined || star === undefined) break;
       if (
         (closer.kind === 'rangle' || closer.kind === 'rbracket') &&
         star.kind === 'star'
@@ -259,8 +262,9 @@ export function fixSource(source: string): {
         });
       }
     }
-    if (repaired) {
-      const raw = lines[line - 1];
+    const raw = lines[line - 1];
+    // Every token's line exists in the source it was lexed from.
+    if (repaired && raw !== undefined) {
       const { comment } = splitComment(raw);
       const leading = raw.match(/^\s*/)?.[0] ?? '';
       const code = printTokens(lineTokens);

package/src/parser.ts

@@ -14,14 +14,21 @@ export function parse(source: string): Module {
 
 class Parser {
   private readonly tokens: Token[];
+  /** The stream's closing `eof` — what the cursor sees once it runs past the end. */
+  private readonly eof: Token;
   private index = 0;
 
   constructor(tokens: Token[]) {
+    const last = tokens[tokens.length - 1];
+    if (last?.kind !== 'eof') {
+      throw new Error('internal: a token stream ends with eof');
+    }
     this.tokens = tokens;
+    this.eof = last;
   }
 
   private peek(): Token {
-    return this.tokens[this.index];
+    return this.tokens[this.index] ?? this.eof;
   }
 
   private at(offset: number): Token | undefined {
@@ -29,7 +36,9 @@ class Parser {
   }
 
   private next(): Token {
-    return this.tokens[this.index++];
+    const token = this.peek();
+    this.index++;
+    return token;
   }
 
   private expect(kind: Token['kind'], what: string): Token {
@@ -204,24 +213,26 @@ class Parser {
 
   /** `a | b | c` — a single option collapses to itself. */
   private alternation(): Node {
-    const options: Node[] = [this.path()];
+    const first = this.path();
+    const options: Node[] = [first];
     while (this.peek().kind === 'pipe') {
       this.next();
       options.push(this.path());
     }
-    if (options.length === 1) return options[0];
+    if (options.length === 1) return first;
     const alt: Alt = { kind: 'alt', options };
     return alt;
   }
 
   /** `a.b.c` — a single step with no `?` collapses to its term. */
   private path(): Node {
-    const steps: Step[] = [this.step()];
+    const first = this.step();
+    const steps: Step[] = [first];
     while (this.peek().kind === 'dot') {
       this.next();
       steps.push(this.step());
     }
-    if (steps.length === 1 && !steps[0].optional) return steps[0].term;
+    if (steps.length === 1 && !first.optional) return first.term;
     const path: Path = { kind: 'path', steps };
     return path;
   }

package/src/tokenizer.ts

@@ -70,8 +70,10 @@ const WORD = /^\d+[A-Za-z][A-Za-z0-9-]*/;
 const NUMBER = /^\d+/;
 
 /** "Write the numbers as they appear": a leading zero declares the pad width. */
-function padWidth(...literals: string[]): number | undefined {
-  const declared = literals.filter((l) => l.length > 1 && l.startsWith('0'));
+function padWidth(...literals: Array<string | undefined>): number | undefined {
+  const declared = literals.filter(
+    (l): l is string => l !== undefined && l.length > 1 && l.startsWith('0'),
+  );
   if (declared.length === 0) return undefined;
   return Math.max(...declared.map((l) => l.length));
 }
@@ -83,9 +85,9 @@ export function tokenize(source: string): Token[] {
   // this stack is non-empty a group is a BLOCK — newlines inside it are insignificant.
   const openBrackets: Array<{ line: number; column: number }> = [];
 
-  for (let i = 0; i < lines.length; i++) {
+  for (const [i, raw] of lines.entries()) {
     const line = i + 1;
-    let text = lines[i];
+    let text = raw;
     const commentAt = text.indexOf('#');
     if (commentAt !== -1) text = text.slice(0, commentAt);
 
@@ -197,11 +199,13 @@ export function tokenize(source: string): Token[] {
         '/': 'slash',
         ':': 'colon',
       };
-      const kind = single[text[0]];
-      if (!kind) throw new DfnError(`unexpected '${text[0]}'`, line, column);
+      // The loop condition guarantees a non-empty `text`, so `charAt(0)` is its first character.
+      const char = text.charAt(0);
+      const kind = single[char];
+      if (!kind) throw new DfnError(`unexpected '${char}'`, line, column);
       if (kind === 'lbracket') openBrackets.push({ line, column });
       if (kind === 'rbracket') openBrackets.pop();
-      push(kind, text[0]);
+      push(kind, char);
     }
 
     // Inside a block, a newline is not a statement boundary.