@ptolemy2002/rgx 13.6.0 → 13.8.0

package/dist/typeGuards.d.ts

@@ -20,11 +20,16 @@ export declare function isRGXGroupedToken(value: unknown, contentCheck?: boolean
 export declare function assertRGXGroupedToken(value: unknown, contentCheck?: boolean): asserts value is t.RGXGroupedToken;
 export declare function isValidRegexString(value: string): value is t.ValidRegexString;
 export declare function assertValidRegexString(value: string): asserts value is t.ValidRegexString;
+export declare function castValidRegexString(value: string): t.ValidRegexString;
 export declare function isValidVanillaRegexFlags(value: string): value is t.ValidVanillaRegexFlags;
 export declare function assertValidVanillaRegexFlags(value: string): asserts value is t.ValidVanillaRegexFlags;
+export declare function castValidVanillaRegexFlags(value: string): t.ValidVanillaRegexFlags;
 export declare function isValidIdentifier(value: string): value is t.ValidIdentifier;
 export declare function assertValidIdentifier(value: string): asserts value is t.ValidIdentifier;
+export declare function castValidIdentifier(value: string): t.ValidIdentifier;
 export declare function isValidRegexLocalizableFlagDiff(value: string): value is t.ValidRegexLocalizableFlagDiff;
 export declare function assertValidRegexLocalizableFlagDiff(value: string): asserts value is t.ValidRegexLocalizableFlagDiff;
+export declare function castValidRegexLocalizableFlagDiff(value: string): t.ValidRegexLocalizableFlagDiff;
 export declare function isValidRegexLocalizableFlags(value: string): value is t.ValidRegexLocalizableFlags;
 export declare function assertValidRegexLocalizableFlags(value: string): asserts value is t.ValidRegexLocalizableFlags;
+export declare function castValidRegexLocalizableFlags(value: string): t.ValidRegexLocalizableFlags;

package/dist/typeGuards.js

@@ -57,14 +57,19 @@ exports.isRGXGroupedToken = isRGXGroupedToken;
 exports.assertRGXGroupedToken = assertRGXGroupedToken;
 exports.isValidRegexString = isValidRegexString;
 exports.assertValidRegexString = assertValidRegexString;
+exports.castValidRegexString = castValidRegexString;
 exports.isValidVanillaRegexFlags = isValidVanillaRegexFlags;
 exports.assertValidVanillaRegexFlags = assertValidVanillaRegexFlags;
+exports.castValidVanillaRegexFlags = castValidVanillaRegexFlags;
 exports.isValidIdentifier = isValidIdentifier;
 exports.assertValidIdentifier = assertValidIdentifier;
+exports.castValidIdentifier = castValidIdentifier;
 exports.isValidRegexLocalizableFlagDiff = isValidRegexLocalizableFlagDiff;
 exports.assertValidRegexLocalizableFlagDiff = assertValidRegexLocalizableFlagDiff;
+exports.castValidRegexLocalizableFlagDiff = castValidRegexLocalizableFlagDiff;
 exports.isValidRegexLocalizableFlags = isValidRegexLocalizableFlags;
 exports.assertValidRegexLocalizableFlags = assertValidRegexLocalizableFlags;
+exports.castValidRegexLocalizableFlags = castValidRegexLocalizableFlags;
 const e = __importStar(require("./errors"));
 const is_callable_1 = __importDefault(require("is-callable"));
 const internal_1 = require("./internal");
@@ -277,6 +282,10 @@ function assertValidRegexString(value) {
         }
     }
 }
+function castValidRegexString(value) {
+    assertValidRegexString(value);
+    return value;
+}
 function isValidVanillaRegexFlags(value) {
     const patternMatch = /^[gimsuydv]*$/.test(value);
     if (!patternMatch)
@@ -290,6 +299,10 @@ function assertValidVanillaRegexFlags(value) {
         throw new e.RGXInvalidVanillaRegexFlagsError("Invalid vanilla regex flags", value);
     }
 }
+function castValidVanillaRegexFlags(value) {
+    assertValidVanillaRegexFlags(value);
+    return value;
+}
 function isValidIdentifier(value) {
     // This regex checks for valid JavaScript identifiers, which can be used for named capture groups.
     return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
@@ -299,6 +312,10 @@ function assertValidIdentifier(value) {
         throw new e.RGXInvalidIdentifierError("Invalid identifier", value);
     }
 }
+function castValidIdentifier(value) {
+    assertValidIdentifier(value);
+    return value;
+}
 function isValidRegexLocalizableFlagDiff(value) {
     if (value === '')
         return true;
@@ -309,6 +326,10 @@ function assertValidRegexLocalizableFlagDiff(value) {
         throw new e.RGXInvalidRegexLocalizableFlagDiffError("Invalid localizable flag diff", value);
     }
 }
+function castValidRegexLocalizableFlagDiff(value) {
+    assertValidRegexLocalizableFlagDiff(value);
+    return value;
+}
 function isValidRegexLocalizableFlags(value) {
     return /^[ims]*$/.test(value);
 }
@@ -317,3 +338,7 @@ function assertValidRegexLocalizableFlags(value) {
         throw new e.RGXInvalidRegexLocalizableFlagsError("Invalid localizable flags", value);
     }
 }
+function castValidRegexLocalizableFlags(value) {
+    assertValidRegexLocalizableFlags(value);
+    return value;
+}

package/dist/walker/base.d.ts

@@ -60,12 +60,19 @@ export declare class RGXWalker<R, S = unknown> {
     private validateCapture;
     private handleAfterCapture;
     step(): RGXCapture | null;
-    stepToToken(predicate: (token: RGXTokenOrPart<R>) => boolean): this;
+    private _stepToTokenIter;
+    stepToToken(predicate?: (token: RGXTokenOrPart<R>) => boolean): this;
+    stepToTokenAsync(predicate?: (token: RGXTokenOrPart<R, S, unknown>) => boolean, yieldFn?: () => Promise<void>): Promise<this>;
+    private _stepPastCurrentPartIfNeeded;
     stepToPart(predicate?: (part: RGXPart<R, S, unknown>) => boolean): this;
+    stepToPartAsync(predicate?: (part: RGXPart<R, S, unknown>) => boolean, yieldFn?: () => Promise<void>): Promise<this>;
     walk(): R;
+    walkAsync(yieldFn?: () => Promise<void>): Promise<R>;
     snapshot(name: string, ...keys: Array<RGXWalkerSnapshotKey | false>): this;
     restore(name: string): this;
+    private _walkerSnapshot;
     tryWalk({ revertReduced, revertShare, revertCaptures }?: RGXTryWalkOptions): boolean;
+    tryWalkAsync({ revertReduced, revertShare, revertCaptures }?: RGXTryWalkOptions, yieldFn?: () => Promise<void>): Promise<boolean>;
     clone(depth?: CloneDepth): RGXWalker<R, S>;
 }
 export declare function rgxWalker<R, S = unknown>(...args: ConstructorParameters<typeof RGXWalker<R, S>>): RGXWalker<R, S>;

package/dist/walker/base.js

@@ -315,7 +315,7 @@ class RGXWalker {
         this.advanceToken();
         return captureResult;
     }
-    stepToToken(predicate) {
+    *_stepToTokenIter(predicate) {
         while (this.hasNextToken()) {
             this._stopped = false;
             if (predicate(this.currentToken()))
@@ -323,25 +323,51 @@ class RGXWalker {
             this.step();
             if (this._stopped)
                 break;
+            yield;
         }
+    }
+    stepToToken(predicate = () => true) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for (const _ of this._stepToTokenIter(predicate)) { /* sync — no yield needed */ }
         return this;
     }
-    stepToPart(predicate = () => true) {
-        // If currently at a Part, step past it first so repeated
-        // calls advance to the next Part rather than getting stuck.
+    async stepToTokenAsync(predicate = () => true, yieldFn = () => new Promise(resolve => setImmediate(resolve))) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for (const _ of this._stepToTokenIter(predicate))
+            await yieldFn();
+        return this;
+    }
+    // If currently at a Part, steps past it (so repeated stepToPart calls advance
+    // rather than getting stuck). Returns true when the walker stopped mid-step.
+    _stepPastCurrentPartIfNeeded() {
         if (this.hasNextToken() && this.currentToken() instanceof part_1.RGXPart) {
             this._stopped = false;
             this.step();
             if (this._stopped)
-                return this;
+                return true;
         }
+        return false;
+    }
+    stepToPart(predicate = () => true) {
+        if (this._stepPastCurrentPartIfNeeded())
+            return this;
         this.stepToToken(token => token instanceof part_1.RGXPart && predicate(token));
         return this;
     }
+    async stepToPartAsync(predicate = () => true, yieldFn = () => new Promise(resolve => setImmediate(resolve))) {
+        if (this._stepPastCurrentPartIfNeeded())
+            return this;
+        await this.stepToTokenAsync(token => token instanceof part_1.RGXPart && predicate(token), yieldFn);
+        return this;
+    }
     walk() {
         this.stepToToken(() => false);
         return this.reduced;
     }
+    async walkAsync(yieldFn) {
+        await this.stepToTokenAsync(() => false, yieldFn);
+        return this.reduced;
+    }
     snapshot(name, ...keys) {
         const filteredKeys = keys.filter((k) => k !== false);
         const snap = {};
@@ -374,8 +400,11 @@ class RGXWalker {
             this.namedCaptures = snap.namedCaptures;
         return this;
     }
+    _walkerSnapshot(name, { revertReduced, revertShare, revertCaptures }) {
+        return this.snapshot(name, "sourcePosition", "tokenPosition", revertReduced && "reduced", revertShare && "share", revertCaptures && "captures", revertCaptures && "namedCaptures");
+    }
     tryWalk({ revertReduced = false, revertShare = false, revertCaptures = false } = {}) {
-        this.snapshot("tryWalk", "sourcePosition", "tokenPosition", revertReduced && "reduced", revertShare && "share", revertCaptures && "captures", revertCaptures && "namedCaptures");
+        this._walkerSnapshot("tryWalk", { revertReduced, revertShare, revertCaptures });
         try {
             this.walk();
             return true;
@@ -387,6 +416,19 @@ class RGXWalker {
             throw e;
         }
     }
+    async tryWalkAsync({ revertReduced = false, revertShare = false, revertCaptures = false } = {}, yieldFn) {
+        this._walkerSnapshot("tryWalk", { revertReduced, revertShare, revertCaptures });
+        try {
+            await this.walkAsync(yieldFn);
+            return true;
+        }
+        catch (e) {
+            this.restore("tryWalk");
+            if (isMatchError(e))
+                return false;
+            throw e;
+        }
+    }
     // Clone method
     clone(depth = "max") {
         if (depth === 0)

package/package.json

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