@ptolemy2002/rgx 13.3.4 → 13.4.0

package/dist/walker/base.d.ts

@@ -14,6 +14,7 @@ export type RGXTryWalkOptions = {
     revertShare?: boolean;
     revertCaptures?: boolean;
 };
+export type RGXWalkerSnapshotKey = "sourcePosition" | "tokenPosition" | "reduced" | "share" | "captures" | "namedCaptures";
 export type RGXTokenOrPart<R, S = unknown, T = any> = RGXToken | RGXPart<R, S, T>;
 export type RGXWalkerStepDirective = "stop" | "skip" | "silent";
 export declare class RGXWalker<R, S = unknown> {
@@ -30,6 +31,7 @@ export declare class RGXWalker<R, S = unknown> {
     contiguous: boolean;
     private _stopped;
     private _didReachEnd;
+    private _snapshots;
     static check: (value: unknown) => value is RGXWalker<unknown, unknown>;
     static assert: (value: unknown) => asserts value is RGXWalker<unknown, unknown>;
     get sourcePosition(): number;
@@ -61,6 +63,8 @@ export declare class RGXWalker<R, S = unknown> {
     stepToToken(predicate: (token: RGXTokenOrPart<R>) => boolean): this;
     stepToPart(predicate?: (part: RGXPart<R, S, unknown>) => boolean): this;
     walk(): R;
+    snapshot(name: string, ...keys: Array<RGXWalkerSnapshotKey | false>): this;
+    restore(name: string): this;
     tryWalk({ revertReduced, revertShare, revertCaptures }?: RGXTryWalkOptions): boolean;
     clone(depth?: CloneDepth): RGXWalker<R, S>;
 }

package/dist/walker/base.js

@@ -55,6 +55,7 @@ class RGXWalker {
         this._stopped = false;
         // Only relevant in infinite mode, tracking whether we've reached the end yet.
         this._didReachEnd = false;
+        this._snapshots = new Map();
         this.source = source;
         this.sourcePosition = options.startingSourcePosition ?? 0;
         this.tokens = tokens;
@@ -184,13 +185,13 @@ class RGXWalker {
         }
     }
     // Returns a directive on handled validation failure, null on success. Unhandled errors are rethrown.
-    validateCapture(token, captureResult, start) {
+    validateCapture(token, captureResult) {
         try {
             token.validate(captureResult, { part: token, walker: this });
             return null;
         }
         catch (e) {
-            this.sourcePosition = start; // Reset source position on validation failure
+            this.restore("step"); // Reset source position on validation failure
             if (e instanceof errors_1.RGXPartValidationFailedError) {
                 const control = token.afterValidationFailure?.(e, { part: token, walker: this });
                 // If this happens, afterValidationFailure itself stopped the walker, so we just need to respect that.
@@ -205,7 +206,7 @@ class RGXWalker {
             throw e;
         }
     }
-    handleAfterCapture(token, captureResult, silent, start) {
+    handleAfterCapture(token, captureResult, silent) {
         const control = token.afterCapture?.(captureResult, { part: token, walker: this });
         if (!silent && (control === "skip" || control === "silent" || control === "stop-silent")) {
             this.unregisterLastCapture(token);
@@ -214,7 +215,7 @@ class RGXWalker {
         if (this.stopped)
             return "stop";
         if (control === "skip") {
-            this.sourcePosition = start;
+            this.restore("step");
             return "skip";
         }
         if (control === "stop" || control === "stop-silent")
@@ -247,9 +248,9 @@ class RGXWalker {
             silent = dir === "silent";
         }
         const branchedToken = isPart ? createBranchGroups(token.token) : createBranchGroups(token);
-        // Still track the previous source position,
-        // because if we have to skip, we need to reset to it.
-        const prevSourcePosition = this.sourcePosition;
+        // Snapshot the source position so validateCapture and handleAfterCapture
+        // can restore it on skip/failure.
+        this.snapshot("step", "sourcePosition");
         let captureAttempt;
         try {
             captureAttempt = this.attemptCapture(branchedToken, isPart ? token : null);
@@ -287,7 +288,7 @@ class RGXWalker {
             groups: captureAttempt.groups ?? null
         };
         if (isPart) {
-            const dir = this.validateCapture(token, captureResult, prevSourcePosition);
+            const dir = this.validateCapture(token, captureResult);
             if (dir === "stop") {
                 this._stopped = true;
                 return null;
@@ -300,7 +301,7 @@ class RGXWalker {
         if (!silent)
             this.registerCapture(captureResult, token);
         if (isPart) {
-            const dir = this.handleAfterCapture(token, captureResult, silent, prevSourcePosition);
+            const dir = this.handleAfterCapture(token, captureResult, silent);
             if (dir === "stop") {
                 this.advanceToken();
                 this._stopped = true;
@@ -341,31 +342,48 @@ class RGXWalker {
         this.stepToToken(() => false);
         return this.reduced;
     }
+    snapshot(name, ...keys) {
+        const filteredKeys = keys.filter((k) => k !== false);
+        const snap = {};
+        for (const key of filteredKeys) {
+            if (key === "sourcePosition" || key === "tokenPosition") {
+                snap[key] = this[key];
+            }
+            else {
+                snap[key] = (0, immutability_utils_1.extClone)(this[key], "max");
+            }
+        }
+        this._snapshots.set(name, snap);
+        return this;
+    }
+    restore(name) {
+        const snap = this._snapshots.get(name);
+        if (!snap)
+            return this;
+        if ("sourcePosition" in snap)
+            this.sourcePosition = snap.sourcePosition;
+        if ("tokenPosition" in snap)
+            this.tokenPosition = snap.tokenPosition;
+        if ("reduced" in snap)
+            this.reduced = snap.reduced;
+        if ("share" in snap)
+            this.share = snap.share;
+        if ("captures" in snap)
+            this.captures = snap.captures;
+        if ("namedCaptures" in snap)
+            this.namedCaptures = snap.namedCaptures;
+        return this;
+    }
     tryWalk({ revertReduced = false, revertShare = false, revertCaptures = false } = {}) {
-        const prevSourcePosition = this.sourcePosition;
-        const prevTokenPosition = this.tokenPosition;
-        const prevReduced = revertReduced ? (0, immutability_utils_1.extClone)(this.reduced, "max") : this.reduced;
-        const prevShare = revertShare ? (0, immutability_utils_1.extClone)(this.share, "max") : this.share;
-        const prevCaptures = revertCaptures ? (0, immutability_utils_1.extClone)(this.captures, "max") : this.captures;
-        const prevNamedCaptures = revertCaptures ? (0, immutability_utils_1.extClone)(this.namedCaptures, "max") : this.namedCaptures;
+        this.snapshot("tryWalk", "sourcePosition", "tokenPosition", revertReduced && "reduced", revertShare && "share", revertCaptures && "captures", revertCaptures && "namedCaptures");
         try {
             this.walk();
             return true;
         }
         catch (e) {
-            this.sourcePosition = prevSourcePosition;
-            this.tokenPosition = prevTokenPosition;
-            if (revertReduced)
-                this.reduced = prevReduced;
-            if (revertShare)
-                this.share = prevShare;
-            if (revertCaptures)
-                this.captures = prevCaptures;
-            if (revertCaptures)
-                this.namedCaptures = prevNamedCaptures;
-            if (isMatchError(e)) {
+            this.restore("tryWalk");
+            if (isMatchError(e))
                 return false;
-            }
             throw e;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/rgx",
-    "version": "13.3.4",
+    "version": "13.4.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",