tarsec 0.0.20 → 0.0.22

package/dist/combinators.js

@@ -15,7 +15,7 @@ import { escape, findAncestorWithNextParser, popMany } from "./utils.js";
  * and returns the result as an array
  */
 export function many(parser) {
-    return trace("many", (input) => {
+    const _parser = (input) => {
         let results = [];
         let captures = [];
         let rest = input;
@@ -44,7 +44,8 @@ export function many(parser) {
                 }
             }
         }
-    });
+    };
+    return trace("many", _parser);
 }
 /**
  * Same as `many`, but fails if the parser doesn't match at least once.
@@ -392,13 +393,14 @@ export function capture(parser, name) {
  * @returns - the parser's result set as the captures object
  */
 export function captureCaptures(parser) {
-    return trace(`captureCaptures()`, (input) => {
+    const _parser = (input) => {
         let result = parser(input);
         if (result.success) {
             return Object.assign(Object.assign({}, result), { captures: result.result });
         }
         return result;
-    });
+    };
+    return trace(`captureCaptures()`, _parser);
 }
 /**
  * Returns a parser that consumes input till the given parser succeeds.
@@ -545,7 +547,7 @@ export function search(parser) {
                 .join(" ");
             return success(result, rest);
         }
-        return success("", input);
+        return success([], input);
     });
 }
 /*

package/dist/parsers.d.ts

@@ -43,7 +43,7 @@ export declare function noneOf(chars: string): Parser<string>;
  * @param input - input string
  * @returns - ParserResult
  */
-export declare const anyChar: any;
+export declare const anyChar: Parser<string>;
 /** A parser that matches one of " \t\n\r". */
 export declare const space: Parser<string>;
 /** A parser that matches one or more spaces. */

package/dist/parsers.js

@@ -175,7 +175,7 @@ export function captureRegex(str, options = "", ...captureNames) {
     else {
         re = str;
     }
-    return trace(`captureRegex(${str})`, (input) => {
+    const _parser = (input) => {
         const match = input.match(re);
         if (match) {
             if (match.slice(1).length > captureNames.length) {
@@ -188,7 +188,8 @@ export function captureRegex(str, options = "", ...captureNames) {
             return success(captures, input.slice(match[0].length));
         }
         return failure(`expected ${str}, got ${input.slice(0, 10)}`, input);
-    });
+    };
+    return trace(`captureRegex(${str})`, _parser);
 }
 /**
  * Return a parser that takes a key and a value.

package/dist/trace.d.ts

@@ -1,10 +1,10 @@
-import { ParserResult } from "./types.js";
+import { ParserResult, Parser, PlainObject, CaptureParser } from "./types.js";
 /**
  * This function is used internally by the `trace` function to create the string for each step.
  * @param name - debug name for parser
  * @param result - parser result
  * @returns - A formatted string that describes the parser's result
- */
+*/
 export declare function resultToString<T>(name: string, result: ParserResult<T>): string;
 /**
  * This function is used internally with debug mode. Given a parser and a debug name for it,
@@ -61,7 +61,21 @@ export declare function resultToString<T>(name: string, result: ParserResult<T>)
  * @param parser - parser to run
  * @returns
  */
-export declare function trace(name: string, parser: any): any;
+export declare function trace<T, C extends PlainObject>(name: string, parser: CaptureParser<T, C>): CaptureParser<T, C>;
+export declare function trace<T>(name: string, parser: Parser<T>): Parser<T>;
+/**
+ * Useful for adding debugging messages to your parsers.
+ * Use `getDebugMessages` to get all the messages,
+ * or `getDebugMessage` to get the last message,
+ * if your parser fails.
+ *
+ * @param parser - a parser
+ * @param message - the message to show if the parser fails
+ */
+export declare function debug<T, C extends PlainObject>(parser: CaptureParser<T, C>, message: string): CaptureParser<T, C>;
+export declare function debug<T>(parser: Parser<T>, message: string): Parser<T>;
+export declare function getDebugMessages(): string[];
+export declare function getDebugMessage(): string;
 /**
  * Utility timing function. Given a callback, it times the callback
  * and returns its runtime in milliseconds. It uses `performance.now()` to do this.

package/dist/trace.js

@@ -4,79 +4,25 @@ const isNode = typeof process !== "undefined" &&
     process.versions != null &&
     process.versions.node != null;
 const STEP = 2;
+let level = 0;
+let counts = {};
+let times = {};
+let debugFlag = isNode ? !!process.env.DEBUG : false;
+let stepCount = 0;
+let stepLimit = -1;
+let debugMessages = [];
 /**
  * This function is used internally by the `trace` function to create the string for each step.
  * @param name - debug name for parser
  * @param result - parser result
  * @returns - A formatted string that describes the parser's result
- */
+*/
 export function resultToString(name, result) {
     if (result.success) {
         return `✅ ${name} -- match: ${escape(result.result)}, rest: ${escape(result.rest)}`;
     }
     return `❌ ${name} -- message: ${escape(result.message)}, rest: ${escape(result.rest)}`;
 }
-let level = 0;
-let counts = {};
-let times = {};
-let debugFlag = isNode ? !!process.env.DEBUG : false;
-let stepCount = 0;
-let stepLimit = -1;
-/**
- * This function is used internally with debug mode. Given a parser and a debug name for it,
- * when the parser is called, `trace` will:
- * 1. Print a line when the parser starts
- * 2. print a line when the parser ends, indicating success or failure.
- * 3. If the parser returns any captures, print the captures.
- * 4. Count the number of times this parser has been run.
- * 5. Track the total time this parser has taken.
- * 6. Track the total number of steps your parser has taken (a step equals one parser invocation).
- * So, for example, you may find out that your parser to parse Markdown has taken 50 steps to parse that file.
- *
- * All this happens only if debug mode is on, which you can turn on by using `parserDebug`, or setting the env var `DEBUG` to `1`.
- *
- * Caveat: If you have debug mode on through an environment variable, `trace` will capture counts and times
- * for all parsers across your entire application. If you want to profile just a particular section of code, use `parserDebug` instead.
- * If you *do* want to track constant times for all parsers, don't use `parserDebug` as it will reset those.
- *
- *
- * `trace` works with tarsec's built-in parsers out of the box. You can easily set it up to work with your custom parser too.
- *
- * For example, if your parser looks like this:
- *
- * ```ts
- * const myParser = (input:string) => {
- *   if (input === "hello") {
- *    return { success: true, result: "hello", rest: "" };
- *  }
- * return { success: false, message: "expected hello", rest: input };
- * }
- * ```
- *
- * You can wrap it in `trace` like this:
- *
- * ```ts
- * const myParser = trace("myParser", (input:string) => {
- *  if (input === "hello") {
- *   return { success: true, result: "hello", rest: "" };
- * }
- * return { success: false, message: "expected hello", rest: input };
- * });
- * ```
- *
- * Now, when you run `myParser("hello")` with debug mode on,
- * you will see the debug output.
- *
- * Some parsers, like `seq`, are very general. You might have a few parser that use `seq`.
- * So when you see `seq` debug output, you might not know which `seq` parser that means.
- * ou can pass `seq` a debug name as an optional third argument to be used in the debug output.
- * This name is used to track count and time, so using this name will also mean this `seq` parser's
- * count and time are tracked separately from the other `seq` parsers, which might be useful.
- *
- * @param name - debug name for parser
- * @param parser - parser to run
- * @returns
- */
 export function trace(name, parser) {
     if (stepLimit > 0 && stepCount > stepLimit) {
         throw new Error(`parser step limit of ${stepLimit} exceeded, parser may be in an infinite loop`);
@@ -107,6 +53,24 @@ export function trace(name, parser) {
         }
     };
 }
+export function debug(parser, message) {
+    return (input) => {
+        const result = parser(input);
+        if (result.success) {
+            return result;
+        }
+        else {
+            debugMessages.push(`${message} -- ${resultToString("", result)}`);
+            return result;
+        }
+    };
+}
+export function getDebugMessages() {
+    return debugMessages;
+}
+export function getDebugMessage() {
+    return debugMessages[debugMessages.length - 1];
+}
 /**
  * Utility timing function. Given a callback, it times the callback
  * and returns its runtime in milliseconds. It uses `performance.now()` to do this.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tarsec",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
   "scripts": {
@@ -38,4 +38,4 @@
     "typescript": "^5.4.2",
     "vitest": "^1.4.0"
   }
-}
+}