namefully 2.0.0 → 2.0.2

package/dist/esm/types.d.ts

@@ -1,6 +1,4 @@
-/**
- * Make a type nullable.
- */
+/** Make a type nullable. */
 export type Nullable<T> = T | null | undefined;
 /**
  * The abbreviation type to indicate whether or not to add period to a prefix
@@ -23,25 +21,19 @@ export declare enum Surname {
     HYPHENATED = "hyphenated",
     ALL = "all"
 }
-/**
- * The order of appearance of a `FullName`.
- */
+/** The order of appearance of a `FullName`. */
 export declare enum NameOrder {
     FIRST_NAME = "firstName",
     LAST_NAME = "lastName"
 }
-/**
- * The types of name handled in this according the name standards.
- */
+/** The types of name handled in this according the name standards. */
 export declare enum NameType {
     FIRST_NAME = "firstName",
     MIDDLE_NAME = "middleName",
     LAST_NAME = "lastName",
     BIRTH_NAME = "birthName"
 }
-/**
- * The possible variants to indicate how to flatten a `FullName`.
- */
+/** The possible variants to indicate how to flatten a `FullName`. */
 export declare enum Flat {
     FIRST_NAME = "firstName",
     MIDDLE_NAME = "middleName",
@@ -50,17 +42,13 @@ export declare enum Flat {
     MID_LAST = "midLast",
     ALL = "all"
 }
-/**
- * The range to use when capitalizing a string content.
- */
+/** The range to use when capitalizing a string content. */
 export declare enum CapsRange {
     NONE = 0,
     INITIAL = 1,
     ALL = 2
 }
-/**
- * The types of name handled in this utility according the name standards.
- */
+/** The types of name handled in this utility according the name standards. */
 export declare class Namon {
     readonly index: number;
     readonly key: string;
@@ -69,35 +57,21 @@ export declare class Namon {
     static readonly MIDDLE_NAME: Namon;
     static readonly LAST_NAME: Namon;
     static readonly SUFFIX: Namon;
-    /**
-     * The list of supported name types.
-     */
+    /** The list of supported name types. */
     static readonly values: Namon[];
-    /**
-     * All the predefined name types.
-     */
+    /** All the predefined name types. */
     static readonly all: Map<string, Namon>;
     private constructor();
-    /**
-     * Whether this string key is part of the predefined keys.
-     */
+    /** Whether this string key is part of the predefined keys. */
     static has(key: string): boolean;
-    /**
-     * Makes a string key a namon type.
-     */
+    /** Makes a string key a namon type. */
     static cast(key: string): Nullable<Namon>;
-    /**
-     * String representation of this object.
-     */
+    /** String representation of this object. */
     toString(): string;
-    /**
-     * Whether this and the other value are equal.
-     */
+    /** Whether this and the other value are equal. */
     equal(other: Namon | unknown): boolean;
 }
-/**
- * The token used to indicate how to split string values.
- */
+/** The token used to indicate how to split string values. */
 export declare class Separator {
     readonly name: string;
     readonly token: string;
@@ -111,17 +85,11 @@ export declare class Separator {
     static readonly SINGLE_QUOTE: Separator;
     static readonly SPACE: Separator;
     static readonly UNDERSCORE: Separator;
-    /**
-     * All the available separators.
-     */
+    /** All the available separators. */
     static readonly all: Map<string, Separator>;
-    /**
-     * All the available tokens.
-     */
+    /** All the available tokens. */
     static readonly tokens: string[];
     private constructor();
-    /**
-     * String representation of this object.
-     */
+    /** String representation of this object. */
     toString(): string;
 }

package/dist/esm/utils.d.ts

@@ -1,6 +1,6 @@
 import { NameOrder, CapsRange } from './types.js';
 /**
- * A fixed set of values to handle specific positions for list of names.
+ * A set of values to handle specific positions for list of names.
  *
  * As for list of names, this helps to follow a specific order based on the
  * count of elements. It is expected that the list has to be between two and
@@ -42,13 +42,12 @@ export declare class NameIndex {
     static when(order: NameOrder, count?: number): NameIndex;
     static only({ prefix, firstName, middleName, lastName, suffix }: Record<string, number>): NameIndex;
     toJson(): Record<string, number>;
+    json: () => Record<string, number>;
 }
-/**
- * Capitalizes a string via a `CapsRange` option.
- */
+/** Capitalizes a string via a `CapsRange` option. */
 export declare function capitalize(str: string, range?: CapsRange): string;
 /** Decapitalizes a string via a `CapsRange` option. */
 export declare function decapitalize(str: string, range?: CapsRange): string;
 /** Toggles a string representation. */
 export declare function toggleCase(str: string): string;
-export declare function isStringArray(value?: unknown): boolean;
+export declare function isStringArray(value?: unknown): value is string[];

package/dist/esm/utils.js

@@ -1,5 +1,5 @@
-import { MIN_NUMBER_OF_NAME_PARTS, MAX_NUMBER_OF_NAME_PARTS } from './constants.js';
 import { NameOrder, CapsRange } from './types.js';
+import { MIN_NUMBER_OF_NAME_PARTS, MAX_NUMBER_OF_NAME_PARTS } from './constants.js';
 export class NameIndex {
     prefix;
     firstName;
@@ -20,19 +20,19 @@ export class NameIndex {
         this.suffix = suffix;
     }
     static base() {
-        return new this(-1, 0, -1, 1, -1);
+        return new NameIndex(-1, 0, -1, 1, -1);
     }
     static when(order, count = 2) {
         if (order === NameOrder.FIRST_NAME) {
             switch (count) {
                 case 2:
-                    return new this(-1, 0, -1, 1, -1);
+                    return new NameIndex(-1, 0, -1, 1, -1);
                 case 3:
-                    return new this(-1, 0, 1, 2, -1);
+                    return new NameIndex(-1, 0, 1, 2, -1);
                 case 4:
-                    return new this(0, 1, 2, 3, -1);
+                    return new NameIndex(0, 1, 2, 3, -1);
                 case 5:
-                    return new this(0, 1, 2, 3, 4);
+                    return new NameIndex(0, 1, 2, 3, 4);
                 default:
                     return NameIndex.base();
             }
@@ -40,20 +40,20 @@ export class NameIndex {
         else {
             switch (count) {
                 case 2:
-                    return new this(-1, 1, -1, 0, -1);
+                    return new NameIndex(-1, 1, -1, 0, -1);
                 case 3:
-                    return new this(-1, 1, 2, 0, -1);
+                    return new NameIndex(-1, 1, 2, 0, -1);
                 case 4:
-                    return new this(0, 2, 3, 1, -1);
+                    return new NameIndex(0, 2, 3, 1, -1);
                 case 5:
-                    return new this(0, 2, 3, 1, 4);
+                    return new NameIndex(0, 2, 3, 1, 4);
                 default:
                     return NameIndex.base();
             }
         }
     }
     static only({ prefix = -1, firstName, middleName = -1, lastName, suffix = -1 }) {
-        return new this(prefix, firstName, middleName, lastName, suffix);
+        return new NameIndex(prefix, firstName, middleName, lastName, suffix);
     }
     toJson() {
         return {
@@ -64,32 +64,25 @@ export class NameIndex {
             suffix: this.suffix,
         };
     }
+    json = this.toJson;
 }
 export function capitalize(str, range = CapsRange.INITIAL) {
     if (!str || range === CapsRange.NONE)
         return str;
-    const initial = str[0].toUpperCase();
-    const rest = str.slice(1).toLowerCase();
+    const [initial, rest] = [str[0].toUpperCase(), str.slice(1).toLowerCase()];
     return range === CapsRange.INITIAL ? initial.concat(rest) : str.toUpperCase();
 }
 export function decapitalize(str, range = CapsRange.INITIAL) {
     if (!str || range === CapsRange.NONE)
         return str;
-    const initial = str[0].toLowerCase();
-    const rest = str.slice(1);
+    const [initial, rest] = [str[0].toLowerCase(), str.slice(1)];
     return range === CapsRange.INITIAL ? initial.concat(rest) : str.toLowerCase();
 }
 export function toggleCase(str) {
-    const chars = [];
-    for (const c of str) {
-        if (c === c.toUpperCase()) {
-            chars.push(c.toLowerCase());
-        }
-        else {
-            chars.push(c.toUpperCase());
-        }
-    }
-    return chars.join('');
+    return str
+        .split('')
+        .map((c) => (c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase()))
+        .join('');
 }
 export function isStringArray(value) {
     return Array.isArray(value) && value.length > 0 && value.every((e) => typeof e === 'string');

package/dist/esm/validator.d.ts

@@ -1,6 +1,6 @@
-import { FirstName, LastName, Name } from './name.js';
 import { Namon } from './types.js';
 import { NameIndex } from './utils.js';
+import { FirstName, LastName, Name } from './name.js';
 export interface Validator<T> {
     validate(value: T): void;
 }

package/dist/esm/validator.js

@@ -1,8 +1,8 @@
-import { MIN_NUMBER_OF_NAME_PARTS, MAX_NUMBER_OF_NAME_PARTS } from './constants.js';
-import { InputError, ValidationError } from './error.js';
-import { FirstName, LastName, Name, isNameArray } from './name.js';
 import { Namon } from './types.js';
 import { NameIndex } from './utils.js';
+import { FirstName, LastName, Name, isNameArray } from './name.js';
+import { InputError, ValidationError } from './error.js';
+import { MIN_NUMBER_OF_NAME_PARTS as MIN, MAX_NUMBER_OF_NAME_PARTS as MAX } from './constants.js';
 class ValidationRule {
     static base = /[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]/;
     static namon = new RegExp(`^${ValidationRule.base.source}+(([' -]${ValidationRule.base.source})?${ValidationRule.base.source}*)*$`);
@@ -15,10 +15,10 @@ const toNameSource = (values) => {
 };
 class ArrayValidator {
     validate(values) {
-        if (values.length === 0 || values.length < MIN_NUMBER_OF_NAME_PARTS || values.length > MAX_NUMBER_OF_NAME_PARTS) {
+        if (values.length === 0 || values.length < MIN || values.length > MAX) {
             throw new InputError({
                 source: values.map((n) => n.toString()),
-                message: `expecting a list of ${MIN_NUMBER_OF_NAME_PARTS}-${MIN_NUMBER_OF_NAME_PARTS} elements`,
+                message: `expecting a list of ${MIN}-${MAX} elements`,
             });
         }
     }
@@ -26,7 +26,7 @@ class ArrayValidator {
 class NamonValidator {
     static #validator;
     static create() {
-        return this.#validator || (this.#validator = new this());
+        return this.#validator || (this.#validator = new NamonValidator());
     }
     validate(value, type) {
         if (value instanceof Name) {
@@ -37,22 +37,19 @@ class NamonValidator {
                 throw new ValidationError({
                     source: value,
                     nameType: 'namon',
-                    message: 'invalid content',
+                    message: 'invalid name content failing namon regex',
                 });
             }
         }
         else {
-            throw new InputError({
-                source: typeof value,
-                message: 'expecting types of string | Name',
-            });
+            throw new InputError({ source: typeof value, message: 'expecting types of string or Name' });
         }
     }
 }
 class FirstNameValidator {
     static #validator;
     static create() {
-        return this.#validator || (this.#validator = new this());
+        return this.#validator || (this.#validator = new FirstNameValidator());
     }
     validate(value) {
         if (value instanceof FirstName) {
@@ -63,22 +60,19 @@ class FirstNameValidator {
                 throw new ValidationError({
                     source: value,
                     nameType: 'firstName',
-                    message: 'invalid content',
+                    message: 'invalid name content failing firstName regex',
                 });
             }
         }
         else {
-            throw new InputError({
-                source: typeof value,
-                message: 'expecting types string | FirstName',
-            });
+            throw new InputError({ source: typeof value, message: 'expecting types string or FirstName' });
         }
     }
 }
 class MiddleNameValidator {
     static #validator;
     static create() {
-        return this.#validator || (this.#validator = new this());
+        return this.#validator || (this.#validator = new MiddleNameValidator());
     }
     validate(value) {
         if (typeof value === 'string') {
@@ -86,7 +80,7 @@ class MiddleNameValidator {
                 throw new ValidationError({
                     source: value,
                     nameType: 'middleName',
-                    message: 'invalid content',
+                    message: 'invalid name content failing middleName regex',
                 });
             }
         }
@@ -107,7 +101,7 @@ class MiddleNameValidator {
         else {
             throw new InputError({
                 source: typeof value,
-                message: 'expecting types of string | string[] | Name[]',
+                message: 'expecting types of string, string[] or Name[]',
             });
         }
     }
@@ -115,7 +109,7 @@ class MiddleNameValidator {
 class LastNameValidator {
     static #validator;
     static create() {
-        return this.#validator || (this.#validator = new this());
+        return this.#validator || (this.#validator = new LastNameValidator());
     }
     validate(value) {
         if (value instanceof LastName) {
@@ -126,36 +120,33 @@ class LastNameValidator {
                 throw new ValidationError({
                     source: value,
                     nameType: 'lastName',
-                    message: 'invalid content',
+                    message: 'invalid name content failing lastName regex',
                 });
             }
         }
         else {
-            throw new InputError({
-                source: typeof value,
-                message: 'expecting types string | LastName',
-            });
+            throw new InputError({ source: typeof value, message: 'expecting types string or LastName' });
         }
     }
 }
 class NameValidator {
     static #validator;
     static create() {
-        return this.#validator || (this.#validator = new this());
+        return this.#validator || (this.#validator = new NameValidator());
     }
     validate(name, type) {
         if (type && name.type !== type) {
             throw new ValidationError({
                 source: name.toString(),
                 nameType: name.type.toString(),
-                message: 'wrong type',
+                message: 'wrong name type; only Namon types are supported',
             });
         }
         if (!ValidationRule.namon.test(name.value)) {
             throw new ValidationError({
                 source: name.toString(),
                 nameType: name.type.toString(),
-                message: 'invalid content',
+                message: 'invalid name content failing namon regex',
             });
         }
     }
@@ -163,7 +154,7 @@ class NameValidator {
 export class NamaValidator {
     static #validator;
     static create() {
-        return this.#validator || (this.#validator = new this());
+        return this.#validator || (this.#validator = new NamaValidator());
     }
     validate(value) {
         this.validateKeys(value);
@@ -178,23 +169,17 @@ export class NamaValidator {
         if (!nama.size) {
             throw new InputError({ source: undefined, message: 'Map<k,v> must not be empty' });
         }
-        else if (nama.size < MIN_NUMBER_OF_NAME_PARTS || nama.size > MAX_NUMBER_OF_NAME_PARTS) {
+        else if (nama.size < MIN || nama.size > MAX) {
             throw new InputError({
                 source: [...nama.values()],
-                message: `expecting ${MIN_NUMBER_OF_NAME_PARTS}-${MIN_NUMBER_OF_NAME_PARTS} fields`,
+                message: `expecting ${MIN}-${MAX} fields`,
             });
         }
         if (!nama.has(Namon.FIRST_NAME)) {
-            throw new InputError({
-                source: [...nama.values()],
-                message: '"firstName" is a required key',
-            });
+            throw new InputError({ source: [...nama.values()], message: '"firstName" is a required key' });
         }
         if (!nama.has(Namon.LAST_NAME)) {
-            throw new InputError({
-                source: [...nama.values()],
-                message: '"lastName" is a required key',
-            });
+            throw new InputError({ source: [...nama.values()], message: '"lastName" is a required key' });
         }
     }
 }
@@ -222,13 +207,13 @@ export class ArrayStringValidator extends ArrayValidator {
 export class ArrayNameValidator {
     static #validator;
     static create() {
-        return this.#validator || (this.#validator = new this());
+        return this.#validator || (this.#validator = new ArrayNameValidator());
     }
     validate(value) {
-        if (value.length < MIN_NUMBER_OF_NAME_PARTS) {
+        if (value.length < MIN) {
             throw new InputError({
                 source: toNameSource(value),
-                message: `expecting at least ${MIN_NUMBER_OF_NAME_PARTS} elements`,
+                message: `expecting at least ${MIN} elements`,
             });
         }
         if (!this.#hasBasicNames(value)) {
@@ -245,7 +230,7 @@ export class ArrayNameValidator {
                 accumulator[name.type.key] = name.toString();
             }
         }
-        return Object.keys(accumulator).length === MIN_NUMBER_OF_NAME_PARTS;
+        return Object.keys(accumulator).length === MIN;
     }
 }
 export class Validators {