@ptolemy2002/rgx 2.6.0 → 2.7.0

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,6 +279,30 @@ 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
@@ -329,7 +353,7 @@ if (type === 'array') {
 
 ### 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 isRGXArrayToken(value: unknown): value is t.RGXToken[];
+export declare function assertRGXArrayToken(value: unknown): asserts value is t.RGXToken[];
 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 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';
@@ -151,10 +163,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.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",