@ptolemy2002/rgx 1.1.0 → 1.2.0

package/README.md

@@ -4,11 +4,12 @@ A library for easy construction and validation of regular expressions in TypeScr
 ## Type Reference
 ```typescript
 import { Branded } from "@ptolemy2002/ts-brand-utils";
+import { MaybeArray } from "@ptolemy2002/ts-utils";
 
 type RGXNoOpToken = null | undefined;
 type RGXLiteralToken = RegExp;
 type RGXNativeToken = string | number | boolean | RGXNoOpToken;
-type RGXConvertibleToken = { toRgx: () => RGXNativeToken | RGXNativeToken[] };
+type RGXConvertibleToken = { toRgx: () => MaybeArray<RGXNativeToken | RGXLiteralToken> };
 type RGXToken = RGXNativeToken | RGXConvertibleToken | RGXToken[];
 
 const validRegexSymbol = Symbol('ValidRegex');
@@ -143,7 +144,7 @@ Escapes special regex characters in the given string and brands the result as a
 
 ### resolveRGXToken
 ```typescript
-function resolveRGXToken(token: RGXToken): string
+function resolveRGXToken(token: RGXToken): ValidRegexString
 ```
 
 Resolves an RGX token to a string. No-op tokens resolve to an empty string, literal tokens are included as-is (wrapped in a non-capturing group), native tokens are converted to strings and escaped, convertible tokens are converted using their `toRgx` method and then resolved recursively, and arrays of tokens are resolved as unions of their resolved elements (placed in a non-capturing group).
@@ -152,11 +153,11 @@ Resolves an RGX token to a string. No-op tokens resolve to an empty string, lite
   - `token` (`RGXToken`): The RGX token to resolve.
 
 #### Returns
-- `string`: The resolved string representation of the RGX token.
+- `ValidRegexString`: The resolved string representation of the RGX token. This is guaranteed to be a valid regex string, as convertible tokens are validated to only produce valid regex strings or arrays of valid regex strings.
 
 ### rgxConcat
 ```typescript
-function rgxConcat(tokens: RGXToken[]): string
+function rgxConcat(tokens: RGXToken[]): ValidRegexString
 ```
 
 A helper function that resolves an array of RGX tokens and concatenates their resolved string representations together. This is useful for cases where you want to concatenate multiple tokens without creating a union between them.
@@ -165,7 +166,7 @@ A helper function that resolves an array of RGX tokens and concatenates their re
   - `tokens` (`RGXToken[]`): The array of RGX tokens to resolve and concatenate.
 
 #### Returns
-- `string`: The concatenated string representation of the resolved RGX tokens.
+- `ValidRegexString`: The concatenated string representation of the resolved RGX tokens. This is guaranteed to be a valid regex string, as it is composed of the resolved forms of RGX tokens, which are all valid regex strings.
 
 ### rgx
 ```typescript

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import { Branded } from "@ptolemy2002/ts-brand-utils";
+import { MaybeArray } from "@ptolemy2002/ts-utils";
 export type RGXNoOpToken = null | undefined;
 export type RGXLiteralToken = RegExp;
 export type RGXNativeToken = string | number | boolean | RGXNoOpToken;
 export type RGXConvertibleToken = {
-    toRgx: () => RGXNativeToken | RGXNativeToken[];
+    toRgx: () => MaybeArray<RGXNativeToken | RGXLiteralToken>;
 };
 export type RGXToken = RGXNativeToken | RGXLiteralToken | RGXConvertibleToken | RGXToken[];
 export type RGXTokenType = 'no-op' | 'literal' | 'native' | 'convertible' | RGXTokenType[];
@@ -21,6 +22,6 @@ export declare function rgxTokenType(value: RGXToken): RGXTokenType;
 export declare function rgxTokenFromType<T extends RGXTokenType>(type: T, value: RGXToken): RGXTokenFromType<T>;
 export declare function isValidRegex(value: string): value is ValidRegexString;
 export declare function escapeRegex(value: string): ValidRegexString;
-export declare function resolveRGXToken(token: RGXToken): string;
-export declare function rgxConcat(tokens: RGXToken[]): string;
+export declare function resolveRGXToken(token: RGXToken): ValidRegexString;
+export declare function rgxConcat(tokens: RGXToken[]): ValidRegexString;
 export default function rgx(strings: TemplateStringsArray, ...tokens: RGXToken[]): RegExp;

package/dist/index.js

@@ -31,9 +31,9 @@ function isRGXConvertibleToken(value) {
         if ((0, is_callable_1.default)(value.toRgx)) {
             const returnValue = value.toRgx();
             if (Array.isArray(returnValue)) {
-                return returnValue.every(isRGXNativeToken);
+                return returnValue.every(value => isRGXNativeToken(value) || isRGXLiteralToken(value));
             }
-            return isRGXNativeToken(returnValue);
+            return isRGXNativeToken(returnValue) || isRGXLiteralToken(returnValue);
         }
         return false;
     }

package/package.json

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