@ptolemy2002/rgx 4.3.0 → 4.5.0

package/README.md

@@ -32,11 +32,12 @@ 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 ExtRegExp | RGXTokenTypeGuardInput[];
+type RGXTokenTypeGuardInput = RGXTokenTypeFlat | null | RGXClassTokenConstructor | 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.
-    // Also maps RGXClassTokenConstructor to InstanceType<T> and typeof ExtRegExp to ExtRegExp.
+    // Also maps any constructor to InstanceType<T>,
+    // and preserves tuple types for constant arrays.
     // ... see source for full definition
 ;
 
@@ -904,6 +905,48 @@ Unregisters a previously registered custom flag transformer by its key. If the k
 #### Returns
 - `void`: This function does not return a value.
 
+### accentInsensitiveFlagTransformer
+```typescript
+const accentInsensitiveFlagTransformer: RegExpFlagTransformer
+```
+
+A pre-built `RegExpFlagTransformer` that makes a regex pattern accent-insensitive. It replaces any accentable characters (a, e, i, o, u and their uppercase equivalents) in the regex source with alternation groups that match both the base character and its accented variants. For example, `é` becomes `(e|é|è|ë|ê)`. The following accent mappings are supported:
+
+- `a` / `A`: á, à, ä, â, ã / Á, À, Ä, Â, Ã
+- `e` / `E`: é, è, ë, ê / É, È, Ë, Ê
+- `i` / `I`: í, ì, ï, î / Í, Ì, Ï, Î
+- `o` / `O`: ó, ò, ö, ô, õ / Ó, Ò, Ö, Ô, Õ
+- `u` / `U`: ú, ù, ü, û / Ú, Ù, Ü, Û
+
+#### Parameters
+  - `exp` (`RegExp`): The regular expression to transform.
+
+#### Returns
+- `RegExp`: A new `RegExp` with the same flags but with accentable characters in the source replaced by accent-insensitive alternation groups.
+
+### registerCustomFlagTransformers
+```typescript
+function registerCustomFlagTransformers(): void
+```
+
+Registers the library's built-in custom flag transformers. Currently registers the following:
+- `"a"` flag: `accentInsensitiveFlagTransformer` — makes patterns accent-insensitive.
+
+This function is called automatically when importing from the main module entry point, so you typically do not need to call it yourself. It only needs to be called manually if you import directly from sub-modules.
+
+#### Returns
+- `void`: This function does not return a value.
+
+### unregisterCustomFlagTransformers
+```typescript
+function unregisterCustomFlagTransformers(): void
+```
+
+Unregisters all built-in custom flag transformers that were registered by `registerCustomFlagTransformers`. Currently unregisters the `"a"` flag.
+
+#### Returns
+- `void`: This function does not return a value.
+
 ### applyFlagTransformers
 ```typescript
 function applyFlagTransformers(regex: RegExp, flags: string, alreadyAppliedFlags?: string): RegExp

package/dist/flag-transformer/accentInsensitive.d.ts

@@ -0,0 +1,2 @@
+import { RegExpFlagTransformer } from "../ExtRegExp";
+export declare const accentInsensitiveFlagTransformer: RegExpFlagTransformer;

package/dist/flag-transformer/accentInsensitive.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accentInsensitiveFlagTransformer = void 0;
+const accentPatterns = [
+    "(a|á|à|ä|â|ã)", "(A|Á|À|Ä|Â|Ã)",
+    "(e|é|è|ë|ê)", "(E|É|È|Ë|Ê)",
+    "(i|í|ì|ï|î)", "(I|Í|Ì|Ï|Î)",
+    "(o|ó|ò|ö|ô|õ)", "(O|Ó|Ò|Ö|Ô|Õ)",
+    "(u|ú|ù|ü|û)", "(U|Ú|Ù|Ü|Û)"
+];
+const accentInsensitiveFlagTransformer = function (exp) {
+    let source = exp.source;
+    const flags = exp.flags;
+    accentPatterns.forEach((pattern) => {
+        // Replace any of the characters in the pattern with the pattern itself
+        source = source.replaceAll(new RegExp(pattern, "g"), pattern);
+    });
+    return new RegExp(source, flags);
+};
+exports.accentInsensitiveFlagTransformer = accentInsensitiveFlagTransformer;

package/dist/flag-transformer/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./accentInsensitive";
+export * from "./register";

package/dist/flag-transformer/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./accentInsensitive"), exports);
+__exportStar(require("./register"), exports);

package/dist/flag-transformer/register.d.ts

@@ -0,0 +1,2 @@
+export declare function registerCustomFlagTransformers(): void;
+export declare function unregisterCustomFlagTransformers(): void;

package/dist/flag-transformer/register.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCustomFlagTransformers = registerCustomFlagTransformers;
+exports.unregisterCustomFlagTransformers = unregisterCustomFlagTransformers;
+const ExtRegExp_1 = require("../ExtRegExp");
+const accentInsensitive_1 = require("./accentInsensitive");
+function registerCustomFlagTransformers() {
+    (0, ExtRegExp_1.registerFlagTransformer)("a", accentInsensitive_1.accentInsensitiveFlagTransformer);
+}
+function unregisterCustomFlagTransformers() {
+    (0, ExtRegExp_1.unregisterFlagTransformer)("a");
+}

package/dist/index.d.ts

@@ -9,5 +9,6 @@ export * from "./resolve";
 export * from "./concat";
 export * from "./utils";
 export * from "./ExtRegExp";
+export * from "./flag-transformer";
 export declare function rgxa(tokens: t.RGXToken[], flags?: string): ExtRegExp;
 export default function rgx(flags?: string): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => ExtRegExp;

package/dist/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxa = rgxa;
 exports.default = rgx;
 const class_1 = require("./class");
+const flag_transformer_1 = require("./flag-transformer");
 const concat_1 = require("./concat");
 const internal_1 = require("./internal");
 const ExtRegExp_1 = require("./ExtRegExp");
@@ -29,8 +30,11 @@ __exportStar(require("./resolve"), exports);
 __exportStar(require("./concat"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./ExtRegExp"), exports);
+__exportStar(require("./flag-transformer"), exports);
 // Call this for certain class methods to work correctly
 (0, class_1.rgxClassInit)();
+// Call this for our custom flags to work correctly
+(0, flag_transformer_1.registerCustomFlagTransformers)();
 function rgxa(tokens, flags = '') {
     (0, ExtRegExp_1.assertValidRegexFlags)(flags);
     const pattern = (0, concat_1.rgxConcat)(tokens);

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 import { Branded } from "@ptolemy2002/ts-brand-utils";
 import type { RGXClassToken } from "./class";
-import { ExtRegExp } from "./ExtRegExp";
+import type { ExtRegExp } from "./ExtRegExp";
+import type { RGXTokenCollection } from "./collection";
 export type RGXNoOpToken = null | undefined;
 export type RGXLiteralToken = RegExp;
 export type RGXNativeToken = string | number | boolean | RGXNoOpToken;
@@ -12,10 +13,10 @@ export type RGXToken = RGXNativeToken | RGXLiteralToken | RGXConvertibleToken |
 export type RGXClassTokenConstructor = new (...args: unknown[]) => RGXClassToken;
 export type RGXTokenType = 'no-op' | 'literal' | 'native' | 'convertible' | 'class' | RGXTokenType[];
 export type RGXTokenTypeFlat = Exclude<RGXTokenType, RGXTokenType[]> | "array";
-export type RGXTokenTypeGuardInput = RGXTokenTypeFlat | null | RGXClassTokenConstructor | typeof ExtRegExp | 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 RGXTokenTypeGuardInput[] ? {
+export type RGXTokenTypeGuardInput = RGXTokenTypeFlat | null | RGXClassTokenConstructor | 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[] ? {
     [K in keyof T]: T[K] extends RGXTokenTypeGuardInput ? RGXTokenFromType<T[K]> : never;
-} : T extends RGXClassTokenConstructor ? InstanceType<T> : T extends typeof ExtRegExp ? ExtRegExp : never;
+} : never;
 export type RangeObject = {
     min?: number | null;
     max?: number | null;

package/package.json

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