pronouny 0.3.1 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # Pronouny
 
-**Pronouny** is a typed library intended to make programmatically resolving English pronouns easier. \
+**Pronouny** is a typed library intended to make programmatically resolving English pronouns easier.
 
 ## Installation
 
@@ -26,6 +26,9 @@ const p = new Pronouny({
 	// Will default to using random pronouns in arrays.
 	// Set to false to force using 0 index.
 	useRandom: true,
+
+	// Will default to using "they" as a fallback pronoun.
+	fallbackPronoun: "they",
 });
 
 // Create a new Pronoun object using Pronouny.new()
@@ -49,7 +52,7 @@ p.add(pronounZe);
 p.remove(p.resolve("I"));
 // this deletes the "I" pronoun from the map.
 
-// Methods are chainable and you can reach the Pronoun class.
+// Methods are chainable so you can reach the Pronoun class.
 p.add(pronounZe).set("he/they").use().subject();
 //   ^Pronouny      ^PronounSet    ^Pronoun  ^string
 
@@ -58,7 +61,7 @@ const vayne = {
 	username: "vaynegarden",
 	pronouns: p.set("she/ze/they"),
 };
-// from there, you can use `[PronounSet].use()` to get a random pronoun.
+// from there, you can use `[PronounSet].use()` to get a random `Pronoun`.
 
 // Resolve the pronouns in your app by referencing the form
 // that you need. There's `subject`, `object`, `possessive`,
@@ -73,6 +76,12 @@ console.log(
 
 ## Changelog
 
+### v0.4.0
+
+-   Optimized `forEach()` calls to use `for` loops instead.
+-   Added `fallbackPronoun` option to allow for configuration of pronoun to use in case of quiet failure states.
+-   Removed redundant `set` parameter from `[PronounSet].remove()` calls.
+
 ### v0.3.1
 
 -   Added documentation.

package/lib/cjs/index.d.ts

@@ -140,7 +140,7 @@ declare class PronounSet {
      * @param failQuietly
      * Override default behavior to fail into 'they'.
      */
-    add(pronoun: string | Pronoun | Array<string> | Array<Pronoun>, failQuietly?: boolean | undefined): this;
+    add(pronoun: string | Pronoun | Array<string> | Array<Pronoun>, failQuietly?: boolean): this;
     /**# `.remove()` from PronounSet
      * Remove pronoun/s from a given Pronoun or strings
      * (resolved using the {@linkcode Pronouny} instance
@@ -153,7 +153,7 @@ declare class PronounSet {
      * @param failQuietly
      * Override default behavior to fail into no removal.
      */
-    remove(set: PronounSet, pronoun: string | Pronoun | Array<string> | Array<Pronoun>, failQuietly?: boolean | undefined): this;
+    remove(pronoun: string | Pronoun | Array<string> | Array<Pronoun>, failQuietly?: boolean): this;
     /**# `.use()` a PronounSet
      * A method to retrieve one Pronoun at random. Use with
      * {@link Pronoun|`Pronoun` methods} to get a specific
@@ -174,17 +174,17 @@ declare class PronounSet {
      * Override default behavior to use random as per
      * Pronouny config.
      */
-    use(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): Pronoun;
+    use(index?: number, failQuietly?: boolean, useRandom?: boolean): Pronoun;
     /**Retrieves a random subject pronoun. */
-    subject(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): string;
+    subject(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
     /**Retrieves a random object pronoun. */
-    object(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): string;
+    object(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
     /**Retrieves a random possessive pronoun. */
-    possessive(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): string;
+    possessive(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
     /**Retrieves a random possessive adjective pronoun. */
-    psAdjective(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): string;
+    psAdjective(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
     /**Retrieves a random reflexive pronoun. */
-    reflexive(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): string;
+    reflexive(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
 }
 /**# Config
  * `failQuietly`: Controls various quiet failure states.
@@ -197,19 +197,33 @@ declare class PronounSet {
  * used. If false, it will default to 0. If failing
  * quietly and indexing out of bounds, it will use the
  * last item.
+ *
+ * `fallbackPronoun`: Controls what is considered the
+ * default pronoun for when one is not assigned or for
+ * quiet failure states. By default, this is `they`. **It
+ * is not recommended to change this.**
  */
 type PronounyConfig = {
     /**Controls various quiet failure states. */
-    failQuietly?: boolean;
+    failQuietly: boolean;
     /**Controls how deeply Pronouny will search for
      * queries. By default, `string` parameters will
      * only resolve using the first subject pronoun. */
-    deepSearch?: boolean;
+    deepSearch: boolean;
     /**Controls whether random selection will be used.
      * If false, it will default to 0. If failing
      * quietly and indexing out of bounds, it will
      * use the last item. */
-    useRandom?: boolean;
+    useRandom: boolean;
+    /**Controls what is considered the default pronoun
+     * for when one is not assigned or for quiet failure
+     * states. By default, this is `they`. **It is not
+     * recommended to change this.**
+     *
+     * If you remove `they` from the Pronouny instance,
+     * you are responsible for setting this to a valid
+     * pronoun string and ensuring it will resolve. */
+    fallbackPronoun: string;
 };
 /**# Pronouny
  * A typed library intended to make English pronoun
@@ -244,7 +258,7 @@ export default class Pronouny {
      * Pronouny's config to determine the depth of search.
      * By default, only checks the first subject pronoun.
      */
-    resolve(pronoun: string, deepSearch?: boolean | undefined): Pronoun;
+    resolve(pronoun: string, deepSearch?: boolean): Pronoun;
     /**# `.add()` an Unlisted Pronoun
      * If you made a `.new()` Pronoun but disabled
      * `autoAppend`, you can later append it back by

package/lib/cjs/index.js

@@ -216,27 +216,27 @@ class PronounSet {
         this.resolver = resolver;
         switch (true) {
             case Array.isArray(pronouns):
-                pronouns.forEach((x) => {
+                for (const x of pronouns) {
                     if (x instanceof Pronoun) {
                         this.pronouns.add(x);
                     }
                     else {
                         this.pronouns.add(resolver.resolve(x));
                     }
-                });
+                }
                 break;
             case typeof pronouns === "string":
                 this.pronouns.add(resolver.resolve(pronouns));
                 break;
             default:
-                pronouns.forEach((x) => {
+                for (const x of pronouns) {
                     if (x instanceof Pronoun) {
                         this.pronouns.add(x);
                     }
                     else {
                         this.pronouns.add(resolver.resolve(x));
                     }
-                });
+                }
                 break;
         }
         return this;
@@ -262,12 +262,12 @@ class PronounSet {
                 this.pronouns.add(this.resolver.resolve(pronoun));
                 break;
             case pronoun instanceof Array:
-                pronoun.forEach((p) => {
+                for (const p of pronoun) {
                     this.add(p, failQuietly);
-                });
+                }
                 break;
             case failQuietly:
-                this.pronouns.add(this.resolver.resolve("they"));
+                this.pronouns.add(this.resolver.resolve(this.resolver.config.fallbackPronoun));
                 break;
             case !failQuietly:
             default:
@@ -287,18 +287,18 @@ class PronounSet {
      * @param failQuietly
      * Override default behavior to fail into no removal.
      */
-    remove(set, pronoun, failQuietly = this.resolver.config.failQuietly) {
+    remove(pronoun, failQuietly = this.resolver.config.failQuietly) {
         switch (true) {
             case pronoun instanceof Pronoun:
-                set.pronouns.delete(pronoun);
+                this.pronouns.delete(pronoun);
                 break;
             case typeof pronoun === "string":
-                set.pronouns.delete(this.resolver.resolve(pronoun));
+                this.pronouns.delete(this.resolver.resolve(pronoun));
                 break;
             case pronoun instanceof Array:
-                pronoun.forEach((p) => {
-                    this.remove(set, p);
-                });
+                for (const p of pronoun) {
+                    this.remove(p);
+                }
                 break;
             case failQuietly:
                 break;
@@ -346,7 +346,7 @@ class PronounSet {
             case indexable[index] !== undefined:
                 return indexable[index];
             case failQuietly:
-                return this.resolver.resolve("they");
+                return this.resolver.resolve(this.resolver.config.fallbackPronoun);
             default:
                 throw new Error(`Index ${index} out of range`);
         }
@@ -418,6 +418,7 @@ const PronounyDefaultConfig = {
     failQuietly: true,
     deepSearch: false,
     useRandom: true,
+    fallbackPronoun: "they",
 };
 /**# Pronouny
  * A typed library intended to make English pronoun
@@ -468,18 +469,18 @@ class Pronouny {
                 return resolvedPronoun;
             case deepSearch:
                 let searchResult;
-                this.resolveMap.forEach((mapPronoun) => {
-                    Object.values(mapPronoun).forEach((type) => {
+                for (const [_, value] of this.resolveMap) {
+                    for (const type of Object.values(value)) {
                         if (type.includes(pronoun)) {
-                            searchResult = mapPronoun;
+                            searchResult = value;
                         }
-                    });
-                });
+                    }
+                }
                 if (searchResult) {
                     return searchResult;
                 }
             case this.config.failQuietly:
-                return this.resolveMap.get("they");
+                return this.resolveMap.get(this.config.fallbackPronoun);
             default:
                 throw new Error(`Pronoun "${pronoun}" not found`);
         }
@@ -498,6 +499,9 @@ class Pronouny {
      * Pronouny instance. Returns `Pronouny`.
      */
     remove(pronoun) {
+        if (pronoun === this.resolveMap.get(this.config.fallbackPronoun)) {
+            throw new Error(`Cannot remove fallback pronoun. Assign a new one before removal.`);
+        }
         this.resolveMap.delete(pronoun.sbj[0]);
         return this;
     }

package/lib/esm/index.d.ts

@@ -140,7 +140,7 @@ declare class PronounSet {
      * @param failQuietly
      * Override default behavior to fail into 'they'.
      */
-    add(pronoun: string | Pronoun | Array<string> | Array<Pronoun>, failQuietly?: boolean | undefined): this;
+    add(pronoun: string | Pronoun | Array<string> | Array<Pronoun>, failQuietly?: boolean): this;
     /**# `.remove()` from PronounSet
      * Remove pronoun/s from a given Pronoun or strings
      * (resolved using the {@linkcode Pronouny} instance
@@ -153,7 +153,7 @@ declare class PronounSet {
      * @param failQuietly
      * Override default behavior to fail into no removal.
      */
-    remove(set: PronounSet, pronoun: string | Pronoun | Array<string> | Array<Pronoun>, failQuietly?: boolean | undefined): this;
+    remove(pronoun: string | Pronoun | Array<string> | Array<Pronoun>, failQuietly?: boolean): this;
     /**# `.use()` a PronounSet
      * A method to retrieve one Pronoun at random. Use with
      * {@link Pronoun|`Pronoun` methods} to get a specific
@@ -174,17 +174,17 @@ declare class PronounSet {
      * Override default behavior to use random as per
      * Pronouny config.
      */
-    use(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): Pronoun;
+    use(index?: number, failQuietly?: boolean, useRandom?: boolean): Pronoun;
     /**Retrieves a random subject pronoun. */
-    subject(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): string;
+    subject(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
     /**Retrieves a random object pronoun. */
-    object(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): string;
+    object(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
     /**Retrieves a random possessive pronoun. */
-    possessive(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): string;
+    possessive(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
     /**Retrieves a random possessive adjective pronoun. */
-    psAdjective(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): string;
+    psAdjective(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
     /**Retrieves a random reflexive pronoun. */
-    reflexive(index?: number, failQuietly?: boolean | undefined, useRandom?: boolean | undefined): string;
+    reflexive(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
 }
 /**# Config
  * `failQuietly`: Controls various quiet failure states.
@@ -197,19 +197,33 @@ declare class PronounSet {
  * used. If false, it will default to 0. If failing
  * quietly and indexing out of bounds, it will use the
  * last item.
+ *
+ * `fallbackPronoun`: Controls what is considered the
+ * default pronoun for when one is not assigned or for
+ * quiet failure states. By default, this is `they`. **It
+ * is not recommended to change this.**
  */
 type PronounyConfig = {
     /**Controls various quiet failure states. */
-    failQuietly?: boolean;
+    failQuietly: boolean;
     /**Controls how deeply Pronouny will search for
      * queries. By default, `string` parameters will
      * only resolve using the first subject pronoun. */
-    deepSearch?: boolean;
+    deepSearch: boolean;
     /**Controls whether random selection will be used.
      * If false, it will default to 0. If failing
      * quietly and indexing out of bounds, it will
      * use the last item. */
-    useRandom?: boolean;
+    useRandom: boolean;
+    /**Controls what is considered the default pronoun
+     * for when one is not assigned or for quiet failure
+     * states. By default, this is `they`. **It is not
+     * recommended to change this.**
+     *
+     * If you remove `they` from the Pronouny instance,
+     * you are responsible for setting this to a valid
+     * pronoun string and ensuring it will resolve. */
+    fallbackPronoun: string;
 };
 /**# Pronouny
  * A typed library intended to make English pronoun
@@ -244,7 +258,7 @@ export default class Pronouny {
      * Pronouny's config to determine the depth of search.
      * By default, only checks the first subject pronoun.
      */
-    resolve(pronoun: string, deepSearch?: boolean | undefined): Pronoun;
+    resolve(pronoun: string, deepSearch?: boolean): Pronoun;
     /**# `.add()` an Unlisted Pronoun
      * If you made a `.new()` Pronoun but disabled
      * `autoAppend`, you can later append it back by

package/lib/esm/index.js

@@ -214,27 +214,27 @@ class PronounSet {
         this.resolver = resolver;
         switch (true) {
             case Array.isArray(pronouns):
-                pronouns.forEach((x) => {
+                for (const x of pronouns) {
                     if (x instanceof Pronoun) {
                         this.pronouns.add(x);
                     }
                     else {
                         this.pronouns.add(resolver.resolve(x));
                     }
-                });
+                }
                 break;
             case typeof pronouns === "string":
                 this.pronouns.add(resolver.resolve(pronouns));
                 break;
             default:
-                pronouns.forEach((x) => {
+                for (const x of pronouns) {
                     if (x instanceof Pronoun) {
                         this.pronouns.add(x);
                     }
                     else {
                         this.pronouns.add(resolver.resolve(x));
                     }
-                });
+                }
                 break;
         }
         return this;
@@ -260,12 +260,12 @@ class PronounSet {
                 this.pronouns.add(this.resolver.resolve(pronoun));
                 break;
             case pronoun instanceof Array:
-                pronoun.forEach((p) => {
+                for (const p of pronoun) {
                     this.add(p, failQuietly);
-                });
+                }
                 break;
             case failQuietly:
-                this.pronouns.add(this.resolver.resolve("they"));
+                this.pronouns.add(this.resolver.resolve(this.resolver.config.fallbackPronoun));
                 break;
             case !failQuietly:
             default:
@@ -285,18 +285,18 @@ class PronounSet {
      * @param failQuietly
      * Override default behavior to fail into no removal.
      */
-    remove(set, pronoun, failQuietly = this.resolver.config.failQuietly) {
+    remove(pronoun, failQuietly = this.resolver.config.failQuietly) {
         switch (true) {
             case pronoun instanceof Pronoun:
-                set.pronouns.delete(pronoun);
+                this.pronouns.delete(pronoun);
                 break;
             case typeof pronoun === "string":
-                set.pronouns.delete(this.resolver.resolve(pronoun));
+                this.pronouns.delete(this.resolver.resolve(pronoun));
                 break;
             case pronoun instanceof Array:
-                pronoun.forEach((p) => {
-                    this.remove(set, p);
-                });
+                for (const p of pronoun) {
+                    this.remove(p);
+                }
                 break;
             case failQuietly:
                 break;
@@ -344,7 +344,7 @@ class PronounSet {
             case indexable[index] !== undefined:
                 return indexable[index];
             case failQuietly:
-                return this.resolver.resolve("they");
+                return this.resolver.resolve(this.resolver.config.fallbackPronoun);
             default:
                 throw new Error(`Index ${index} out of range`);
         }
@@ -416,6 +416,7 @@ const PronounyDefaultConfig = {
     failQuietly: true,
     deepSearch: false,
     useRandom: true,
+    fallbackPronoun: "they",
 };
 /**# Pronouny
  * A typed library intended to make English pronoun
@@ -466,18 +467,18 @@ export default class Pronouny {
                 return resolvedPronoun;
             case deepSearch:
                 let searchResult;
-                this.resolveMap.forEach((mapPronoun) => {
-                    Object.values(mapPronoun).forEach((type) => {
+                for (const [_, value] of this.resolveMap) {
+                    for (const type of Object.values(value)) {
                         if (type.includes(pronoun)) {
-                            searchResult = mapPronoun;
+                            searchResult = value;
                         }
-                    });
-                });
+                    }
+                }
                 if (searchResult) {
                     return searchResult;
                 }
             case this.config.failQuietly:
-                return this.resolveMap.get("they");
+                return this.resolveMap.get(this.config.fallbackPronoun);
             default:
                 throw new Error(`Pronoun "${pronoun}" not found`);
         }
@@ -496,6 +497,9 @@ export default class Pronouny {
      * Pronouny instance. Returns `Pronouny`.
      */
     remove(pronoun) {
+        if (pronoun === this.resolveMap.get(this.config.fallbackPronoun)) {
+            throw new Error(`Cannot remove fallback pronoun. Assign a new one before removal.`);
+        }
         this.resolveMap.delete(pronoun.sbj[0]);
         return this;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pronouny",
-	"version": "0.3.1",
+	"version": "0.4.0",
 	"description": "a small, typed utility library to determine the correct pronoun from a string and several utility functions.",
 	"main": "./lib/cjs/index.js",
 	"module": "./lib/esm/index.js",