@ptolemy2002/rgx 7.2.0 → 7.3.0

package/README.md

@@ -24,6 +24,7 @@ type RGXToken = RGXNativeToken | RGXLiteralToken | RGXConvertibleToken | RGXToke
 type RGXClassTokenConstructor = new (...args: unknown[]) => RGXClassToken;
 type RGXGroupedToken = RGXToken[] | RGXLiteralToken | RGXGroupedConvertibleToken;
 type RGXGroupedConvertibleToken = (RGXConvertibleToken & { readonly rgxIsGroup: true }) | (Omit<RGXConvertibleToken, "toRgx"> & { toRgx: () => RGXGroupedToken, readonly rgxGroupWrap: true  });
+type RGXRepeatableConvertibleToken = RGXConvertibleToken & { readonly rgxIsRepeatable: true | undefined };
 
 const validRegexSymbol = Symbol('rgx.ValidRegex');
 type ValidRegexBrandSymbol = typeof validRegexSymbol;
@@ -45,7 +46,7 @@ type ValidIdentifier = Branded<string, [ValidIdentifierBrandSymbol]>;
 
 type RGXTokenType = 'no-op' | 'literal' | 'native' | 'convertible' | 'class' | RGXTokenType[];
 type RGXTokenTypeFlat = Exclude<RGXTokenType, RGXTokenType[]> | "array";
-type RGXTokenTypeGuardInput = RGXTokenTypeFlat | null | RGXClassTokenConstructor | typeof RegExp | typeof ExtRegExp | typeof RGXTokenCollection | RGXTokenTypeGuardInput[];
+type RGXTokenTypeGuardInput = "repeatable" | RGXTokenTypeFlat | null | RGXClassTokenConstructor | typeof RegExp | typeof ExtRegExp | typeof RGXTokenCollection | RGXTokenTypeGuardInput[];
 type RGXTokenFromType<T extends RGXTokenTypeGuardInput> =
     // Maps token type strings to their corresponding types, e.g.:
     // 'no-op' -> RGXNoOpToken, 'literal' -> RGXLiteralToken, etc.
@@ -911,7 +912,7 @@ Converts an `RGXTokenType` to its flat equivalent `RGXTokenTypeFlat`. If the typ
 function rgxTokenTypeGuardInputToFlat(type: RGXTokenTypeGuardInput): RGXTokenTypeFlat | null
 ```
 
-Converts an `RGXTokenTypeGuardInput` to its flat equivalent. If the type is `null`, it returns `null`; if it is an array, it returns `'array'`; if it is an `RGXClassTokenConstructor` (a constructor for an `RGXClassToken` subclass), it returns `'class'` (making it slightly lossy in that case); otherwise, it returns the type as-is.
+Converts an `RGXTokenTypeGuardInput` to its flat equivalent. If the type is `null`, it returns `null`; if it is an array, it returns `'array'`; if it is a RegEx constructor, it returns `'literal`; if it is the `RGXTokenCollection` constructor, it returns `'convertible'`; if it is an `RGXClassTokenConstructor` (a constructor for an `RGXClassToken` subclass), it returns `'class'` (making it slightly lossy in that case); otherwise, it returns the type as-is.
 
 #### Parameters
   - `type` (`RGXTokenTypeGuardInput`): The type guard input to convert.
@@ -930,6 +931,8 @@ When `type` is a constructor, it performs an `instanceof` check against that spe
 
 When `type` is an array, it checks that every element of the value array is a valid RGX token matching the corresponding type in the `type` array. If `matchLength` is `true` (the default), it also requires that the value array has the same length as the type array; if `false`, it allows the value array to be longer than the type array, as long as all elements up to the length of the type array match and all elements after that are still valid RGX tokens of any type.
 
+When `type` is `"repeatable"`, it passes for any token that is not convertible, then checks if `rgxIsRepeatable` is `true | undefined` for convertible tokens.
+
 #### Parameters
   - `value` (`unknown`): The value to check.
   - `type` (`T`, optional): The token type to check against. Can be a token type string, `null` (checks against all token types), an `RGXClassTokenConstructor` (checks via `instanceof`), or an array of these. Defaults to `null`.

package/dist/class/repeat.js

@@ -32,7 +32,7 @@ class RGXRepeatToken extends base_1.RGXClassToken {
         return this._token;
     }
     set token(value) {
-        if ((0, typeGuards_1.isRGXToken)(value, "convertible") && typeof value.rgxIsRepeatable === "boolean" && !value.rgxIsRepeatable) {
+        if ((0, typeGuards_1.isRGXToken)(value, "convertible") && !(0, typeGuards_1.isRGXToken)(value, "repeatable")) {
             if ((0, typeGuards_1.isRGXToken)(value, "class")) {
                 throw new errors_1.RGXNotSupportedError(`Repeating ${value.constructor.name} tokens`, "The token was manually marked as non-repeatable.");
             }

package/dist/constants.js

@@ -61,6 +61,13 @@ defineRGXConstant("start", {
         return /^/;
     }
 });
+defineRGXConstant("line-start", {
+    rgxGroupWrap: false,
+    rgxIsRepeatable: false,
+    toRgx() {
+        return /^/m;
+    }
+});
 defineRGXConstant("end", {
     rgxGroupWrap: false,
     rgxIsRepeatable: false,
@@ -68,6 +75,13 @@ defineRGXConstant("end", {
         return /$/;
     }
 });
+defineRGXConstant("line-end", {
+    rgxGroupWrap: false,
+    rgxIsRepeatable: false,
+    toRgx() {
+        return /$/m;
+    }
+});
 defineRGXConstant("word-bound", {
     rgxGroupWrap: false,
     rgxIsRepeatable: false,

package/dist/typeGuards.js

@@ -65,6 +65,8 @@ const e = __importStar(require("./errors"));
 const is_callable_1 = __importDefault(require("is-callable"));
 const internal_1 = require("./internal");
 const class_1 = require("./class");
+const ExtRegExp_1 = require("./ExtRegExp");
+const collection_1 = require("./collection");
 function isRGXNoOpToken(value) {
     return value === null || value === undefined;
 }
@@ -171,8 +173,14 @@ function rgxTokenTypeGuardInputToFlat(type) {
         return null;
     if (Array.isArray(type))
         return 'array';
+    if (type === RegExp || type === ExtRegExp_1.ExtRegExp)
+        return 'literal';
+    if (type === collection_1.RGXTokenCollection)
+        return 'convertible';
     if ((0, internal_1.isConstructor)(type))
         return 'class';
+    if (type === "repeatable")
+        return null;
     return type;
 }
 function isRGXToken(value, type = null, matchLength = true) {
@@ -192,6 +200,11 @@ function isRGXToken(value, type = null, matchLength = true) {
         return true;
     if (typeMatches('convertible') && isRGXConvertibleToken(value))
         return true;
+    // Non-covertible tokens are repeatable by default. Convertible tokens are only non-repeatable if they have the rgxIsRepeatable property set to false.
+    if (type === 'repeatable' && !isRGXConvertibleToken(value, false))
+        return true;
+    if (type === 'repeatable' && isRGXConvertibleToken(value))
+        return value.rgxIsRepeatable ?? true;
     if (typeMatches('array') && isRGXArrayToken(value))
         return true;
     if (Array.isArray(type) && Array.isArray(value) && (!matchLength || type.length === value.length)) {

package/dist/types.d.ts

@@ -22,10 +22,13 @@ export type RGXGroupedConvertibleToken = (RGXConvertibleToken & {
     toRgx: () => RGXGroupedToken;
     readonly rgxGroupWrap: true;
 });
+export type RGXRepeatableConvertibleToken = RGXConvertibleToken & {
+    readonly rgxIsRepeatable: true | undefined;
+};
 export type RGXTokenType = 'no-op' | 'literal' | 'native' | 'convertible' | 'class' | RGXTokenType[];
 export type RGXTokenTypeFlat = Exclude<RGXTokenType, RGXTokenType[]> | "array";
-export type RGXTokenTypeGuardInput = 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 new (...args: unknown[]) => infer R ? R : T extends 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;
 export type RangeObject = {

package/package.json

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