webpipe-js 2.0.31 → 2.0.33

package/dist/index.d.ts

@@ -21,10 +21,14 @@ interface Config {
     properties: ConfigProperty[];
     lineNumber?: number;
     inlineComment?: Comment;
+    start: number;
+    end: number;
 }
 interface ConfigProperty {
     key: string;
     value: ConfigValue;
+    start: number;
+    end: number;
 }
 type ConfigValue = {
     kind: 'String';
@@ -45,6 +49,8 @@ interface NamedPipeline {
     pipeline: Pipeline;
     lineNumber?: number;
     inlineComment?: Comment;
+    start: number;
+    end: number;
 }
 interface Variable {
     varType: string;
@@ -52,23 +58,31 @@ interface Variable {
     value: string;
     lineNumber?: number;
     inlineComment?: Comment;
+    start: number;
+    end: number;
 }
 interface GraphQLSchema {
     sdl: string;
     lineNumber?: number;
     inlineComment?: Comment;
+    start: number;
+    end: number;
 }
 interface QueryResolver {
     name: string;
     pipeline: Pipeline;
     lineNumber?: number;
     inlineComment?: Comment;
+    start: number;
+    end: number;
 }
 interface MutationResolver {
     name: string;
     pipeline: Pipeline;
     lineNumber?: number;
     inlineComment?: Comment;
+    start: number;
+    end: number;
 }
 interface Route {
     method: string;
@@ -76,16 +90,24 @@ interface Route {
     pipeline: PipelineRef;
     lineNumber?: number;
     inlineComment?: Comment;
+    start: number;
+    end: number;
 }
 type PipelineRef = {
     kind: 'Inline';
     pipeline: Pipeline;
+    start: number;
+    end: number;
 } | {
     kind: 'Named';
     name: string;
+    start: number;
+    end: number;
 };
 interface Pipeline {
     steps: PipelineStep[];
+    start: number;
+    end: number;
 }
 type ConfigType = 'backtick' | 'quoted' | 'identifier';
 type LetValueFormat = 'quoted' | 'backtick' | 'bare';
@@ -102,6 +124,8 @@ interface Tag {
     name: string;
     negated: boolean;
     args: string[];
+    start: number;
+    end: number;
 }
 /** A boolean expression of tags for dispatch routing */
 type TagExpr = {
@@ -119,35 +143,50 @@ type TagExpr = {
 type PipelineStep = {
     kind: 'Regular';
     name: string;
+    args: string[];
     config: string;
     configType: ConfigType;
     condition?: TagExpr;
     parsedJoinTargets?: string[];
+    start: number;
+    end: number;
 } | {
     kind: 'Result';
     branches: ResultBranch[];
+    start: number;
+    end: number;
 } | {
     kind: 'If';
     condition: Pipeline;
     thenBranch: Pipeline;
     elseBranch?: Pipeline;
+    start: number;
+    end: number;
 } | {
     kind: 'Dispatch';
     branches: DispatchBranch[];
     default?: Pipeline;
+    start: number;
+    end: number;
 } | {
     kind: 'Foreach';
     selector: string;
     pipeline: Pipeline;
+    start: number;
+    end: number;
 };
 interface DispatchBranch {
     condition: TagExpr;
     pipeline: Pipeline;
+    start: number;
+    end: number;
 }
 interface ResultBranch {
     branchType: ResultBranchType;
     statusCode: number;
     pipeline: Pipeline;
+    start: number;
+    end: number;
 }
 type ResultBranchType = {
     kind: 'Ok';
@@ -170,6 +209,8 @@ interface Describe {
 interface Mock {
     target: string;
     returnValue: string;
+    start: number;
+    end: number;
 }
 interface It {
     name: string;
@@ -188,13 +229,19 @@ type When = {
     kind: 'CallingRoute';
     method: string;
     path: string;
+    start: number;
+    end: number;
 } | {
     kind: 'ExecutingPipeline';
     name: string;
+    start: number;
+    end: number;
 } | {
     kind: 'ExecutingVariable';
     varType: string;
     name: string;
+    start: number;
+    end: number;
 };
 type DomAssertType = {
     kind: 'Exists';
@@ -217,6 +264,8 @@ interface Condition {
     callTarget?: string;
     selector?: string;
     domAssert?: DomAssertType;
+    start: number;
+    end: number;
 }
 type DiagnosticSeverity = 'error' | 'warning' | 'info';
 interface ParseDiagnostic {

package/dist/index.mjs

@@ -306,6 +306,7 @@ var Parser = class {
     throw new ParseFailure("step-config", this.pos);
   }
   parseTag() {
+    const start = this.pos;
     this.expect("@");
     const negated = this.cur() === "!";
     if (negated) this.pos++;
@@ -314,7 +315,8 @@ var Parser = class {
     if (this.cur() === "(") {
       args = this.parseTagArgs();
     }
-    return { name, negated, args };
+    const end = this.pos;
+    return { name, negated, args, start, end };
   }
   parseTagArgs() {
     this.expect("(");
@@ -389,14 +391,17 @@ var Parser = class {
   }
   parseConfigProperty() {
     this.skipSpaces();
+    const start = this.pos;
     const key = this.parseIdentifier();
     this.skipInlineSpaces();
     this.expect(":");
     this.skipInlineSpaces();
     const value = this.parseConfigValue();
-    return { key, value };
+    const end = this.pos;
+    return { key, value, start, end };
   }
   parseConfig() {
+    const start = this.pos;
     this.expect("config");
     this.skipInlineSpaces();
     const name = this.parseIdentifier();
@@ -414,7 +419,8 @@ var Parser = class {
     this.skipSpaces();
     this.expect("}");
     this.skipWhitespaceOnly();
-    return { name, properties, inlineComment: inlineComment || void 0 };
+    const end = this.pos;
+    return { name, properties, inlineComment: inlineComment || void 0, start, end };
   }
   parsePipelineStep() {
     const result = this.tryParse(() => this.parseResultStep());
@@ -429,6 +435,7 @@ var Parser = class {
   }
   parseForeachStep() {
     this.skipWhitespaceOnly();
+    const start = this.pos;
     this.expect("|>");
     this.skipInlineSpaces();
     this.expect("foreach");
@@ -444,20 +451,25 @@ var Parser = class {
     const pipeline = this.parseIfPipeline("end");
     this.skipSpaces();
     this.expect("end");
-    return { kind: "Foreach", selector, pipeline };
+    const end = this.pos;
+    return { kind: "Foreach", selector, pipeline, start, end };
   }
   parseRegularStep() {
     this.skipWhitespaceOnly();
+    const start = this.pos;
     this.expect("|>");
     this.skipInlineSpaces();
     const name = this.parseIdentifier();
+    const args = this.parseInlineArgs();
+    this.skipInlineSpaces();
     this.expect(":");
     this.skipInlineSpaces();
     const { config, configType } = this.parseStepConfig();
     const condition = this.parseStepCondition();
     const parsedJoinTargets = name === "join" ? this.parseJoinTaskNames(config) : void 0;
     this.skipWhitespaceOnly();
-    return { kind: "Regular", name, config, configType, condition, parsedJoinTargets };
+    const end = this.pos;
+    return { kind: "Regular", name, args, config, configType, condition, parsedJoinTargets, start, end };
   }
   /**
    * Parse optional step condition (tag expression after the config)
@@ -511,8 +523,132 @@ var Parser = class {
     }
     return names;
   }
+  /**
+   * Split argument content by commas while respecting nesting depth and strings
+   * Example: `"url", {a:1, b:2}` -> [`"url"`, `{a:1, b:2}`]
+   */
+  splitBalancedArgs(content) {
+    const args = [];
+    let current = "";
+    let depth = 0;
+    let inString = false;
+    let stringChar = "";
+    let escapeNext = false;
+    for (let i = 0; i < content.length; i++) {
+      const ch = content[i];
+      if (escapeNext) {
+        current += ch;
+        escapeNext = false;
+        continue;
+      }
+      if (ch === "\\" && inString) {
+        current += ch;
+        escapeNext = true;
+        continue;
+      }
+      if ((ch === '"' || ch === "`") && !inString) {
+        inString = true;
+        stringChar = ch;
+        current += ch;
+        continue;
+      }
+      if (ch === stringChar && inString) {
+        inString = false;
+        stringChar = "";
+        current += ch;
+        continue;
+      }
+      if (inString) {
+        current += ch;
+        continue;
+      }
+      if (ch === "(" || ch === "[" || ch === "{") {
+        depth++;
+        current += ch;
+      } else if (ch === ")" || ch === "]" || ch === "}") {
+        depth--;
+        current += ch;
+      } else if (ch === "," && depth === 0) {
+        args.push(current.trim());
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+    if (current.trim().length > 0) {
+      args.push(current.trim());
+    }
+    return args;
+  }
+  /**
+   * Parse inline arguments: middleware(arg1, arg2) or middleware[arg1, arg2]
+   * Returns the array of argument strings and advances position past the closing bracket
+   */
+  parseInlineArgs() {
+    const trimmedStart = this.pos;
+    this.skipInlineSpaces();
+    const ch = this.cur();
+    if (ch !== "(" && ch !== "[") {
+      this.pos = trimmedStart;
+      return [];
+    }
+    const openChar = ch;
+    const closeChar = openChar === "(" ? ")" : "]";
+    this.pos++;
+    let depth = 1;
+    let inString = false;
+    let stringChar = "";
+    let escapeNext = false;
+    const contentStart = this.pos;
+    while (!this.eof() && depth > 0) {
+      const c = this.cur();
+      if (escapeNext) {
+        this.pos++;
+        escapeNext = false;
+        continue;
+      }
+      if (c === "\\" && inString) {
+        this.pos++;
+        escapeNext = true;
+        continue;
+      }
+      if ((c === '"' || c === "`") && !inString) {
+        inString = true;
+        stringChar = c;
+        this.pos++;
+        continue;
+      }
+      if (c === stringChar && inString) {
+        inString = false;
+        stringChar = "";
+        this.pos++;
+        continue;
+      }
+      if (!inString) {
+        if (c === openChar) {
+          depth++;
+        } else if (c === closeChar) {
+          depth--;
+          if (depth === 0) {
+            break;
+          }
+        }
+      }
+      this.pos++;
+    }
+    if (depth !== 0) {
+      throw new ParseFailure(`unclosed ${openChar}`, contentStart);
+    }
+    const argsContent = this.text.slice(contentStart, this.pos);
+    this.pos++;
+    if (argsContent.trim().length === 0) {
+      return [];
+    }
+    return this.splitBalancedArgs(argsContent);
+  }
   parseResultStep() {
     this.skipWhitespaceOnly();
+    const start = this.pos;
     this.expect("|>");
     this.skipInlineSpaces();
     this.expect("result");
@@ -523,10 +659,12 @@ var Parser = class {
       if (!br) break;
       branches.push(br);
     }
-    return { kind: "Result", branches };
+    const end = this.pos;
+    return { kind: "Result", branches, start, end };
   }
   parseResultBranch() {
     this.skipSpaces();
+    const start = this.pos;
     const branchIdent = this.parseIdentifier();
     let branchType;
     if (branchIdent === "ok") branchType = { kind: "Ok" };
@@ -546,10 +684,12 @@ var Parser = class {
     this.expect(":");
     this.skipSpaces();
     const pipeline = this.parsePipeline();
-    return { branchType, statusCode, pipeline };
+    const end = this.pos;
+    return { branchType, statusCode, pipeline, start, end };
   }
   parseIfStep() {
     this.skipWhitespaceOnly();
+    const start = this.pos;
     this.expect("|>");
     this.skipInlineSpaces();
     this.expect("if");
@@ -570,10 +710,12 @@ var Parser = class {
       this.expect("end");
       return true;
     });
-    return { kind: "If", condition, thenBranch, elseBranch: elseBranch || void 0 };
+    const end = this.pos;
+    return { kind: "If", condition, thenBranch, elseBranch: elseBranch || void 0, start, end };
   }
   parseDispatchStep() {
     this.skipWhitespaceOnly();
+    const start = this.pos;
     this.expect("|>");
     this.skipInlineSpaces();
     this.expect("dispatch");
@@ -595,10 +737,12 @@ var Parser = class {
       this.expect("end");
       return true;
     });
-    return { kind: "Dispatch", branches, default: defaultBranch || void 0 };
+    const end = this.pos;
+    return { kind: "Dispatch", branches, default: defaultBranch || void 0, start, end };
   }
   parseDispatchBranch() {
     this.skipSpaces();
+    const start = this.pos;
     this.expect("case");
     this.skipInlineSpaces();
     const condition = this.parseTagExpr();
@@ -606,7 +750,8 @@ var Parser = class {
     this.expect(":");
     this.skipSpaces();
     const pipeline = this.parseIfPipeline("case", "default:", "end");
-    return { condition, pipeline };
+    const end = this.pos;
+    return { condition, pipeline, start, end };
   }
   /**
    * Parse a tag expression with boolean operators (and, or) and grouping
@@ -666,6 +811,7 @@ var Parser = class {
     return { kind: "Tag", tag };
   }
   parseIfPipeline(...stopKeywords) {
+    const start = this.pos;
     const steps = [];
     while (true) {
       const save = this.pos;
@@ -673,7 +819,8 @@ var Parser = class {
       for (const keyword of stopKeywords) {
         if (this.text.startsWith(keyword, this.pos)) {
           this.pos = save;
-          return { steps };
+          const end2 = this.pos;
+          return { steps, start, end: end2 };
         }
       }
       if (!this.text.startsWith("|>", this.pos)) {
@@ -683,9 +830,11 @@ var Parser = class {
       const step = this.parsePipelineStep();
       steps.push(step);
     }
-    return { steps };
+    const end = this.pos;
+    return { steps, start, end };
   }
   parsePipeline() {
+    const start = this.pos;
     const steps = [];
     while (true) {
       const save = this.pos;
@@ -697,7 +846,8 @@ var Parser = class {
       const step = this.parsePipelineStep();
       steps.push(step);
     }
-    return { steps };
+    const end = this.pos;
+    return { steps, start, end };
   }
   parseNamedPipeline() {
     const start = this.pos;
@@ -708,24 +858,27 @@ var Parser = class {
     this.expect("=");
     const inlineComment = this.parseInlineComment();
     this.skipInlineSpaces();
-    const beforePipeline = this.pos;
     const pipeline = this.parsePipeline();
     const end = this.pos;
     this.pipelineRanges.set(name, { start, end });
     this.skipWhitespaceOnly();
-    return { name, pipeline, inlineComment: inlineComment || void 0 };
+    return { name, pipeline, inlineComment: inlineComment || void 0, start, end };
   }
   parsePipelineRef() {
     const inline = this.tryParse(() => this.parsePipeline());
-    if (inline && inline.steps.length > 0) return { kind: "Inline", pipeline: inline };
+    if (inline && inline.steps.length > 0) {
+      return { kind: "Inline", pipeline: inline, start: inline.start, end: inline.end };
+    }
     const named = this.tryParse(() => {
       this.skipWhitespaceOnly();
+      const start = this.pos;
       this.expect("|>");
       this.skipInlineSpaces();
       this.expect("pipeline:");
       this.skipInlineSpaces();
       const name = this.parseIdentifier();
-      return { kind: "Named", name };
+      const end = this.pos;
+      return { kind: "Named", name, start, end };
     });
     if (named) return named;
     throw new Error("pipeline-ref");
@@ -743,19 +896,22 @@ var Parser = class {
     const end = this.pos;
     this.variableRanges.set(`${varType}::${name}`, { start, end });
     this.skipWhitespaceOnly();
-    return { varType, name, value, inlineComment: inlineComment || void 0 };
+    return { varType, name, value, inlineComment: inlineComment || void 0, start, end };
   }
   parseGraphQLSchema() {
+    const start = this.pos;
     this.expect("graphqlSchema");
     this.skipInlineSpaces();
     this.expect("=");
     const inlineComment = this.parseInlineComment();
     this.skipInlineSpaces();
     const sdl = this.parseBacktickString();
+    const end = this.pos;
     this.skipWhitespaceOnly();
-    return { sdl, inlineComment: inlineComment || void 0 };
+    return { sdl, inlineComment: inlineComment || void 0, start, end };
   }
   parseQueryResolver() {
+    const start = this.pos;
     this.expect("query");
     this.skipInlineSpaces();
     const name = this.parseIdentifier();
@@ -764,10 +920,12 @@ var Parser = class {
     const inlineComment = this.parseInlineComment();
     this.skipWhitespaceOnly();
     const pipeline = this.parsePipeline();
+    const end = this.pos;
     this.skipWhitespaceOnly();
-    return { name, pipeline, inlineComment: inlineComment || void 0 };
+    return { name, pipeline, inlineComment: inlineComment || void 0, start, end };
   }
   parseMutationResolver() {
+    const start = this.pos;
     this.expect("mutation");
     this.skipInlineSpaces();
     const name = this.parseIdentifier();
@@ -776,8 +934,9 @@ var Parser = class {
     const inlineComment = this.parseInlineComment();
     this.skipWhitespaceOnly();
     const pipeline = this.parsePipeline();
+    const end = this.pos;
     this.skipWhitespaceOnly();
-    return { name, pipeline, inlineComment: inlineComment || void 0 };
+    return { name, pipeline, inlineComment: inlineComment || void 0, start, end };
   }
   parseFeatureFlags() {
     this.expect("featureFlags");
@@ -789,35 +948,42 @@ var Parser = class {
     return pipeline;
   }
   parseRoute() {
+    const start = this.pos;
     const method = this.parseMethod();
     this.skipInlineSpaces();
     const path = this.consumeWhile((c) => c !== " " && c !== "\n" && c !== "#");
     const inlineComment = this.parseInlineComment();
     this.skipSpaces();
     const pipeline = this.parsePipelineRef();
+    const end = this.pos;
     this.skipWhitespaceOnly();
-    return { method, path, pipeline, inlineComment: inlineComment || void 0 };
+    return { method, path, pipeline, inlineComment: inlineComment || void 0, start, end };
   }
   parseWhen() {
     const calling = this.tryParse(() => {
+      const start = this.pos;
       this.expect("calling");
       this.skipInlineSpaces();
       const method = this.parseMethod();
       this.skipInlineSpaces();
       const path = this.consumeWhile((c) => c !== "\n");
-      return { kind: "CallingRoute", method, path };
+      const end = this.pos;
+      return { kind: "CallingRoute", method, path, start, end };
     });
     if (calling) return calling;
     const executingPipeline = this.tryParse(() => {
+      const start = this.pos;
       this.expect("executing");
       this.skipInlineSpaces();
       this.expect("pipeline");
       this.skipInlineSpaces();
       const name = this.parseIdentifier();
-      return { kind: "ExecutingPipeline", name };
+      const end = this.pos;
+      return { kind: "ExecutingPipeline", name, start, end };
     });
     if (executingPipeline) return executingPipeline;
     const executingVariable = this.tryParse(() => {
+      const start = this.pos;
       this.expect("executing");
       this.skipInlineSpaces();
       this.expect("variable");
@@ -825,13 +991,15 @@ var Parser = class {
       const varType = this.parseIdentifier();
       this.skipInlineSpaces();
       const name = this.parseIdentifier();
-      return { kind: "ExecutingVariable", varType, name };
+      const end = this.pos;
+      return { kind: "ExecutingVariable", varType, name, start, end };
     });
     if (executingVariable) return executingVariable;
     throw new ParseFailure("when", this.pos);
   }
   parseCondition() {
     this.skipSpaces();
+    const start = this.pos;
     const ct = (() => {
       if (this.match("then")) return "Then";
       if (this.match("and")) return "And";
@@ -864,13 +1032,16 @@ var Parser = class {
         if (v2 !== null) return v2;
         return this.consumeWhile((c) => c !== "\n");
       })();
+      const end2 = this.pos;
       return {
         conditionType: ct,
         field: "call",
         comparison: comparison2,
         value: value2,
         isCallAssertion: true,
-        callTarget
+        callTarget,
+        start,
+        end: end2
       };
     }
     if (field === "selector") {
@@ -943,13 +1114,16 @@ var Parser = class {
       } else {
         throw new Error(`Unknown selector operation: ${operation}`);
       }
+      const end2 = this.pos;
       return {
         conditionType: ct,
         field: "selector",
         comparison: comparison2,
         value: value2,
         selector: selectorStr,
-        domAssert
+        domAssert,
+        start,
+        end: end2
       };
     }
     let headerName;
@@ -976,10 +1150,12 @@ var Parser = class {
       if (v2 !== null) return v2;
       return this.consumeWhile((c) => c !== "\n");
     })();
-    return { conditionType: ct, field, headerName: headerName ?? void 0, jqExpr: jqExpr ?? void 0, comparison, value };
+    const end = this.pos;
+    return { conditionType: ct, field, headerName: headerName ?? void 0, jqExpr: jqExpr ?? void 0, comparison, value, start, end };
   }
   parseMockHead(prefixWord) {
     this.skipSpaces();
+    const start = this.pos;
     this.expect(prefixWord);
     this.skipInlineSpaces();
     this.expect("mock");
@@ -998,7 +1174,8 @@ var Parser = class {
     this.skipInlineSpaces();
     const returnValue = this.parseBacktickString();
     this.skipSpaces();
-    return { target, returnValue };
+    const end = this.pos;
+    return { target, returnValue, start, end };
   }
   parseMock() {
     return this.parseMockHead("with");
@@ -1537,9 +1714,10 @@ function formatConfigValue(value) {
 }
 function formatPipelineStep(step, indent = "  ") {
   if (step.kind === "Regular") {
+    const argsPart = step.args.length > 0 ? `(${step.args.join(", ")})` : "";
     const configPart = formatStepConfig(step.config, step.configType);
     const conditionPart = step.condition ? " " + formatTagExpr(step.condition) : "";
-    return `${indent}|> ${step.name}: ${configPart}${conditionPart}`;
+    return `${indent}|> ${step.name}${argsPart}: ${configPart}${conditionPart}`;
   } else if (step.kind === "Result") {
     const lines = [`${indent}|> result`];
     step.branches.forEach((branch) => {