@ptolemy2002/rgx 2.3.1 → 2.3.2

package/README.md

@@ -108,7 +108,7 @@ constructor(tokens: RGXToken[] = [], mode: RGXTokenCollectionMode = 'concat')
 #### Properties
 - `tokens` (`RGXToken[]`): The array of RGX tokens managed by the collection. In almost all cases, use `getTokens()` instead of accessing this property directly, as it will be copied to prevent external mutation.
 - `mode` (`RGXTokenCollectionMode`): The mode of the collection, either 'union' or 'concat'. This determines how the tokens in the collection will be resolved when `toRgx()` is called.
-- `toRgx()` (`() => RGXToken`): A method that resolves the collection to a single RGX token based on the collection mode. In both modes, a string is ultimately returned, but in 'union' mode, the tokens are resolved as alternatives (using the `|` operator), while in 'concat' mode, the tokens are resolved as concatenated together.
+- `toRgx()` (`() => ValidRegexString`): A method that resolves the collection to a single RGX token based on the collection mode. In both modes, a string is ultimately returned, but in 'union' mode, the tokens are resolved as alternatives (using the `|` operator), while in 'concat' mode, the tokens are resolved as concatenated together.
 - `getTokens()` (`() => RGXToken[]`): A method that returns a copy of the array of RGX tokens managed by the collection. This is used to prevent external mutation of the internal `tokens` array.
 - `clone()` (`() => RGXTokenCollection`): A method that creates and returns a deep clone of the RGXTokenCollection instance. This is useful for creating a new collection with the same tokens and mode without affecting the original collection.
 - `asConcat()` (`() => RGXTokenCollection`): If this collection is in 'union' mode, this method returns a new RGXTokenCollection instance with the same tokens but in 'concat' mode. If the collection is already in 'concat' mode, it simply returns itself.

package/dist/collection.d.ts

@@ -1,40 +1,42 @@
-import { RGXConvertibleTokenOutput, RGXToken } from "./types";
+import { RGXToken, ValidRegexString } from "./types";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
+import { Collection } from "@ptolemy2002/ts-utils";
 export type RGXTokenCollectionMode = 'union' | 'concat';
-export declare class RGXTokenCollection {
+export declare class RGXTokenCollection implements Collection<RGXToken> {
     mode: RGXTokenCollectionMode;
     tokens: RGXToken[];
     constructor(tokens?: RGXToken[], mode?: RGXTokenCollectionMode);
-    toRgx(): RGXConvertibleTokenOutput;
+    toRgx(): ValidRegexString;
     getTokens(): RGXToken[];
     clone(depth?: CloneDepth): RGXTokenCollection;
     asConcat(): RGXTokenCollection;
     asUnion(): RGXTokenCollection;
+    toArray(): RGXToken[];
     get length(): number;
     at(index: number): RGXToken | undefined;
-    find(predicate: (token: RGXToken, index: number, array: RGXToken[]) => boolean): RGXToken | undefined;
-    findIndex(predicate: (token: RGXToken, index: number, array: RGXToken[]) => boolean): number;
+    find(predicate: (token: RGXToken, index: number, array: RGXTokenCollection) => boolean): RGXToken | undefined;
+    findIndex(predicate: (token: RGXToken, index: number, array: RGXTokenCollection) => boolean): number;
     indexOf(token: RGXToken, fromIndex?: number): number;
     includes(token: RGXToken, fromIndex?: number): boolean;
-    some(predicate: (token: RGXToken, index: number, array: RGXToken[]) => boolean): boolean;
-    every(predicate: (token: RGXToken, index: number, array: RGXToken[]) => boolean): boolean;
-    forEach(callback: (token: RGXToken, index: number, array: RGXToken[]) => void): void;
-    map(callback: (token: RGXToken, index: number, array: RGXToken[]) => RGXToken): RGXTokenCollection;
-    filter(predicate: (token: RGXToken, index: number, array: RGXToken[]) => boolean): RGXTokenCollection;
-    reduce<T>(callback: (accumulator: T, token: RGXToken, index: number, array: RGXToken[]) => T, initialValue: T): T;
-    reduce(callback: (accumulator: RGXToken, token: RGXToken, index: number, array: RGXToken[]) => RGXToken): RGXToken;
+    some(predicate: (token: RGXToken, index: number, array: RGXTokenCollection) => boolean): boolean;
+    every(predicate: (token: RGXToken, index: number, array: RGXTokenCollection) => boolean): boolean;
+    forEach(callback: (token: RGXToken, index: number, array: RGXTokenCollection) => void): void;
+    map<T>(callback: (token: RGXToken, index: number, array: RGXTokenCollection) => T): T[];
+    filter(predicate: (token: RGXToken, index: number, array: RGXTokenCollection) => boolean): RGXTokenCollection;
+    reduce<T>(callback: (accumulator: T, token: RGXToken, index: number, array: RGXTokenCollection) => T, initialValue: T): T;
+    reduce(callback: (accumulator: RGXToken, token: RGXToken, index: number, array: RGXTokenCollection) => RGXToken): RGXToken;
     flat(depth?: number): RGXTokenCollection;
-    flatMap(callback: (token: RGXToken, index: number, array: RGXToken[]) => RGXToken | RGXToken[]): RGXTokenCollection;
+    flatMap<T>(callback: (token: RGXToken, index: number, array: RGXTokenCollection) => T | T[], depth?: number): T[];
     slice(start?: number, end?: number): RGXTokenCollection;
-    concat(...others: (RGXToken | RGXTokenCollection)[]): RGXTokenCollection;
+    concat(...others: (RGXToken | RGXToken[] | RGXTokenCollection)[]): RGXTokenCollection;
     push(...tokens: RGXToken[]): void;
     pop(): RGXToken | undefined;
     shift(): RGXToken | undefined;
     unshift(...tokens: RGXToken[]): number;
     splice(start: number, deleteCount?: number, ...items: RGXToken[]): RGXTokenCollection;
-    reverse(): this;
-    sort(compareFn?: (a: RGXToken, b: RGXToken) => number): this;
-    fill(value: RGXToken, start?: number, end?: number): this;
+    reverse(): RGXTokenCollection;
+    sort(compareFn?: (a: RGXToken, b: RGXToken) => number): RGXTokenCollection;
+    fill(value: RGXToken, start?: number, end?: number): RGXTokenCollection;
     [Symbol.iterator](): Iterator<RGXToken>;
     entries(): IterableIterator<[number, RGXToken]>;
     keys(): IterableIterator<number>;

package/dist/collection.js

@@ -11,7 +11,7 @@ class RGXTokenCollection {
     }
     toRgx() {
         if (this.mode === 'union') {
-            return (0, index_1.resolveRGXToken)(this.tokens.map(index_1.resolveRGXToken));
+            return (0, index_1.resolveRGXToken)(this.tokens);
         }
         else {
             return (0, index_1.rgxConcat)(this.tokens);
@@ -23,7 +23,7 @@ class RGXTokenCollection {
     clone(depth = "max") {
         if (depth === 0)
             return this; // No cloning at depth 0, return the same instance.
-        return new RGXTokenCollection((0, immutability_utils_1.extClone)(this.tokens, typeof depth === "number" ? depth - 1 : depth), this.mode);
+        return new RGXTokenCollection((0, immutability_utils_1.extClone)(this.tokens, (0, immutability_utils_1.depthDecrement)(depth)), this.mode);
     }
     asConcat() {
         if (this.mode === 'concat')
@@ -39,7 +39,10 @@ class RGXTokenCollection {
             clone.mode = 'union';
         });
     }
-    // ------------------ Standard array properties and methods ------------------
+    // ------------------ Abstract Impplementations ------------------
+    toArray() {
+        return this.getTokens();
+    }
     get length() {
         return this.tokens.length;
     }
@@ -47,10 +50,10 @@ class RGXTokenCollection {
         return this.tokens[index];
     }
     find(predicate) {
-        return this.tokens.find(predicate);
+        return this.tokens.find((token, index) => predicate(token, index, this));
     }
     findIndex(predicate) {
-        return this.tokens.findIndex(predicate);
+        return this.tokens.findIndex((token, index) => predicate(token, index, this));
     }
     indexOf(token, fromIndex) {
         return this.tokens.indexOf(token, fromIndex);
@@ -59,29 +62,27 @@ class RGXTokenCollection {
         return this.tokens.includes(token, fromIndex);
     }
     some(predicate) {
-        return this.tokens.some(predicate);
+        return this.tokens.some((token, index) => predicate(token, index, this));
     }
     every(predicate) {
-        return this.tokens.every(predicate);
+        return this.tokens.every((token, index) => predicate(token, index, this));
     }
     forEach(callback) {
-        this.tokens.forEach(callback);
+        this.tokens.forEach((token, index) => callback(token, index, this));
     }
     map(callback) {
-        return (0, immutability_utils_1.immutableMut)(this, clone => {
-            clone.tokens = clone.tokens.map(callback);
-        });
+        return this.tokens.map((token, index) => callback(token, index, this));
     }
     filter(predicate) {
         return (0, immutability_utils_1.immutableMut)(this, clone => {
-            clone.tokens = clone.tokens.filter(predicate);
+            clone.tokens = clone.tokens.filter((token, index) => predicate(token, index, this));
         });
     }
-    reduce(callback, ...rest) {
-        if (rest.length > 0) {
-            return this.tokens.reduce(callback, rest[0]);
+    reduce(callback, initialValue) {
+        if (initialValue !== undefined) {
+            return this.tokens.reduce((accumulator, token, index) => callback(accumulator, token, index, this), initialValue);
         }
-        return this.tokens.reduce(callback);
+        return this.tokens.reduce((accumulator, token, index) => callback(accumulator, token, index, this));
     }
     flat(depth = 1) {
         return (0, immutability_utils_1.immutableMut)(this, clone => {
@@ -89,11 +90,8 @@ class RGXTokenCollection {
             clone.tokens = clone.tokens.flat(depth);
         });
     }
-    flatMap(callback) {
-        return (0, immutability_utils_1.immutableMut)(this, clone => {
-            // Fixing TypeScript complaining about possible infinite recursion here.
-            clone.tokens = clone.tokens.flatMap(callback);
-        });
+    flatMap(callback, depth) {
+        return this.tokens.flatMap((token, index) => callback(token, index, this));
     }
     slice(start, end) {
         return (0, immutability_utils_1.immutableMut)(this, clone => {
@@ -102,7 +100,7 @@ class RGXTokenCollection {
     }
     concat(...others) {
         return (0, immutability_utils_1.immutableMut)(this, clone => {
-            const arrays = others.map(o => o instanceof RGXTokenCollection ? o.tokens : [o]);
+            const arrays = others.map(o => o instanceof RGXTokenCollection ? o.tokens : Array.isArray(o) ? o : [o]);
             clone.tokens = clone.tokens.concat(...arrays.flat());
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/rgx",
-    "version": "2.3.1",
+    "version": "2.3.2",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -32,7 +32,7 @@
         "@ptolemy2002/immutability-utils": "^2.0.0",
         "@ptolemy2002/js-utils": "^3.2.2",
         "@ptolemy2002/ts-brand-utils": "^1.0.0",
-        "@ptolemy2002/ts-utils": "^3.4.0",
+        "@ptolemy2002/ts-utils": "^3.5.1",
         "@types/is-callable": "^1.1.2",
         "@types/jest": "^29.5.0",
         "@types/lodash.clonedeep": "^4.5.9",