@ptolemy2002/rgx 2.0.0 → 2.0.2

package/dist/index.d.ts

@@ -1,38 +1,8 @@
-import { Branded } from "@ptolemy2002/ts-brand-utils";
-import { MaybeArray } from "@ptolemy2002/ts-utils";
+import * as t from "./types";
 export * from "./errors";
-export type RGXNoOpToken = null | undefined;
-export type RGXLiteralToken = RegExp;
-export type RGXNativeToken = string | number | boolean | RGXNoOpToken;
-export type RGXConvertibleToken = {
-    toRgx: () => MaybeArray<RGXNativeToken | RGXLiteralToken>;
-};
-export type RGXToken = RGXNativeToken | RGXLiteralToken | RGXConvertibleToken | RGXToken[];
-export type RGXTokenType = 'no-op' | 'literal' | 'native' | 'convertible' | RGXTokenType[];
-export type RGXTokenFromType<T extends RGXTokenType> = T extends 'no-op' ? RGXNoOpToken : T extends 'literal' ? RGXLiteralToken : T extends 'native' ? RGXNativeToken : T extends 'convertible' ? RGXConvertibleToken : T extends RGXTokenType[] ? {
-    [K in keyof T]: T[K] extends RGXTokenType ? RGXTokenFromType<T[K]> : never;
-} : never;
-export declare const validRegexSymbol: unique symbol;
-export type ValidRegexBrandSymbol = typeof validRegexSymbol;
-export type ValidRegexString = Branded<string, [ValidRegexBrandSymbol]>;
-export declare const validVanillaRegexFlagsSymbol: unique symbol;
-export type ValidVanillaRegexFlagsBrandSymbol = typeof validVanillaRegexFlagsSymbol;
-export type ValidVanillaRegexFlags = Branded<string, [ValidVanillaRegexFlagsBrandSymbol]>;
-export declare function isRGXNoOpToken(value: unknown): value is RGXNoOpToken;
-export declare function assertRGXNoOpToken(value: unknown): asserts value is RGXNoOpToken;
-export declare function isRGXLiteralToken(value: unknown): value is RGXLiteralToken;
-export declare function assertRGXLiteralToken(value: unknown): asserts value is RGXLiteralToken;
-export declare function isRGXNativeToken(value: unknown): value is RGXNativeToken;
-export declare function assertRGXNativeToken(value: unknown): asserts value is RGXNativeToken;
-export declare function isRGXConvertibleToken(value: unknown): value is RGXConvertibleToken;
-export declare function assertRGXConvertibleToken(value: unknown): asserts value is RGXConvertibleToken;
-export declare function rgxTokenType(value: RGXToken): RGXTokenType;
-export declare function rgxTokenFromType<T extends RGXTokenType>(type: T, value: RGXToken): RGXTokenFromType<T>;
-export declare function isValidRegexString(value: string): value is ValidRegexString;
-export declare function assertValidRegexString(value: string): asserts value is ValidRegexString;
-export declare function isValidVanillaRegexFlags(value: string): value is ValidVanillaRegexFlags;
-export declare function assertValidVanillaRegexFlags(value: string): asserts value is ValidVanillaRegexFlags;
-export declare function escapeRegex(value: string): ValidRegexString;
-export declare function resolveRGXToken(token: RGXToken): ValidRegexString;
-export declare function rgxConcat(tokens: RGXToken[]): ValidRegexString;
-export default function rgx(flags?: string): (strings: TemplateStringsArray, ...tokens: RGXToken[]) => RegExp;
+export * from "./types";
+export * from "./type-guards";
+export declare function escapeRegex(value: string): t.ValidRegexString;
+export declare function resolveRGXToken(token: t.RGXToken): t.ValidRegexString;
+export declare function rgxConcat(tokens: t.RGXToken[]): t.ValidRegexString;
+export default function rgx(flags?: string): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => RegExp;

package/dist/index.js

@@ -10,137 +10,52 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validVanillaRegexFlagsSymbol = exports.validRegexSymbol = void 0;
-exports.isRGXNoOpToken = isRGXNoOpToken;
-exports.assertRGXNoOpToken = assertRGXNoOpToken;
-exports.isRGXLiteralToken = isRGXLiteralToken;
-exports.assertRGXLiteralToken = assertRGXLiteralToken;
-exports.isRGXNativeToken = isRGXNativeToken;
-exports.assertRGXNativeToken = assertRGXNativeToken;
-exports.isRGXConvertibleToken = isRGXConvertibleToken;
-exports.assertRGXConvertibleToken = assertRGXConvertibleToken;
-exports.rgxTokenType = rgxTokenType;
-exports.rgxTokenFromType = rgxTokenFromType;
-exports.isValidRegexString = isValidRegexString;
-exports.assertValidRegexString = assertValidRegexString;
-exports.isValidVanillaRegexFlags = isValidVanillaRegexFlags;
-exports.assertValidVanillaRegexFlags = assertValidVanillaRegexFlags;
 exports.escapeRegex = escapeRegex;
 exports.resolveRGXToken = resolveRGXToken;
 exports.rgxConcat = rgxConcat;
 exports.default = rgx;
-const is_callable_1 = __importDefault(require("is-callable"));
-const errors_1 = require("./errors");
+const e = __importStar(require("./errors"));
+const tg = __importStar(require("./type-guards"));
 __exportStar(require("./errors"), exports);
-exports.validRegexSymbol = Symbol('rgx.ValidRegex');
-exports.validVanillaRegexFlagsSymbol = Symbol('rgx.ValidVanillaRegexFlags');
-function isRGXNoOpToken(value) {
-    return value === null || value === undefined;
-}
-function assertRGXNoOpToken(value) {
-    if (!isRGXNoOpToken(value)) {
-        throw new errors_1.RGXInvalidTokenError(`Invalid no-op token`, 'null or undefined', value);
-    }
-}
-function isRGXLiteralToken(value) {
-    return value instanceof RegExp;
-}
-function assertRGXLiteralToken(value) {
-    if (!isRGXLiteralToken(value)) {
-        throw new errors_1.RGXInvalidTokenError(`Invalid literal token`, 'RegExp', value);
-    }
-}
-function isRGXNativeToken(value) {
-    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || isRGXNoOpToken(value);
-}
-function assertRGXNativeToken(value) {
-    if (!isRGXNativeToken(value)) {
-        throw new errors_1.RGXInvalidTokenError(`Invalid native token`, 'string, number, boolean, null, or undefined', value);
-    }
-}
-function isRGXConvertibleToken(value) {
-    if (typeof value === 'object' && value !== null && 'toRgx' in value) {
-        if ((0, is_callable_1.default)(value.toRgx)) {
-            const returnValue = value.toRgx();
-            if (Array.isArray(returnValue)) {
-                return returnValue.every(value => isRGXNativeToken(value) || isRGXLiteralToken(value));
-            }
-            return isRGXNativeToken(returnValue) || isRGXLiteralToken(returnValue);
-        }
-        return false;
-    }
-    return false;
-}
-function assertRGXConvertibleToken(value) {
-    if (!isRGXConvertibleToken(value)) {
-        throw new errors_1.RGXInvalidTokenError(`Invalid convertible token`, 'object with a toRgx method that returns a valid token', value);
-    }
-}
-function rgxTokenType(value) {
-    if (isRGXNoOpToken(value))
-        return 'no-op';
-    if (isRGXLiteralToken(value))
-        return 'literal';
-    if (isRGXNativeToken(value))
-        return 'native';
-    if (isRGXConvertibleToken(value))
-        return 'convertible';
-    if (Array.isArray(value))
-        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 errors_1.RGXInvalidTokenError(`Invalid RGX token: ${value}`, 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.
-    /* istanbul ignore next */
-    return value;
-}
-function isValidRegexString(value) {
-    try {
-        new RegExp(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function assertValidRegexString(value) {
-    if (!isValidRegexString(value)) {
-        throw new errors_1.RGXInvalidRegexStringError(`Invalid regex string: ${value}`, value);
-    }
-}
-function isValidVanillaRegexFlags(value) {
-    const patternMatch = /^[gimsuy]*$/.test(value);
-    if (!patternMatch)
-        return false;
-    // No repeated flags allowed
-    const flagsSet = new Set(value);
-    return flagsSet.size === value.length;
-}
-function assertValidVanillaRegexFlags(value) {
-    if (!isValidVanillaRegexFlags(value)) {
-        throw new errors_1.RGXInvalidVanillaRegexFlagsError(`Invalid vanilla regex flags: ${value}`, value);
-    }
-}
+__exportStar(require("./types"), exports);
+__exportStar(require("./type-guards"), exports);
 function escapeRegex(value) {
     return value.replaceAll(/[\-\^\$.*+?^${}()|[\]\\]/g, '\\$&');
 }
 function resolveRGXToken(token) {
-    if (isRGXNoOpToken(token))
+    if (tg.isRGXNoOpToken(token))
         return '';
-    if (isRGXLiteralToken(token))
+    if (tg.isRGXLiteralToken(token))
         return '(?:' + token.source + ')';
-    if (isRGXNativeToken(token))
+    if (tg.isRGXNativeToken(token))
         return escapeRegex(String(token));
-    if (isRGXConvertibleToken(token)) {
+    if (tg.isRGXConvertibleToken(token)) {
         return resolveRGXToken(token.toRgx());
     }
     // Interpret arrays as unions
@@ -154,14 +69,14 @@ function resolveRGXToken(token) {
     }
     // 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 errors_1.RGXInvalidTokenError(`Invalid RGX token: ${token}`, null, token);
+    throw new e.RGXInvalidTokenError(`Invalid RGX token: ${token}`, null, token);
 }
 // Wrapper for letting an array of tokens be resolved as a concatenation instead of a union.
 function rgxConcat(tokens) {
     return tokens.map(resolveRGXToken).join('');
 }
 function rgx(flags = '') {
-    assertValidVanillaRegexFlags(flags);
+    tg.assertValidVanillaRegexFlags(flags);
     return (strings, ...tokens) => {
         let pattern = '';
         const resolvedTokens = tokens.map(resolveRGXToken);

package/dist/type-guards.d.ts

@@ -0,0 +1,15 @@
+import * as t from "./types";
+export declare function isRGXNoOpToken(value: unknown): value is t.RGXNoOpToken;
+export declare function assertRGXNoOpToken(value: unknown): asserts value is t.RGXNoOpToken;
+export declare function isRGXLiteralToken(value: unknown): value is t.RGXLiteralToken;
+export declare function assertRGXLiteralToken(value: unknown): asserts value is t.RGXLiteralToken;
+export declare function isRGXNativeToken(value: unknown): value is t.RGXNativeToken;
+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 rgxTokenType(value: t.RGXToken): t.RGXTokenType;
+export declare function rgxTokenFromType<T extends t.RGXTokenType>(type: T, value: t.RGXToken): t.RGXTokenFromType<T>;
+export declare function isValidRegexString(value: string): value is t.ValidRegexString;
+export declare function assertValidRegexString(value: string): asserts value is t.ValidRegexString;
+export declare function isValidVanillaRegexFlags(value: string): value is t.ValidVanillaRegexFlags;
+export declare function assertValidVanillaRegexFlags(value: string): asserts value is t.ValidVanillaRegexFlags;

package/dist/type-guards.js

@@ -0,0 +1,143 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRGXNoOpToken = isRGXNoOpToken;
+exports.assertRGXNoOpToken = assertRGXNoOpToken;
+exports.isRGXLiteralToken = isRGXLiteralToken;
+exports.assertRGXLiteralToken = assertRGXLiteralToken;
+exports.isRGXNativeToken = isRGXNativeToken;
+exports.assertRGXNativeToken = assertRGXNativeToken;
+exports.isRGXConvertibleToken = isRGXConvertibleToken;
+exports.assertRGXConvertibleToken = assertRGXConvertibleToken;
+exports.rgxTokenType = rgxTokenType;
+exports.rgxTokenFromType = rgxTokenFromType;
+exports.isValidRegexString = isValidRegexString;
+exports.assertValidRegexString = assertValidRegexString;
+exports.isValidVanillaRegexFlags = isValidVanillaRegexFlags;
+exports.assertValidVanillaRegexFlags = assertValidVanillaRegexFlags;
+const e = __importStar(require("./errors"));
+const is_callable_1 = __importDefault(require("is-callable"));
+function isRGXNoOpToken(value) {
+    return value === null || value === undefined;
+}
+function assertRGXNoOpToken(value) {
+    if (!isRGXNoOpToken(value)) {
+        throw new e.RGXInvalidTokenError(`Invalid no-op token`, 'null or undefined', value);
+    }
+}
+function isRGXLiteralToken(value) {
+    return value instanceof RegExp;
+}
+function assertRGXLiteralToken(value) {
+    if (!isRGXLiteralToken(value)) {
+        throw new e.RGXInvalidTokenError(`Invalid literal token`, 'RegExp', value);
+    }
+}
+function isRGXNativeToken(value) {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || isRGXNoOpToken(value);
+}
+function assertRGXNativeToken(value) {
+    if (!isRGXNativeToken(value)) {
+        throw new e.RGXInvalidTokenError(`Invalid native token`, 'string, number, boolean, null, or undefined', value);
+    }
+}
+function isRGXConvertibleToken(value) {
+    if (typeof value === 'object' && value !== null && 'toRgx' in value) {
+        if ((0, is_callable_1.default)(value.toRgx)) {
+            const returnValue = value.toRgx();
+            if (Array.isArray(returnValue)) {
+                return returnValue.every(value => isRGXNativeToken(value) || isRGXLiteralToken(value));
+            }
+            return isRGXNativeToken(returnValue) || isRGXLiteralToken(returnValue);
+        }
+        return false;
+    }
+    return false;
+}
+function assertRGXConvertibleToken(value) {
+    if (!isRGXConvertibleToken(value)) {
+        throw new e.RGXInvalidTokenError(`Invalid convertible token`, 'object with a toRgx method that returns a valid token', value);
+    }
+}
+function rgxTokenType(value) {
+    if (isRGXNoOpToken(value))
+        return 'no-op';
+    if (isRGXLiteralToken(value))
+        return 'literal';
+    if (isRGXNativeToken(value))
+        return 'native';
+    if (isRGXConvertibleToken(value))
+        return 'convertible';
+    if (Array.isArray(value))
+        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: ${value}`, 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.
+    /* istanbul ignore next */
+    return value;
+}
+function isValidRegexString(value) {
+    try {
+        new RegExp(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assertValidRegexString(value) {
+    if (!isValidRegexString(value)) {
+        throw new e.RGXInvalidRegexStringError(`Invalid regex string: ${value}`, value);
+    }
+}
+function isValidVanillaRegexFlags(value) {
+    const patternMatch = /^[gimsuy]*$/.test(value);
+    if (!patternMatch)
+        return false;
+    // No repeated flags allowed
+    const flagsSet = new Set(value);
+    return flagsSet.size === value.length;
+}
+function assertValidVanillaRegexFlags(value) {
+    if (!isValidVanillaRegexFlags(value)) {
+        throw new e.RGXInvalidVanillaRegexFlagsError(`Invalid vanilla regex flags: ${value}`, value);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+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: () => MaybeArray<RGXNativeToken | RGXLiteralToken>;
+};
+export type RGXToken = RGXNativeToken | RGXLiteralToken | RGXConvertibleToken | RGXToken[];
+export type RGXTokenType = 'no-op' | 'literal' | 'native' | 'convertible' | RGXTokenType[];
+export type RGXTokenFromType<T extends RGXTokenType> = T extends 'no-op' ? RGXNoOpToken : T extends 'literal' ? RGXLiteralToken : T extends 'native' ? RGXNativeToken : T extends 'convertible' ? RGXConvertibleToken : T extends RGXTokenType[] ? {
+    [K in keyof T]: T[K] extends RGXTokenType ? RGXTokenFromType<T[K]> : never;
+} : never;
+export declare const validRegexSymbol: unique symbol;
+export type ValidRegexBrandSymbol = typeof validRegexSymbol;
+export type ValidRegexString = Branded<string, [ValidRegexBrandSymbol]>;
+export declare const validVanillaRegexFlagsSymbol: unique symbol;
+export type ValidVanillaRegexFlagsBrandSymbol = typeof validVanillaRegexFlagsSymbol;
+export type ValidVanillaRegexFlags = Branded<string, [ValidVanillaRegexFlagsBrandSymbol]>;

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validVanillaRegexFlagsSymbol = exports.validRegexSymbol = void 0;
+exports.validRegexSymbol = Symbol('rgx.ValidRegex');
+exports.validVanillaRegexFlagsSymbol = Symbol('rgx.ValidVanillaRegexFlags');

package/package.json

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