@ptolemy2002/rgx 7.7.4 → 8.0.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as t from "./types";
 import { ExtRegExp } from "./ExtRegExp";
-import { RGXWalker } from "./walker";
+import { RGXTokenOrPart, RGXWalker } from "./walker";
 export * from "./errors";
 export * from "./types";
 export * from "./typeGuards";
@@ -16,5 +16,5 @@ export * from "./constants";
 export * from "./walker";
 export declare function rgxa(tokens: t.RGXToken[], flags?: string): ExtRegExp;
 export default function rgx(flags?: string, multiline?: boolean): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => ExtRegExp;
-export declare function rgxwa<R = unknown>(source: string, tokens: t.RGXToken[], options?: Omit<t.RGXWOptions<R>, "multiline">): RGXWalker<R>;
-export declare function rgxw<R = unknown>(source: string, { multiline, ...options }?: t.RGXWOptions<R>): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => RGXWalker<R>;
+export declare function rgxwa<R = unknown, T = unknown>(source: string, tokens: RGXTokenOrPart<R, T>[], options?: Omit<t.RGXWOptions<R>, "multiline">): RGXWalker<R>;
+export declare function rgxw<R = unknown, T = unknown>(source: string, { multiline, ...options }?: t.RGXWOptions<R>): (strings: TemplateStringsArray, ...tokens: RGXTokenOrPart<R, T>[]) => RGXWalker<R>;

package/dist/index.js

@@ -54,7 +54,7 @@ function rgx(flags = '', multiline = true) {
     };
 }
 function rgxwa(source, tokens, options = {}) {
-    (0, internal_1.assureAcceptance)(tokens, '');
+    (0, internal_1.assureAcceptance)(tokens.map(t => walker_1.RGXPart.check(t) ? t.token : t), '');
     return new walker_1.RGXWalker(source, tokens, options);
 }
 function rgxw(source, { multiline = true, ...options } = {}) {

package/dist/types.d.ts

@@ -3,7 +3,6 @@ import type { RGXClassToken } from "./class";
 import type { ExtRegExp } from "./ExtRegExp";
 import type { RGXTokenCollection } from "./collection";
 import type { RGXWalkerOptions } from "./walker";
-import type { RGXPart, RGXWalker } from "./walker";
 export type RGXNoOpToken = null | undefined;
 export type RGXLiteralToken = RegExp;
 export type RGXNativeToken = string | number | boolean | RGXNoOpToken;
@@ -28,7 +27,7 @@ export type RGXRepeatableConvertibleToken = RGXConvertibleToken & {
 };
 export type RGXTokenType = 'no-op' | 'literal' | 'native' | 'convertible' | 'class' | RGXTokenType[];
 export type RGXTokenTypeFlat = Exclude<RGXTokenType, RGXTokenType[]> | "array";
-export type RGXTokenTypeGuardInput = "repeatable" | RGXTokenTypeFlat | null | RGXClassTokenConstructor | typeof RegExp | typeof ExtRegExp | typeof RGXTokenCollection | typeof RGXWalker | typeof RGXPart | RGXTokenTypeGuardInput[];
+export type RGXTokenTypeGuardInput = "repeatable" | RGXTokenTypeFlat | null | RGXClassTokenConstructor | typeof RegExp | typeof ExtRegExp | typeof RGXTokenCollection | RGXTokenTypeGuardInput[];
 export type RGXTokenFromType<T extends RGXTokenTypeGuardInput> = T extends null ? RGXToken : T extends 'no-op' ? RGXNoOpToken : T extends 'literal' ? RGXLiteralToken : T extends 'native' ? RGXNativeToken : T extends 'convertible' ? RGXConvertibleToken : T extends 'class' ? RGXClassToken : T extends 'array' ? RGXToken[] : T extends 'repeatable' ? Exclude<RGXToken, RGXConvertibleToken> | RGXRepeatableConvertibleToken : T extends new (...args: unknown[]) => infer R ? R : T extends RGXTokenTypeGuardInput[] ? {
     [K in keyof T]: T[K] extends RGXTokenTypeGuardInput ? RGXTokenFromType<T[K]> : never;
 } : never;

package/dist/walker/base.d.ts

@@ -1,6 +1,5 @@
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
-import { RGXTokenCollection, RGXTokenCollectionInput } from "../collection";
-import { RGXConvertibleToken, RGXToken } from "../types";
+import { RGXToken } from "../types";
 import { RGXPart, RGXCapture } from "./part";
 export type RGXWalkerOptions<R> = {
     startingSourcePosition?: number;
@@ -8,10 +7,11 @@ export type RGXWalkerOptions<R> = {
     infinite?: boolean;
     looping?: boolean;
 };
-export declare class RGXWalker<R> implements RGXConvertibleToken {
+export type RGXTokenOrPart<R, T = unknown> = RGXToken | RGXPart<R, T>;
+export declare class RGXWalker<R> {
     readonly source: string;
     _sourcePosition: number;
-    readonly tokens: RGXTokenCollection;
+    readonly tokens: RGXTokenOrPart<R>[];
     _tokenPosition: number;
     reduced: R;
     captures: RGXCapture[];
@@ -26,22 +26,21 @@ export declare class RGXWalker<R> implements RGXConvertibleToken {
     get tokenPosition(): number;
     set tokenPosition(value: number);
     get stopped(): boolean;
-    constructor(source: string, tokens: RGXTokenCollectionInput, options?: RGXWalkerOptions<R>);
+    constructor(source: string, tokens: RGXTokenOrPart<R>[], options?: RGXWalkerOptions<R>);
     stop(): this;
     atTokenEnd(): boolean;
-    hasNextToken(predicate?: (token: RGXToken) => boolean): boolean;
+    hasNextToken(predicate?: (token: RGXToken | RGXPart<R>) => boolean): boolean;
     atSourceEnd(): boolean;
     hasNextSource(predicate?: (rest: string) => boolean): boolean;
     lastCapture(): RGXCapture | null;
-    currentToken(): RGXToken;
+    currentToken(): RGXTokenOrPart<R, unknown>;
     remainingSource(): string | null;
-    capture(token: RGXToken, includeMatch: true): RegExpExecArray;
-    capture(token: RGXToken, includeMatch?: false): string;
+    capture(token: RGXTokenOrPart<R>, includeMatch: true): RegExpExecArray;
+    capture(token: RGXTokenOrPart<R>, includeMatch?: false): string;
     step(): RGXCapture | null;
-    stepToToken(predicate: (token: RGXToken) => boolean): this;
-    stepToPart(predicate?: (part: RGXPart<R>) => boolean): this;
+    stepToToken(predicate: (token: RGXTokenOrPart<R>) => boolean): this;
+    stepToPart(predicate?: (part: RGXPart<R, unknown>) => boolean): this;
     walk(): this;
-    toRgx(): RGXTokenCollection;
     clone(depth?: CloneDepth): RGXWalker<R>;
 }
 export declare function rgxWalker<R>(...args: ConstructorParameters<typeof RGXWalker<R>>): RGXWalker<R>;

package/dist/walker/base.js

@@ -46,7 +46,7 @@ class RGXWalker {
         this._stopped = false;
         this.source = source;
         this.sourcePosition = options.startingSourcePosition ?? 0;
-        this.tokens = new collection_1.RGXTokenCollection(tokens, "concat");
+        this.tokens = tokens;
         this.tokenPosition = 0;
         this.reduced = options.reduced ?? null;
         this.infinite = options.infinite ?? false;
@@ -76,7 +76,7 @@ class RGXWalker {
     currentToken() {
         if (this.atTokenEnd())
             return null;
-        return this.tokens.at(this.tokenPosition);
+        return this.tokens[this.tokenPosition];
     }
     remainingSource() {
         if (this.atSourceEnd())
@@ -84,7 +84,7 @@ class RGXWalker {
         return this.source.slice(this.sourcePosition);
     }
     capture(token, includeMatch = false) {
-        const regex = (0, index_1.rgxa)([token]);
+        const regex = (0, index_1.rgxa)([part_1.RGXPart.check(token) ? token.token : token]);
         const match = (0, index_1.assertRegexMatchesAtPosition)(regex, this.source, this.sourcePosition, 10, true);
         this.sourcePosition += match[0].length;
         return includeMatch ? match : match[0];
@@ -119,29 +119,29 @@ class RGXWalker {
         }
         // Capture the match
         const start = this.sourcePosition;
-        let innerToken = token;
+        let branchedToken;
         if (isPart)
-            innerToken = createBranchGroups(token.token);
-        const capture = this.capture(innerToken, true);
+            branchedToken = createBranchGroups(token.token);
+        else
+            branchedToken = createBranchGroups(token);
+        const capture = this.capture(branchedToken, true);
         const raw = isPart ? token.rawTransform(capture[0]) : capture[0];
         const end = this.sourcePosition;
         const value = isPart ? token.transform(raw) : raw;
         let branch = 0;
-        if (isPart) {
-            // Determine branch index for captureResult by finding the first index
-            // with non-undefined match group.
-            for (let i = 0; i < capture.length; i++) {
-                const branchKey = `rgx_branch_${i}`;
-                if (capture.groups && capture.groups[branchKey] !== undefined) {
-                    branch = i;
-                    break;
-                }
+        // Determine branch index for captureResult by finding the first index
+        // with non-undefined match group.
+        for (let i = 0; i < capture.length; i++) {
+            const branchKey = `rgx_branch_${i}`;
+            if (capture.groups && capture.groups[branchKey] !== undefined) {
+                branch = i;
+                break;
             }
         }
         const captureResult = {
             raw, value, start, end, branch,
             ownerId: isPart && token.hasId() ? token.id : null,
-            groups: isPart ? capture.groups ?? null : null
+            groups: capture.groups ?? null
         };
         // Validate the part. If validation fails, it will throw an error, so nothing below will run.
         if (isPart) {
@@ -194,15 +194,11 @@ class RGXWalker {
     walk() {
         return this.stepToToken(() => false);
     }
-    // When used as a convertible token, treat the walker as its collection.
-    toRgx() {
-        return this.tokens;
-    }
     // Clone method
     clone(depth = "max") {
         if (depth === 0)
             return this;
-        const clone = new RGXWalker(this.source, this.tokens.clone((0, immutability_utils_1.depthDecrement)(1)), {
+        const clone = new RGXWalker(this.source, (0, immutability_utils_1.extClone)(this.tokens, (0, immutability_utils_1.depthDecrement)(1)), {
             startingSourcePosition: this.sourcePosition,
             reduced: (0, immutability_utils_1.extClone)(this.reduced, (0, immutability_utils_1.depthDecrement)(1)),
             infinite: this.infinite,
@@ -220,3 +216,4 @@ RGXWalker.assert = (0, internal_1.createAssertClassGuardFunction)(RGXWalker);
 function rgxWalker(...args) {
     return new RGXWalker(...args);
 }
+;

package/dist/walker/part.d.ts

@@ -1,4 +1,4 @@
-import { RGXConvertibleToken, RGXToken } from "../types";
+import { RGXToken } from "../types";
 import type { RGXWalker } from "./base";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
 export type RGXPartControl = "skip" | "stop" | "silent" | void;
@@ -19,7 +19,7 @@ export type RGXPartOptions<R, T = string> = {
     beforeCapture: ((part: RGXPart<R, T>, walker: RGXWalker<R>) => RGXPartControl) | null;
     afterCapture: ((capture: RGXCapture<T>, part: RGXPart<R, T>, walker: RGXWalker<R>) => void) | null;
 };
-export declare class RGXPart<R, T = string> implements RGXConvertibleToken {
+export declare class RGXPart<R, T = string> {
     id: string | null;
     token: RGXToken;
     readonly rawTransform: RGXPartOptions<R, T>["rawTransform"];
@@ -34,9 +34,6 @@ export declare class RGXPart<R, T = string> implements RGXConvertibleToken {
         id: string;
     };
     validate(capture: RGXCapture<T>, walker: RGXWalker<R>): void;
-    get rgxIsGroup(): boolean;
-    get rgxIsRepeatable(): boolean;
-    toRgx(): RGXToken;
     clone(depth?: CloneDepth): RGXPart<R, T>;
 }
 export declare function rgxPart<R, T = string>(...args: ConstructorParameters<typeof RGXPart<R, T>>): RGXPart<R, T>;

package/dist/walker/part.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RGXPart = void 0;
 exports.rgxPart = rgxPart;
-const typeGuards_1 = require("../typeGuards");
 const internal_1 = require("../internal");
 const clone_1 = require("../clone");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
@@ -27,19 +26,6 @@ class RGXPart {
         const message = typeof result === "string" ? result : "Part Validation Failed";
         throw new errors_1.RGXPartValidationFailedError(this.id, message, capture.raw, capture.value);
     }
-    // Properties used for conversion to an RGXToken
-    get rgxIsGroup() {
-        return (0, typeGuards_1.isRGXGroupedToken)(this.token);
-    }
-    get rgxIsRepeatable() {
-        if ((0, typeGuards_1.isRGXToken)(this.token, 'convertible'))
-            return this.token.rgxIsRepeatable ?? true;
-        // Assume any other token is repeatable, since we don't know its implementation.
-        return true;
-    }
-    toRgx() {
-        return this.token;
-    }
     // Clone method
     clone(depth = "max") {
         if (depth === 0)

package/package.json

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