@ptolemy2002/rgx 2.6.0 → 2.7.1

package/README.md

@@ -23,7 +23,7 @@ type ValidVanillaRegexFlags = Branded<string, [ValidVanillaRegexFlagsBrandSymbol
 
 type RGXTokenType = 'no-op' | 'literal' | 'native' | 'convertible' | RGXTokenType[];
 type RGXTokenTypeFlat = Exclude<RGXTokenType, RGXTokenType[]> | "array";
-type RGXTokenTypeGuardInput = Exclude<RGXTokenType, RGXTokenType[]> | RGXTokenTypeFlat | null | RGXTokenTypeGuardInput[];
+type RGXTokenTypeGuardInput = RGXTokenTypeFlat | null | RGXTokenTypeGuardInput[];
 type RGXTokenFromType<T extends RGXTokenTypeGuardInput> =
     // ... see source for full definition
 ;
@@ -279,12 +279,36 @@ Asserts that the given value is a convertible token (an object with a `toRgx` me
 #### Returns
 - `void`: This function does not return a value, but will throw an error if the assertion fails.
 
+### isRGXArrayToken
+```typescript
+function isRGXArrayToken(value: unknown): value is RGXToken[]
+```
+Checks if the given value is an array of RGX tokens. Validates that the value is an array and that every element is a valid RGX token (of any type, including nested arrays).
+
+#### Parameters
+  - `value` (`unknown`): The value to check.
+
+#### Returns
+- `boolean`: `true` if the value is an array of RGX tokens, otherwise `false`.
+
+### assertRGXArrayToken
+```typescript
+function assertRGXArrayToken(value: unknown): asserts value is RGXToken[]
+```
+Asserts that the given value is an array of RGX tokens. Validates that the value is an array and that every element is a valid RGX token (of any type, including nested arrays). If the assertion fails, an `RGXInvalidTokenError` will be thrown.
+
+#### Parameters
+  - `value` (`unknown`): The value to assert.
+
+#### Returns
+- `void`: This function does not return a value, but will throw an error if the assertion fails.
+
 ### rgxTokenType
 ```typescript
-function rgxTokenType(value: RGXToken): RGXTokenType
+function rgxTokenType(value: unknown): RGXTokenType
 ```
 
-Determines the type of a given RGX token (`no-op`, `literal`, `native`, `convertible`, or an array of the former).
+Determines the type of a given RGX token value (`no-op`, `literal`, `native`, `convertible`, or an array of the former) or throws an error if the value is not a valid RGX token.
 
 If you narrow the result of this function to something more specific, you can then convert these string or array literals into their corresponding token types using the `RGXTokenFromType` utility type or `rgxTokenFromType` function.
 
@@ -299,16 +323,16 @@ if (type === 'native') {
 ```
 
 #### Parameters
-  - `value` (`RGXToken`): The RGX token to check.
+  - `value` (`unknown`): The value to check.
 
 #### Returns
 - `RGXTokenType`: The type of the RGX token.
 
 ### rgxTokenTypeFlat
 ```typescript
-function rgxTokenTypeFlat(value: RGXToken): RGXTokenTypeFlat
+function rgxTokenTypeFlat(value: unknown): RGXTokenTypeFlat
 ```
-Determines the flat type of a given RGX token (`no-op`, `literal`, `native`, `convertible`, or `array`). The `array` type represents any array of RGX tokens, regardless of the types of the individual tokens within the array.
+Determines the flat type of a given RGX token value (`no-op`, `literal`, `native`, `convertible`, or `array`) or throws an error if the value is not a valid RGX token. The `array` type represents any array of RGX tokens, regardless of the types of the individual tokens within the array.
 
 If you narrow the result of this function to something more specific, you can then convert these string literals into their corresponding token types using the `RGXTokenFromType` utility type or `rgxTokenFromType` function.
 
@@ -322,14 +346,14 @@ if (type === 'array') {
 ```
 
 #### Parameters
-  - `value` (`RGXToken`): The RGX token to check.
+  - `value` (`unknown`): The value to check.
 
 #### Returns
 - `RGXTokenTypeFlat`: The flat type of the RGX token.
 
 ### rgxTokenFromType
 ```typescript
-function rgxTokenFromType<T extends RGXTokenType | RGXTokenTypeFlat>(type: T, value: RGXToken): RGXTokenFromType<T>
+function rgxTokenFromType<T extends RGXTokenTypeGuardInput>(type: T, value: RGXToken): RGXTokenFromType<T>
 ```
 
 Does nothing at runtime, but performs a type assertion to the correct subset of `RGXToken` based on the provided `RGXTokenType`.

package/dist/index.js

@@ -41,6 +41,7 @@ exports.default = rgx;
 const tg = __importStar(require("./typeGuards"));
 const class_1 = require("./class");
 const concat_1 = require("./concat");
+const internal_1 = require("./internal");
 __exportStar(require("./errors"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./typeGuards"), exports);
@@ -50,16 +51,6 @@ __exportStar(require("./resolve"), exports);
 __exportStar(require("./concat"), exports);
 // Call this for certain class methods to work correctly
 (0, class_1.rgxClassInit)();
-function taggedTemplateToTokenArray(strings, tokens) {
-    const tokenArray = [];
-    for (let i = 0; i < strings.length; i++) {
-        if (strings[i])
-            tokenArray.push(strings[i]);
-        if (i < tokens.length)
-            tokenArray.push(tokens[i]);
-    }
-    return tokenArray;
-}
 function rgxa(tokens, flags = '') {
     tg.assertValidVanillaRegexFlags(flags);
     const pattern = (0, concat_1.rgxConcat)(tokens);
@@ -68,6 +59,6 @@ function rgxa(tokens, flags = '') {
 function rgx(flags = '') {
     tg.assertValidVanillaRegexFlags(flags);
     return (strings, ...tokens) => {
-        return rgxa(taggedTemplateToTokenArray(strings, tokens), flags);
+        return rgxa((0, internal_1.taggedTemplateToArray)(strings, tokens), flags);
     };
 }

package/dist/internal/index.d.ts

@@ -1 +1,2 @@
 export * from "./createConstructFunction";
+export * from "./taggedTemplateToArray";

package/dist/internal/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./createConstructFunction"), exports);
+__exportStar(require("./taggedTemplateToArray"), exports);

package/dist/internal/taggedTemplateToArray.d.ts

@@ -0,0 +1 @@
+export declare function taggedTemplateToArray<T>(strings: TemplateStringsArray, tokens: T[]): (string | T)[];

package/dist/internal/taggedTemplateToArray.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taggedTemplateToArray = taggedTemplateToArray;
+function taggedTemplateToArray(strings, tokens) {
+    function isNullOrUndefined(value) {
+        return value === null || value === undefined;
+    }
+    const array = [];
+    for (let i = 0; i < Math.max(strings.length, tokens.length); i++) {
+        const string = strings[i];
+        const token = tokens[i];
+        // Strings always come before tokens
+        if (!isNullOrUndefined(string))
+            array.push(string);
+        if (!isNullOrUndefined(token))
+            array.push(token);
+    }
+    return array;
+}

package/dist/typeGuards.d.ts

@@ -7,9 +7,11 @@ export declare function isRGXNativeToken(value: unknown): value is t.RGXNativeTo
 export declare function assertRGXNativeToken(value: unknown): asserts value is t.RGXNativeToken;
 export declare function isRGXConvertibleToken(value: unknown): value is t.RGXConvertibleToken;
 export declare function assertRGXConvertibleToken(value: unknown): asserts value is t.RGXConvertibleToken;
-export declare function rgxTokenTypeFlat(value: t.RGXToken): t.RGXTokenTypeFlat;
-export declare function rgxTokenType(value: t.RGXToken): t.RGXTokenType;
-export declare function rgxTokenFromType<T extends t.RGXTokenType | t.RGXTokenTypeFlat>(type: T, value: t.RGXToken): t.RGXTokenFromType<T>;
+export declare function isRGXArrayToken(value: unknown): value is t.RGXToken[];
+export declare function assertRGXArrayToken(value: unknown): asserts value is t.RGXToken[];
+export declare function rgxTokenTypeFlat(value: unknown): t.RGXTokenTypeFlat;
+export declare function rgxTokenType(value: unknown): t.RGXTokenType;
+export declare function rgxTokenFromType<T extends t.RGXTokenTypeGuardInput>(type: T, value: t.RGXToken): t.RGXTokenFromType<T>;
 export declare function rgxTokenTypeToFlat(type: t.RGXTokenType): t.RGXTokenTypeFlat;
 export declare function rgxTokenTypeGuardInputToFlat(type: t.RGXTokenTypeGuardInput): t.RGXTokenTypeFlat | null;
 export declare function isRGXToken<T extends t.RGXTokenTypeGuardInput = null>(value: unknown, type?: T, matchLength?: boolean): value is t.RGXTokenFromType<T>;

package/dist/typeGuards.js

@@ -44,6 +44,8 @@ exports.isRGXNativeToken = isRGXNativeToken;
 exports.assertRGXNativeToken = assertRGXNativeToken;
 exports.isRGXConvertibleToken = isRGXConvertibleToken;
 exports.assertRGXConvertibleToken = assertRGXConvertibleToken;
+exports.isRGXArrayToken = isRGXArrayToken;
+exports.assertRGXArrayToken = assertRGXArrayToken;
 exports.rgxTokenTypeFlat = rgxTokenTypeFlat;
 exports.rgxTokenType = rgxTokenType;
 exports.rgxTokenFromType = rgxTokenFromType;
@@ -99,6 +101,16 @@ function assertRGXConvertibleToken(value) {
         throw new e.RGXInvalidTokenError(`Invalid convertible token`, { type: "tokenType", values: ['convertible'] }, value);
     }
 }
+function isRGXArrayToken(value) {
+    return Array.isArray(value) && value.every(item => isRGXNoOpToken(item) || isRGXLiteralToken(item) ||
+        isRGXNativeToken(item) ||
+        isRGXConvertibleToken(item) || isRGXArrayToken(item));
+}
+function assertRGXArrayToken(value) {
+    if (!isRGXArrayToken(value)) {
+        throw new e.RGXInvalidTokenError("Invalid array token", { type: "tokenType", values: ['array'] }, value);
+    }
+}
 function rgxTokenTypeFlat(value) {
     if (isRGXNoOpToken(value))
         return 'no-op';
@@ -108,21 +120,16 @@ function rgxTokenTypeFlat(value) {
         return 'native';
     if (isRGXConvertibleToken(value))
         return 'convertible';
-    if (Array.isArray(value))
+    if (isRGXArrayToken(value))
         return 'array';
-    // Ignoring this line since it should be impossible to reach if the types are correct, but we need it to satisfy the return type
-    /* istanbul ignore next */
     throw new e.RGXInvalidTokenError("Invalid RGX token", null, value);
 }
 function rgxTokenType(value) {
     const flatType = rgxTokenTypeFlat(value);
     if (flatType !== 'array')
         return flatType;
-    if (flatType === 'array')
+    else
         return value.map(rgxTokenType);
-    // Ignoring this line since it should be impossible to reach if the types are correct, but we need it to satisfy the return type
-    /* istanbul ignore next */
-    throw new e.RGXInvalidTokenError("Invalid RGX token", null, value);
 }
 function rgxTokenFromType(type, value) {
     // Ignoring this line because the function is entirely a TypeScript utility that doesn't need to be tested at runtime.
@@ -151,10 +158,8 @@ function isRGXToken(value, type = null, matchLength = true) {
         return true;
     if (typeMatches('convertible') && isRGXConvertibleToken(value))
         return true;
-    if (typeMatches('array') && Array.isArray(value)) {
-        // @ts-ignore Excessively deep type is not a problem here.
-        return value.every(item => isRGXToken(item, null));
-    }
+    if (typeMatches('array') && isRGXArrayToken(value))
+        return true;
     if (Array.isArray(type) && Array.isArray(value) && (!matchLength || type.length === value.length)) {
         // This will always be false.
         if (value.length < type.length)

package/dist/types.d.ts

@@ -10,7 +10,7 @@ export type RGXConvertibleToken = {
 export type RGXToken = RGXNativeToken | RGXLiteralToken | RGXConvertibleToken | RGXToken[];
 export type RGXTokenType = 'no-op' | 'literal' | 'native' | 'convertible' | RGXTokenType[];
 export type RGXTokenTypeFlat = Exclude<RGXTokenType, RGXTokenType[]> | "array";
-export type RGXTokenTypeGuardInput = Exclude<RGXTokenType, RGXTokenType[]> | RGXTokenTypeFlat | null | RGXTokenTypeGuardInput[];
+export type RGXTokenTypeGuardInput = RGXTokenTypeFlat | null | 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 'array' ? RGXToken[] : T extends RGXTokenTypeGuardInput[] ? {
     [K in keyof T]: T[K] extends RGXTokenTypeGuardInput ? RGXTokenFromType<T[K]> : never;
 } : never;

package/package.json

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