refactor: rename notWord, etc

Author: mdjastrzebski

src/constructs/__tests__/anchors.test.tsx

@@ -2,7 +2,7 @@ import {
   buildRegExp,
   digit,
   endOfString,
-  notWhitespace,
+  nonWhitespace,
   notWordBoundary,
   oneOrMore,
   startOfString,
@@ -35,11 +35,11 @@ test('`wordBoundary` pattern', () => {
 
 test('`wordBoundary` matching', () => {
   expect(
-    buildRegExp([wordBoundary, 'a', zeroOrMore(notWhitespace)], { global: true }),
+    buildRegExp([wordBoundary, 'a', zeroOrMore(nonWhitespace)], { global: true }),
   ).toMatchGroups('a ba ab aa', ['a', 'ab', 'aa']);
 
   expect(
-    buildRegExp([zeroOrMore(notWhitespace), 'a', wordBoundary], { global: true }),
+    buildRegExp([zeroOrMore(nonWhitespace), 'a', wordBoundary], { global: true }),
   ).toMatchGroups('a ba ab aa', ['a', 'ba', 'aa']);
 });
 

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

@@ -6,9 +6,9 @@ import {
   charRange,
   digit,
   inverted,
-  notDigit,
-  notWhitespace,
-  notWord,
+  nonDigit,
+  nonWhitespace,
+  nonWord,
   oneOrMore,
   optional,
   whitespace,
@@ -30,12 +30,12 @@ test('`digit` character class', () => {
   expect(digit).not.toMatchString('A');
 });
 
-test('`notDigit` character class', () => {
-  expect(notDigit).toEqualRegex(/\D/);
-  expect(['x', notDigit]).toEqualRegex(/x\D/);
-  expect(['x', notDigit, 'x']).toEqualRegex(/x\Dx/);
-  expect(notDigit).not.toMatchString('1');
-  expect(notDigit).toMatchString('A');
+test('`nonDigit` character class', () => {
+  expect(nonDigit).toEqualRegex(/\D/);
+  expect(['x', nonDigit]).toEqualRegex(/x\D/);
+  expect(['x', nonDigit, 'x']).toEqualRegex(/x\Dx/);
+  expect(nonDigit).not.toMatchString('1');
+  expect(nonDigit).toMatchString('A');
 });
 
 test('`word` character class', () => {
@@ -47,13 +47,13 @@ test('`word` character class', () => {
   expect(word).not.toMatchString('$');
 });
 
-test('`notWord` character class', () => {
-  expect(notWord).toEqualRegex(/\W/);
-  expect(['x', notWord]).toEqualRegex(/x\W/);
-  expect(['x', notWord, 'x']).toEqualRegex(/x\Wx/);
-  expect(notWord).not.toMatchString('A');
-  expect(notWord).not.toMatchString('1');
-  expect(notWord).toMatchString('$');
+test('`nonWord` character class', () => {
+  expect(nonWord).toEqualRegex(/\W/);
+  expect(['x', nonWord]).toEqualRegex(/x\W/);
+  expect(['x', nonWord, 'x']).toEqualRegex(/x\Wx/);
+  expect(nonWord).not.toMatchString('A');
+  expect(nonWord).not.toMatchString('1');
+  expect(nonWord).toMatchString('$');
 });
 
 test('`whitespace` character class', () => {
@@ -66,14 +66,14 @@ test('`whitespace` character class', () => {
   expect(whitespace).not.toMatchString('1');
 });
 
-test('`notWhitespace` character class', () => {
-  expect(notWhitespace).toEqualRegex(/\S/);
-  expect(['x', notWhitespace]).toEqualRegex(/x\S/);
-  expect(['x', notWhitespace, 'x']).toEqualRegex(/x\Sx/);
-  expect(notWhitespace).not.toMatchString(' ');
-  expect(notWhitespace).not.toMatchString('\t');
-  expect(notWhitespace).toMatchString('A');
-  expect(notWhitespace).toMatchString('1');
+test('`nonWhitespace` character class', () => {
+  expect(nonWhitespace).toEqualRegex(/\S/);
+  expect(['x', nonWhitespace]).toEqualRegex(/x\S/);
+  expect(['x', nonWhitespace, 'x']).toEqualRegex(/x\Sx/);
+  expect(nonWhitespace).not.toMatchString(' ');
+  expect(nonWhitespace).not.toMatchString('\t');
+  expect(nonWhitespace).toMatchString('A');
+  expect(nonWhitespace).toMatchString('1');
 });
 
 test('`charClass` base cases', () => {
@@ -173,22 +173,22 @@ test('`encodeCharacterClass` throws on empty text', () => {
 });
 
 test('showcase: negated character classes', () => {
-  expect(notDigit).toEqualRegex(/\D/);
-  expect(notWord).toEqualRegex(/\W/);
-  expect(notWhitespace).toEqualRegex(/\S/);
-
-  expect(notDigit).toMatchString('A');
-  expect(notDigit).not.toMatchString('1');
-  expect(notDigit).toMatchString(' ');
-  expect(notDigit).toMatchString('#');
-
-  expect(notWord).not.toMatchString('A');
-  expect(notWord).not.toMatchString('1');
-  expect(notWord).toMatchString(' ');
-  expect(notWord).toMatchString('#');
-
-  expect(notWhitespace).toMatchString('A');
-  expect(notWhitespace).toMatchString('1');
-  expect(notWhitespace).not.toMatchString(' ');
-  expect(notWhitespace).toMatchString('#');
+  expect(nonDigit).toEqualRegex(/\D/);
+  expect(nonWord).toEqualRegex(/\W/);
+  expect(nonWhitespace).toEqualRegex(/\S/);
+
+  expect(nonDigit).toMatchString('A');
+  expect(nonDigit).not.toMatchString('1');
+  expect(nonDigit).toMatchString(' ');
+  expect(nonDigit).toMatchString('#');
+
+  expect(nonWord).not.toMatchString('A');
+  expect(nonWord).not.toMatchString('1');
+  expect(nonWord).toMatchString(' ');
+  expect(nonWord).toMatchString('#');
+
+  expect(nonWhitespace).toMatchString('A');
+  expect(nonWhitespace).toMatchString('1');
+  expect(nonWhitespace).not.toMatchString(' ');
+  expect(nonWhitespace).toMatchString('#');
 });

src/constructs/character-class.ts

@@ -33,7 +33,7 @@ export const digit: CharacterClass = {
   encode: encodeCharacterClass,
 };
 
-export const notDigit: CharacterClass = {
+export const nonDigit: CharacterClass = {
   type: 'characterClass',
   chars: ['\\D'],
   ranges: [],
@@ -49,7 +49,7 @@ export const word: CharacterClass = {
   encode: encodeCharacterClass,
 };
 
-export const notWord: CharacterClass = {
+export const nonWord: CharacterClass = {
   type: 'characterClass',
   chars: ['\\W'],
   ranges: [],
@@ -65,14 +65,29 @@ export const whitespace: CharacterClass = {
   encode: encodeCharacterClass,
 };
 
-export const notWhitespace: CharacterClass = {
+export const nonWhitespace: CharacterClass = {
   type: 'characterClass',
   chars: ['\\S'],
   ranges: [],
   isInverted: false,
   encode: encodeCharacterClass,
 };
 
+/**
+ * @deprecated Renamed to `nonDigit`.
+ */
+export const notDigit = nonDigit;
+
+/**
+ * @deprecated Renamed to `nonWord`.
+ */
+export const notWord = nonWord;
+
+/**
+ * @deprecated Renamed to `nonWhitespace`.
+ */
+export const notWhitespace = nonWhitespace;
+
 export function charClass(...elements: CharacterClass[]): CharacterClass {
   elements.forEach((element) => {
     if (element.isInverted) {

src/index.ts

@@ -11,6 +11,9 @@ export {
   charRange,
   digit,
   inverted,
+  nonDigit,
+  nonWhitespace,
+  nonWord,
   notDigit,
   notWhitespace,
   notWord,

website/docs/api/character-classes.md

@@ -10,20 +10,20 @@ Character classes are a set of characters that match any one of the characters i
 ```ts
 const any: CharacterClass;
 const word: CharacterClass;
-const notWord: CharacterClass;
+const nonWord: CharacterClass;
 const digit: CharacterClass;
-const notDigit: CharacterClass;
+const nonDigit: CharacterClass;
 const whitespace: CharacterClass;
-const notWhitespace: CharacterClass;
+const nonWhitespace: CharacterClass;
 ```
 
 - `any` matches any character except newline characters. Regex syntax: `*`.
 - `word` matches any word character (letters, digits & underscore). Regex syntax: `\w`.
-- `notWord` matches any character **except** word characters (letters, digits & underscore). Regex syntax: `\W`.
+- `nonWord` matches any character **except** word characters (letters, digits & underscore). Regex syntax: `\W`.
 - `digit` matches any digit. Regex syntax: `\d`.
-- `notDigit` matches any character **except** digits. Regex syntax: `\D`.
+- `nonDigit` matches any character **except** digits. Regex syntax: `\D`.
 - `whitespace` matches any whitespace character (spaces, tabs, line breaks). Regex syntax: `\s`.
-- `notWhitespace` matches any character **except** whitespace characters (spaces, tabs, line breaks). Regex syntax: `\S`.
+- `nonWhitespace` matches any character **except** whitespace characters (spaces, tabs, line breaks). Regex syntax: `\S`.
 
 ### `anyOf()`