refactor: rename inverted

Author: mdjastrzebski

README.md

@@ -136,7 +136,7 @@ See [Quantifiers API doc](https://callstack.github.io/ts-regex-builder/api/quant
 | `anyOf('abc')`        | `[abc]`      | Any of provided characters                        |
 | `charRange('a', 'z')` | `[a-z]`      | Character in a range                              |
 | `charClass(...)`      | `[...]`      | Union of multiple character classes               |
-| `inverted(...)`       | `[^...]`     | Negation of a given character class               |
+| `negated(...)`        | `[^...]`     | Negation of a given character class               |
 
 See [Character Classes API doc](https://callstack.github.io/ts-regex-builder/api/character-classes) for more info.
 

src/constructs/__tests__/character-class.test.ts

@@ -5,7 +5,7 @@ import {
   charClass,
   charRange,
   digit,
-  inverted,
+  negated,
   nonDigit,
   nonWhitespace,
   nonWord,
@@ -83,9 +83,9 @@ test('`charClass` base cases', () => {
   expect(charClass(charRange('a', 'z'), whitespace, anyOf('05'))).toEqualRegex(/[a-z\s05]/);
 });
 
-test('`charClass` throws on inverted arguments', () => {
-  expect(() => charClass(inverted(whitespace))).toThrowErrorMatchingInlineSnapshot(
-    `"\`charClass\` should receive only non-inverted character classes"`,
+test('`charClass` throws on negated arguments', () => {
+  expect(() => charClass(negated(whitespace))).toThrowErrorMatchingInlineSnapshot(
+    `"\`charClass\` should receive only non-negated character classes"`,
   );
 });
 
@@ -141,30 +141,30 @@ test('`anyOf` throws on empty text', () => {
   );
 });
 
-test('`inverted` character class pattern', () => {
-  expect(inverted(anyOf('a'))).toEqualRegex(/[^a]/);
-  expect(inverted(anyOf('abc'))).toEqualRegex(/[^abc]/);
+test('`negated` character class pattern', () => {
+  expect(negated(anyOf('a'))).toEqualRegex(/[^a]/);
+  expect(negated(anyOf('abc'))).toEqualRegex(/[^abc]/);
 });
 
-test('`inverted` character class pattern double inversion', () => {
-  expect(inverted(inverted(anyOf('a')))).toEqualRegex(/a/);
-  expect(inverted(inverted(anyOf('abc')))).toEqualRegex(/[abc]/);
+test('`negated` character class pattern double inversion', () => {
+  expect(negated(negated(anyOf('a')))).toEqualRegex(/a/);
+  expect(negated(negated(anyOf('abc')))).toEqualRegex(/[abc]/);
 });
 
-test('`inverted` character class matching', () => {
-  expect(inverted(anyOf('a'))).not.toMatchString('aa');
-  expect(inverted(anyOf('a'))).toMatchGroups('aba', ['b']);
+test('`negated` character class matching', () => {
+  expect(negated(anyOf('a'))).not.toMatchString('aa');
+  expect(negated(anyOf('a'))).toMatchGroups('aba', ['b']);
 });
 
 test('`encodeCharacterClass` throws on empty text', () => {
   expect(() =>
     buildRegExp(
       // @ts-expect-error
-      inverted({
+      negated({
         type: 'characterClass',
         chars: [],
         ranges: [],
-        isInverted: false,
+        isNegated: false,
       }),
     ),
   ).toThrowErrorMatchingInlineSnapshot(

src/constructs/character-class.ts

@@ -5,7 +5,7 @@ export interface CharacterClass extends RegexConstruct {
   type: 'characterClass';
   chars: string[];
   ranges: CharacterRange[];
-  isInverted: boolean;
+  isNegated: boolean;
   encode: () => EncodeResult;
 }
 
@@ -21,55 +21,55 @@ export const any: CharacterClass = {
   type: 'characterClass',
   chars: ['.'],
   ranges: [],
-  isInverted: false,
+  isNegated: false,
   encode: encodeCharacterClass,
 };
 
 export const digit: CharacterClass = {
   type: 'characterClass',
   chars: ['\\d'],
   ranges: [],
-  isInverted: false,
+  isNegated: false,
   encode: encodeCharacterClass,
 };
 
 export const nonDigit: CharacterClass = {
   type: 'characterClass',
   chars: ['\\D'],
   ranges: [],
-  isInverted: false,
+  isNegated: false,
   encode: encodeCharacterClass,
 };
 
 export const word: CharacterClass = {
   type: 'characterClass',
   chars: ['\\w'],
   ranges: [],
-  isInverted: false,
+  isNegated: false,
   encode: encodeCharacterClass,
 };
 
 export const nonWord: CharacterClass = {
   type: 'characterClass',
   chars: ['\\W'],
   ranges: [],
-  isInverted: false,
+  isNegated: false,
   encode: encodeCharacterClass,
 };
 
 export const whitespace: CharacterClass = {
   type: 'characterClass',
   chars: ['\\s'],
   ranges: [],
-  isInverted: false,
+  isNegated: false,
   encode: encodeCharacterClass,
 };
 
 export const nonWhitespace: CharacterClass = {
   type: 'characterClass',
   chars: ['\\S'],
   ranges: [],
-  isInverted: false,
+  isNegated: false,
   encode: encodeCharacterClass,
 };
 
@@ -90,16 +90,16 @@ export const notWhitespace = nonWhitespace;
 
 export function charClass(...elements: CharacterClass[]): CharacterClass {
   elements.forEach((element) => {
-    if (element.isInverted) {
-      throw new Error('`charClass` should receive only non-inverted character classes');
+    if (element.isNegated) {
+      throw new Error('`charClass` should receive only non-negated character classes');
     }
   });
 
   return {
     type: 'characterClass',
     chars: elements.map((c) => c.chars).flat(),
     ranges: elements.map((c) => c.ranges).flat(),
-    isInverted: false,
+    isNegated: false,
     encode: encodeCharacterClass,
   };
 }
@@ -121,7 +121,7 @@ export function charRange(start: string, end: string): CharacterClass {
     type: 'characterClass',
     chars: [],
     ranges: [{ start, end }],
-    isInverted: false,
+    isNegated: false,
     encode: encodeCharacterClass,
   };
 }
@@ -137,17 +137,17 @@ export function anyOf(characters: string): CharacterClass {
     type: 'characterClass',
     chars,
     ranges: [],
-    isInverted: false,
+    isNegated: false,
     encode: encodeCharacterClass,
   };
 }
 
-export function inverted(element: CharacterClass): CharacterClass {
+export function negated(element: CharacterClass): CharacterClass {
   return {
     type: 'characterClass',
     chars: element.chars,
     ranges: element.ranges,
-    isInverted: !element.isInverted,
+    isNegated: !element.isNegated,
     encode: encodeCharacterClass,
   };
 }
@@ -158,7 +158,7 @@ function encodeCharacterClass(this: CharacterClass): EncodeResult {
   }
 
   // Direct rendering for single-character class
-  if (this.chars.length === 1 && this.ranges?.length === 0 && !this.isInverted) {
+  if (this.chars.length === 1 && this.ranges?.length === 0 && !this.isNegated) {
     return {
       precedence: 'atom',
       pattern: this.chars[0]!,
@@ -172,9 +172,9 @@ function encodeCharacterClass(this: CharacterClass): EncodeResult {
   const caret = this.chars.includes('^') ? '^' : '';
   const otherChars = this.chars.filter((c) => c !== '-' && c !== '^').join('');
   const ranges = this.ranges.map(({ start, end }) => `${start}-${end}`).join('');
-  const isInverted = this.isInverted ? '^' : '';
+  const negation = this.isNegated ? '^' : '';
 
-  let pattern = `[${isInverted}${ranges}${otherChars}${caret}${hyphen}]`;
+  let pattern = `[${negation}${ranges}${otherChars}${caret}${hyphen}]`;
   if (pattern === '[^-]') pattern = '[\\^-]';
 
   return {

src/index.ts

@@ -16,7 +16,7 @@ export {
   charClass,
   charRange,
   digit,
-  inverted,
+  negated,
   nonDigit,
   nonWhitespace,
   nonWord,

website/docs/api/character-classes.md

@@ -68,17 +68,17 @@ Examples:
 - `charClass(charRange('a', 'f'), digit)` will match all lowercase hex digits (`0` to `9` and `a` to `f`).
 - `charClass(charRange('a', 'z'), digit, anyOf("._-"))` will match any digit, lowercase Latin letter from `a` to `z`, and either of `.`, `_`, and `-` characters.
 
-### `inverted()`
+### `negated()`
 
 ```ts
-function inverted(element: CharacterClass): CharacterClass;
+function negated(element: CharacterClass): CharacterClass;
 ```
 
 Regex syntax: `[^...]`.
 
-The `inverted` construct creates a new character class that matches any character not present in the passed character class.
+The `negated` construct creates a new character class that matches any character not present in the passed character class.
 
 Examples:
 
-- `inverted(digit)` matches any character that is not a digit
-- `inverted(anyOf('aeiou'))` matches any character that is not a lowercase vowel.
+- `negated(digit)` matches any character that is not a digit
+- `negated(anyOf('aeiou'))` matches any character that is not a lowercase vowel.

website/docs/api/overview.md

@@ -84,7 +84,7 @@ See [Quantifiers](./api/quantifiers) for more info.
 | `anyOf('abc')`        | `[abc]`      | Any of provided characters                        |
 | `charRange('a', 'z')` | `[a-z]`      | Character in a range                              |
 | `charClass(...)`      | `[...]`      | Union of multiple character classes               |
-| `inverted(...)`       | `[^...]`     | Negation of a given character class               |
+| `negated(...)`        | `[^...]`     | Negation of a given character class               |
 
 See [Character Classes](./api/character-classes) for more info.