@nejs/basic-extensions 2.21.5 → 2.22.6

package/dist/cjs/regular.expression.extensions.js

@@ -1,423 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RegExpExtensions = void 0;
-const extension_1 = require("@nejs/extension");
-exports.RegExpExtensions = new extension_1.Patch(RegExp, {
-    [extension_1.Patch.kMutablyHidden]: {
-        /**
-         * Generates a regular expression pattern that matches any character.
-         *
-         * This method creates a regular expression pattern that matches any
-         * character. The pattern can be configured to be greedy or non-greedy,
-         * and to include or exclude newline characters.
-         *
-         * @param {boolean} [greedy=false] - If true, the pattern will be greedy,
-         * meaning it will match as many characters as possible. If false, the
-         * pattern will be non-greedy, meaning it will match as few characters
-         * as possible.
-         * @param {boolean} [includeNewlines=false] - If true, the pattern will
-         * include newline characters ('\n' and '\r'). If false, newline
-         * characters will be excluded from the pattern.
-         * @returns {string} - The generated regular expression pattern.
-         *
-         * @example
-         * // Generate a non-greedy pattern that excludes newlines
-         * console.log(anything())  // Output: '[.]*?'
-         *
-         * @example
-         * // Generate a greedy pattern that includes newlines
-         * console.log(anything(true, true))  // Output: '[.\\n\\r]*'
-         */
-        anything(greedy = false, includeNewlines = false) {
-            return `[.${includeNewlines ? '\\n\\r' : ''}]*${greedy ? '' : '?'}`;
-        },
-        /**
-         * Creates a non-capturing group in a regular expression.
-         *
-         * This method wraps the provided string in a non-capturing group,
-         * which is denoted by the syntax `(?:...)` in a regular expression.
-         * Non-capturing groups match the pattern inside the group but do not
-         * capture the matched content for later use.
-         *
-         * @param {string} string - The string to be wrapped in a non-capturing group.
-         * @returns {string} - The string wrapped in a non-capturing group.
-         *
-         * @example
-         * // Suppose we have a string 'abc'
-         * const str = 'abc'
-         *
-         * // Using `nonCaptureGroup`
-         * console.log(nonCaptureGroup(str))  // Output: '(?:abc)'
-         */
-        nonCaptureGroup(string) {
-            return `(?:${string})`;
-        },
-        /**
-         * Creates a capturing group in a regular expression.
-         *
-         * This method wraps the provided string in a capturing group,
-         * which is denoted by the syntax `(...)` in a regular expression.
-         * Capturing groups match the pattern inside the group and capture
-         * the matched content for later use.
-         *
-         * @param {string} string - The string to be wrapped in a capturing group.
-         * @returns {string} - The string wrapped in a capturing group.
-         *
-         * @example
-         * // Suppose we have a string 'abc'
-         * const str = 'abc'
-         *
-         * // Using `captureGroup`
-         * console.log(captureGroup(str))  // Output: '(abc)'
-         */
-        captureGroup(string) {
-            return `(${string})`;
-        },
-        /**
-         * Creates a regular expression pattern that matches any one of the
-         * provided strings.
-         *
-         * This method takes any number of strings as arguments, and returns a
-         * string that represents a regular expression pattern. The pattern
-         * matches any one of the provided strings. The strings are joined
-         * together with the '|' character, which represents the OR operator
-         * in regular expressions.
-         *
-         * @param {...string} strings - The strings to be included in the pattern.
-         * @returns {string} - A string representing a regular expression pattern
-         * that matches any one of the provided strings.
-         *
-         * @example
-         * // Suppose we have strings 'abc', 'def', and 'ghi'
-         * const str1 = 'abc'
-         * const str2 = 'def'
-         * const str3 = 'ghi'
-         *
-         * // Using `oneOf`
-         * console.log(oneOf(str1, str2, str3))  // Output: 'abc|def|ghi'
-         */
-        oneOf(...strings) {
-            return strings.join('|');
-        },
-        /**
-         * Creates a regular expression pattern that matches zero or more
-         * occurrences of the provided string.
-         *
-         * This method wraps the provided string in a non-capturing group,
-         * which is denoted by the syntax `(?:...)` in a regular expression,
-         * and appends the `*` character, which represents zero or more
-         * occurrences in regular expressions.
-         *
-         * @param {string} string - The string to be matched zero or more times.
-         * @returns {string} - A string representing a regular expression pattern
-         * that matches zero or more occurrences of the provided string.
-         *
-         * @example
-         * // Suppose we have a string 'abc'
-         * const str = 'abc'
-         *
-         * // Using `zeroOrMore`
-         * console.log(zeroOrMore(str))  // Output: '(?:abc)*'
-         */
-        zeroOrMore(string) {
-            return `(?:${string})*`;
-        },
-        /**
-         * Creates a regular expression pattern that matches zero or one
-         * occurrence of the provided string.
-         *
-         * This method wraps the provided string in a non-capturing group,
-         * which is denoted by the syntax `(?:...)` in a regular expression,
-         * and appends the `?` character, which represents zero or one
-         * occurrence in regular expressions.
-         *
-         * @param {string} string - The string to be matched zero or one time.
-         * @returns {string} - A string representing a regular expression pattern
-         * that matches zero or one occurrence of the provided string.
-         *
-         * @example
-         * // Suppose we have a string 'abc'
-         * const str = 'abc'
-         *
-         * // Using `zeroOrOne`
-         * console.log(zeroOrOne(str))  // Output: '(?:abc)?'
-         */
-        zeroOrOne(string) {
-            return `(?:${string})?`;
-        },
-        /**
-         * Escapes special characters in a string for use in a regular expression.
-         *
-         * This method checks if the `RegExp.escape` method is available. If it is,
-         * it uses that method to escape the string. If it's not, it uses a polyfill
-         * method to escape the string.
-         *
-         * The polyfill method replaces all special characters in the string with
-         * their escaped equivalents. The special characters are defined by the
-         * regular expression `/[-[\]{}()*+?.,\\^$|#\s]/g`.
-         *
-         * @param {string} string - The string to be escaped.
-         * @returns {string} - The escaped string.
-         *
-         * @example
-         * // Suppose we have a string with special characters
-         * const str = 'Hello, [World]!'
-         *
-         * // Using `escape` or `escapePolyfill`
-         * console.log(RegExp[RegExp.escape ? 'escapePolyfill' : 'escape'](str))
-         * // Output: 'Hello\\, \\[World\\]\\!'
-         */
-        escape(string) {
-            return RegExpEscape(string);
-        },
-        /**
-         * Getter method that returns a string 'null'.
-         *
-         * This method is used when you need a string representation of null
-         * in your regular expressions. It simply returns the string 'null'.
-         *
-         * @returns {string} - A string 'null'.
-         *
-         * @example
-         * // Using `null`
-         * console.log(this.null)  // Output: 'null'
-         */
-        get null() {
-            return 'null';
-        },
-        /**
-         * Getter method that returns a regular expression string for boolean
-         * values.
-         *
-         * This method uses the `oneOf` method to create a regular expression
-         * string that matches either 'true' or 'false'. This is useful when you
-         * need to match boolean values in a string using a regular expression.
-         *
-         * @returns {string} - A regular expression string that matches 'true'
-         * or 'false'.
-         *
-         * @example
-         * // Using `bool`
-         * const boolRegex = new RegExp(this.bool)
-         * console.log(boolRegex.test('true'))  // Output: true
-         * console.log(boolRegex.test('false')) // Output: true
-         * console.log(boolRegex.test('maybe')) // Output: false
-         */
-        get bool() {
-            return this.oneOf('true', 'false');
-        },
-        /**
-         * Generates a regular expression string that matches the symbols of
-         * specified currencies.
-         *
-         * This method uses the Intl API to get the symbols of the specified
-         * currencies and constructs a regular expression string that matches
-         * these symbols. If no specific currencies are provided, it defaults
-         * to all known currencies. If a single currency is provided as a
-         * string, it is converted to an array. If the symbols array is empty
-         * after filtering out unknown currencies, it defaults back to all
-         * known currencies.
-         *
-         * @param {Array|string} [symbols=[['*'], ['USD','GBP']][0]] - The
-         * currencies to include in the regular expression. Can be an array
-         * of currency codes or a single currency code as a string. Defaults
-         * to all known currencies.
-         * @param {string} [locale='en-US'] - The locale to use when getting
-         * the currency symbols. Defaults to 'en-US'.
-         * @returns {string} - A regular expression string that matches the
-         * symbols of the specified currencies.
-         *
-         * @example
-         * // Using `currencySymbols` with default parameters
-         * console.log(this.currencySymbols())
-         * // Output: A regular expression string that matches all known
-         * // currency symbols
-         *
-         * @example
-         * // Using `currencySymbols` with specific currencies
-         * console.log(this.currencySymbols(['USD', 'EUR']))
-         * // Output: A regular expression string that matches the symbols
-         * // of USD and EUR
-         */
-        currencySymbols(symbols = [['*'], ['USD', 'GBP']][0], locale = 'en-US') {
-            const known = Intl.supportedValuesOf('currency');
-            const has = code => !!~known.indexOf(code);
-            if (typeof symbols === 'string' && has(symbols)) {
-                symbols = [symbols];
-            }
-            if (!Array.isArray(symbols)) {
-                symbols = known;
-            }
-            symbols = symbols.filter(symbol => has(symbol));
-            if (!symbols.length) {
-                symbols = known;
-            }
-            const opts = (currency) => ({ style: 'currency', currency });
-            const fmt = (place, currency) => Intl.NumberFormat(place, opts(currency));
-            const codes = (((symbols.length === 1 && symbols[0] === '*') ? known : symbols)
-                .filter(code => has(code))
-                .map(currency => {
-                const symbol = fmt(locale, currency).formatToParts()?.[0].value;
-                return symbol && `(?:${RegExp.escape(symbol)})`;
-            })
-                .join('|'));
-            return codes;
-        },
-        /**
-         * Getter method that returns a regular expression string for numbers.
-         *
-         * This method returns a regular expression string that matches both
-         * integer and floating point numbers. The returned regular expression
-         * string is '\\d+\\.?\\d*', which matches one or more digits followed
-         * by an optional decimal point and zero or more digits.
-         *
-         * @returns {string} - A regular expression string that matches numbers.
-         *
-         * @example
-         * // Using `number`
-         * const numberRegex = new RegExp(this.number)
-         * console.log(numberRegex.test('123'))    // Output: true
-         * console.log(numberRegex.test('123.45')) // Output: true
-         * console.log(numberRegex.test('abc'))    // Output: false
-         */
-        get number() {
-            const instance = Object(`\\d+\\.?\\d*`);
-            const self = this;
-            Object.defineProperties(instance, {
-                // alias for .float
-                any: { get() { return String(instance); } },
-                /**
-                 * Getter method that returns a regular expression string for floating
-                 * point numbers.
-                 *
-                 * This method returns a regular expression string that matches floating
-                 * point numbers. It leverages the 'number' getter method which matches
-                 * both integer and floating point numbers. The returned regular expression
-                 * string is '\\d+\\.?\\d*', which matches one or more digits followed by
-                 * an optional decimal point and zero or more digits.
-                 *
-                 * @returns {string} - A regular expression string that matches floating
-                 * point numbers.
-                 *
-                 * @example
-                 * // Using `float`
-                 * const floatRegex = new RegExp(this.float)
-                 * console.log(floatRegex.test('123.45')) // Output: true
-                 * console.log(floatRegex.test('123'))    // Output: false
-                 * console.log(floatRegex.test('abc'))    // Output: false
-                 */
-                float: { get() { return String(instance); } },
-                // any known locale currency symbol + .float
-                money: { get() { return `(?:${self.currencySymbols()})?${this.float}`; } },
-                /**
-                 * Getter method that returns a regular expression string for integers.
-                 *
-                 * This method returns a regular expression string that matches integer
-                 * numbers. The returned regular expression string is '\\d+', which matches
-                 * one or more digits.
-                 *
-                 * @returns {string} - A regular expression string that matches integers.
-                 *
-                 * @example
-                 * // Using `integer`
-                 * const integerRegex = new RegExp(this.integer)
-                 * console.log(integerRegex.test('123'))    // Output: true
-                 * console.log(integerRegex.test('123.45')) // Output: false
-                 * console.log(integerRegex.test('abc'))    // Output: false
-                 */
-                integer: { get() { return `\\d+`; } },
-                /**
-                 * Getter method that returns a regular expression string for pretty
-                 * numbers.
-                 *
-                 * This method returns a regular expression string that matches numbers
-                 * with commas or spaces for thousands separators. The returned regular
-                 * expression string is '[\\d\\$]+\\.?[\\d,\\$]*', which matches one or
-                 * more digits or dollar signs, followed by an optional decimal point,
-                 * and zero or more digits, commas, or dollar signs.
-                 *
-                 * @returns {string} - A regular expression string that matches pretty
-                 * numbers.
-                 *
-                 * @example
-                 * // Using `pretty`
-                 * const prettyRegex = new RegExp(this.pretty)
-                 * console.log(prettyRegex.test('1,234.56')) // Output: true
-                 * console.log(prettyRegex.test('1234.56'))  // Output: true
-                 * console.log(prettyRegex.test('1 234.56')) // Output: true
-                 * console.log(prettyRegex.test('abc'))      // Output: false
-                 */
-                pretty: {
-                    value(locale = 'en-US') {
-                        const symbols = self.zeroOrMore(self.currencySymbols(['*'], locale));
-                        return `${symbols}[\\d,]+\\.?[\\d]*`;
-                    }
-                },
-                /**
-                 * Getter method that returns a regular expression string for JavaScript
-                 * literals.
-                 *
-                 * This method returns a regular expression string that matches JavaScript
-                 * literals. The returned regular expression string is '[\\d_]+', which
-                 * matches one or more digits or underscores.
-                 *
-                 * @returns {string} - A regular expression string that matches JavaScript
-                 * literals.
-                 *
-                 * @example
-                 * // Using `jsLiteral`
-                 * const jsLiteralRegex = new RegExp(this.jsLiteral)
-                 * console.log(jsLiteralRegex.test('123_456')) // Output: true
-                 * console.log(jsLiteralRegex.test('abc'))     // Output: false
-                 */
-                jsLiteral: { get() { return `[\\d_]+`; } }
-            });
-            return instance;
-        },
-        /**
-         * Getter method that returns a regular expression string for integers.
-         *
-         * This method returns a regular expression string that matches integer
-         * numbers. The returned regular expression string is '\\d+', which matches
-         * one or more digits.
-         *
-         * @returns {string} - A regular expression string that matches integers.
-         *
-         * @example
-         * // Using `integer`
-         * const integerRegex = new RegExp(this.integer)
-         * console.log(integerRegex.test('123'))    // Output: true
-         * console.log(integerRegex.test('123.45')) // Output: false
-         * console.log(integerRegex.test('abc'))    // Output: false
-         */
-        get integer() {
-            return `\\d+`;
-        },
-        get string() {
-            return {
-                get doubleQuoted() {
-                    return '"[^"\\\\]*(?:\\\\.[^"\\\\]*)*"';
-                },
-                get singleQuoted() {
-                    return "'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'";
-                }
-            };
-        },
-        get whitespace() {
-            return `\\s*`;
-        },
-        get comma() {
-            return `,${this.whitespace}`;
-        },
-    }
-}, {
-    conditions: {
-        ['escape']() { return !Reflect.has(RegExp, 'escape'); },
-    }
-});
-// Simple variant that does not require external dependencies; may not cover
-// all known use cases.
-function RegExpEscape(string) {
-    return string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
-}
-//# sourceMappingURL=regular.expression.extensions.js.map

package/dist/cjs/regular.expression.extensions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"regular.expression.extensions.js","sourceRoot":"","sources":["../../src/regular.expression.extensions.js"],"names":[],"mappings":"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"}

package/dist/cjs/set.extensions.d.ts

@@ -1,40 +0,0 @@
-/**
- * `SetExtensions` is a constant that applies a patch to the global
- * `Set` constructor. This patch extends the `Set` with additional
- * methods and properties, enhancing its functionality.
- *
- * The `Patch` function takes two arguments: the target object to be patched
- * (in this case, `Set`), and an object containing the methods and
- * properties to be added to the target object.
- *
- * @example
- * // Using a method added by SetExtensions
- * const set = new Set();
- * console.log(Set.isSet(set)); // Output: true
- *
- * @const
- * @type {Patch}
- * @memberof module:set.extensions
- */
-export const SetExtensions: Patch;
-/**
- * `SetPrototypeExtensions` is a constant that applies a patch to the
- * prototype of the built-in JavaScript `Set` object. This patch extends the
- * `Set` prototype with additional methods and properties, enhancing its
- * functionality.
- *
- * The `Patch` function takes two arguments: the target object to be patched
- * (in this case, `Set.prototype`), and an object containing the methods and
- * properties to be added to the target object.
- *
- * @example
- * // Using a method added by SetPrototypeExtensions
- * const mySet = new Set();
- * mySet.myNewMethod(); // Calls the new method added by the patch
- *
- * @const
- * @type {Patch}
- * @memberof module:set.extensions
- */
-export const SetPrototypeExtensions: Patch;
-import { Patch } from '@nejs/extension';