namefully 1.3.0 → 1.3.1

package/dist/lib/parser.js

@@ -1,19 +1,13 @@
 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _NamaParser_instances, _NamaParser_asNama;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayNameParser = exports.NamaParser = exports.ArrayStringParser = exports.StringParser = exports.Parser = void 0;
-const full_name_1 = require("./full-name");
 const config_1 = require("./config");
 const utils_1 = require("./utils");
-const validator_1 = require("./validator");
-const name_1 = require("./name");
-const types_1 = require("./types");
 const error_1 = require("./error");
+const full_name_1 = require("./full-name");
+const types_1 = require("./types");
+const name_1 = require("./name");
+const validator_1 = require("./validator");
 class Parser {
     constructor(raw) {
         this.raw = raw;
@@ -22,16 +16,13 @@ class Parser {
         const parts = text.trim().split(types_1.Separator.SPACE.token);
         const length = parts.length;
         if (index instanceof utils_1.NameIndex) {
-            const names = Object.entries(index.toJson())
+            const names = Object.entries(index.json())
                 .filter(([, position]) => position > -1 && position < length)
                 .map(([key, position]) => new name_1.Name(parts[position], types_1.Namon.all.get(key)));
             return new ArrayNameParser(names);
         }
         if (length < 2) {
-            throw new error_1.InputError({
-                source: text,
-                message: 'cannot build from invalid input',
-            });
+            throw new error_1.InputError({ source: text, message: 'expecting at least 2 name parts' });
         }
         else if (length === 2 || length === 3) {
             return new StringParser(text);
@@ -56,14 +47,13 @@ class StringParser extends Parser {
     parse(options) {
         const config = config_1.Config.merge(options);
         const names = this.raw.split(config.separator.token);
-        return new ArrayStringParser(names).parse(options);
+        return new ArrayStringParser(names).parse(config);
     }
 }
 exports.StringParser = StringParser;
 class ArrayStringParser extends Parser {
     parse(options) {
         const config = config_1.Config.merge(options);
-        const fullName = new full_name_1.FullName(config);
         const raw = this.raw.map((n) => n.trim());
         const index = utils_1.NameIndex.when(config.orderedBy, raw.length);
         const validator = new validator_1.ArrayStringValidator(index);
@@ -74,8 +64,9 @@ class ArrayStringParser extends Parser {
             validator.validate(raw);
         }
         const { firstName, lastName, middleName, prefix, suffix } = index;
-        fullName.setFirstName(new name_1.FirstName(raw[firstName]));
-        fullName.setLastName(new name_1.LastName(raw[lastName]));
+        const fullName = new full_name_1.FullName(config)
+            .setFirstName(new name_1.FirstName(raw[firstName]))
+            .setLastName(new name_1.LastName(raw[lastName]));
         if (raw.length >= 3)
             fullName.setMiddleName(raw[middleName].split(config.separator.token));
         if (raw.length >= 4)
@@ -87,39 +78,32 @@ class ArrayStringParser extends Parser {
 }
 exports.ArrayStringParser = ArrayStringParser;
 class NamaParser extends Parser {
-    constructor() {
-        super(...arguments);
-        _NamaParser_instances.add(this);
-    }
     parse(options) {
         const config = config_1.Config.merge(options);
+        const names = new Map(Object.entries(this.raw).map(([key, value]) => {
+            const namon = types_1.Namon.cast(key);
+            if (!namon) {
+                throw new error_1.InputError({
+                    source: Object.values(this.raw).join(' '),
+                    message: `unsupported key "${key}"`,
+                });
+            }
+            return [namon, value];
+        }));
         if (config.bypass) {
-            validator_1.NamaValidator.create().validateKeys(__classPrivateFieldGet(this, _NamaParser_instances, "m", _NamaParser_asNama).call(this));
+            validator_1.Validators.nama.validateKeys(names);
         }
         else {
-            validator_1.NamaValidator.create().validate(__classPrivateFieldGet(this, _NamaParser_instances, "m", _NamaParser_asNama).call(this));
+            validator_1.Validators.nama.validate(names);
         }
         return full_name_1.FullName.parse(this.raw, config);
     }
 }
 exports.NamaParser = NamaParser;
-_NamaParser_instances = new WeakSet(), _NamaParser_asNama = function _NamaParser_asNama() {
-    return new Map(Object.entries(this.raw).map(([key, value]) => {
-        const namon = types_1.Namon.cast(key);
-        if (!namon) {
-            throw new error_1.InputError({
-                source: Object.values(this.raw).join(' '),
-                message: `unsupported key "${key}"`,
-            });
-        }
-        return [namon, value];
-    }));
-};
 class ArrayNameParser extends Parser {
     parse(options) {
-        const config = config_1.Config.merge(options);
-        const fullName = new full_name_1.FullName(config);
         validator_1.ArrayNameValidator.create().validate(this.raw);
+        const fullName = new full_name_1.FullName(options);
         for (const name of this.raw) {
             if (name.isPrefix) {
                 fullName.setPrefix(name);
@@ -134,8 +118,8 @@ class ArrayNameParser extends Parser {
                 fullName.middleName.push(name);
             }
             else if (name.isLastName) {
-                const lastName = new name_1.LastName(name.value, name instanceof name_1.LastName ? name.mother : undefined, config.surname);
-                fullName.setLastName(lastName);
+                const mother = name instanceof name_1.LastName ? name.mother : undefined;
+                fullName.setLastName(new name_1.LastName(name.value, mother, fullName.config.surname));
             }
         }
         return fullName;

package/dist/lib/types.js

@@ -49,7 +49,10 @@ class Namon {
         return Namon.all.has(key);
     }
     static cast(key) {
-        return Namon.has(key) ? Namon.all.get(key) : undefined;
+        var _a;
+        const searchValue = String(key).toLowerCase();
+        const namon = (_a = Object.entries(Namon.aliases).find(([, list]) => list.includes(searchValue))) === null || _a === void 0 ? void 0 : _a[0];
+        return Namon.has(namon !== null && namon !== void 0 ? namon : '') ? Namon.all.get(key) : undefined;
     }
     toString() {
         return `Namon.${this.key}`;
@@ -72,11 +75,26 @@ Namon.all = new Map([
     [Namon.LAST_NAME.key, Namon.LAST_NAME],
     [Namon.SUFFIX.key, Namon.SUFFIX],
 ]);
+Namon.aliases = {
+    [Namon.PREFIX.key]: ['prefix', 'px', 'p'],
+    [Namon.FIRST_NAME.key]: ['firstname', 'first', 'fn', 'f'],
+    [Namon.MIDDLE_NAME.key]: ['middlename', 'middle', 'mid', 'mn', 'm'],
+    [Namon.LAST_NAME.key]: ['lastname', 'last', 'ln', 'l'],
+    [Namon.SUFFIX.key]: ['suffix', 'sx', 's'],
+};
 class Separator {
     constructor(name, token) {
         this.name = name;
         this.token = token;
     }
+    static cast(key) {
+        for (const [name, separator] of Separator.all) {
+            if (separator.token === key || name.toLowerCase() === key.toLowerCase()) {
+                return separator;
+            }
+        }
+        return undefined;
+    }
     toString() {
         return `Separator.${this.name}`;
     }

package/dist/lib/utils.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNameArray = exports.isStringArray = exports.toggleCase = exports.decapitalize = exports.capitalize = exports.NameIndex = void 0;
-const constants_1 = require("./constants");
-const name_1 = require("./name");
+exports.isStringArray = exports.toggleCase = exports.decapitalize = exports.capitalize = exports.NameIndex = void 0;
 const types_1 = require("./types");
+const constants_1 = require("./constants");
 class NameIndex {
     static get min() {
         return constants_1.MIN_NUMBER_OF_NAME_PARTS;
@@ -17,21 +16,22 @@ class NameIndex {
         this.middleName = middleName;
         this.lastName = lastName;
         this.suffix = suffix;
+        this.json = this.toJson;
     }
     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 === types_1.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();
             }
@@ -39,20 +39,20 @@ 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 {
@@ -68,37 +68,25 @@ exports.NameIndex = NameIndex;
 function capitalize(str, range = types_1.CapsRange.INITIAL) {
     if (!str || range === types_1.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 === types_1.CapsRange.INITIAL ? initial.concat(rest) : str.toUpperCase();
 }
 exports.capitalize = capitalize;
 function decapitalize(str, range = types_1.CapsRange.INITIAL) {
     if (!str || range === types_1.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 === types_1.CapsRange.INITIAL ? initial.concat(rest) : str.toLowerCase();
 }
 exports.decapitalize = decapitalize;
 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('');
 }
 exports.toggleCase = toggleCase;
 function isStringArray(value) {
     return Array.isArray(value) && value.length > 0 && value.every((e) => typeof e === 'string');
 }
 exports.isStringArray = isStringArray;
-function isNameArray(value) {
-    return Array.isArray(value) && value.length > 0 && value.every((e) => e instanceof name_1.Name);
-}
-exports.isNameArray = isNameArray;

package/dist/lib/validator.js

@@ -13,11 +13,11 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var _a, _NamonValidator_validator, _b, _FirstNameValidator_validator, _c, _MiddleNameValidator_validator, _d, _LastNameValidator_validator, _e, _NameValidator_validator, _f, _NamaValidator_validator, _ArrayNameValidator_instances, _g, _ArrayNameValidator_validator, _ArrayNameValidator_hasBasicNames;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Validators = exports.ArrayNameValidator = exports.ArrayStringValidator = exports.NamaValidator = void 0;
-const constants_1 = require("./constants");
-const error_1 = require("./error");
-const name_1 = require("./name");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
+const name_1 = require("./name");
+const error_1 = require("./error");
+const constants_1 = require("./constants");
 class ValidationRule {
 }
 ValidationRule.base = /[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]/;
@@ -25,19 +25,22 @@ ValidationRule.namon = new RegExp(`^${ValidationRule.base.source}+(([' -]${Valid
 ValidationRule.firstName = ValidationRule.namon;
 ValidationRule.middleName = new RegExp(`^${ValidationRule.base.source}+(([' -]${ValidationRule.base.source})?${ValidationRule.base.source}*)*$`);
 ValidationRule.lastName = ValidationRule.namon;
+const toNameSource = (values) => {
+    return (0, name_1.isNameArray)(values) ? values.map((n) => n.toString()).join(' ') : '';
+};
 class ArrayValidator {
     validate(values) {
         if (values.length === 0 || values.length < constants_1.MIN_NUMBER_OF_NAME_PARTS || values.length > constants_1.MAX_NUMBER_OF_NAME_PARTS) {
             throw new error_1.InputError({
                 source: values.map((n) => n.toString()),
-                message: `expecting a list of ${constants_1.MIN_NUMBER_OF_NAME_PARTS}-${constants_1.MIN_NUMBER_OF_NAME_PARTS} elements`,
+                message: `expecting a list of ${constants_1.MIN_NUMBER_OF_NAME_PARTS}-${constants_1.MAX_NUMBER_OF_NAME_PARTS} elements`,
             });
         }
     }
 }
 class NamonValidator {
     static create() {
-        return __classPrivateFieldGet(this, _a, "f", _NamonValidator_validator) || (__classPrivateFieldSet(this, _a, new this(), "f", _NamonValidator_validator));
+        return __classPrivateFieldGet(this, _a, "f", _NamonValidator_validator) || (__classPrivateFieldSet(this, _a, new _a(), "f", _NamonValidator_validator));
     }
     validate(value, type) {
         if (value instanceof name_1.Name) {
@@ -48,15 +51,12 @@ class NamonValidator {
                 throw new error_1.ValidationError({
                     source: value,
                     nameType: 'namon',
-                    message: 'invalid content',
+                    message: 'invalid name content failing namon regex',
                 });
             }
         }
         else {
-            throw new error_1.InputError({
-                source: typeof value,
-                message: 'expecting types of string | Name',
-            });
+            throw new error_1.InputError({ source: typeof value, message: 'expecting types of string or Name' });
         }
     }
 }
@@ -64,7 +64,7 @@ _a = NamonValidator;
 _NamonValidator_validator = { value: void 0 };
 class FirstNameValidator {
     static create() {
-        return __classPrivateFieldGet(this, _b, "f", _FirstNameValidator_validator) || (__classPrivateFieldSet(this, _b, new this(), "f", _FirstNameValidator_validator));
+        return __classPrivateFieldGet(this, _b, "f", _FirstNameValidator_validator) || (__classPrivateFieldSet(this, _b, new _b(), "f", _FirstNameValidator_validator));
     }
     validate(value) {
         if (value instanceof name_1.FirstName) {
@@ -75,15 +75,12 @@ class FirstNameValidator {
                 throw new error_1.ValidationError({
                     source: value,
                     nameType: 'firstName',
-                    message: 'invalid content',
+                    message: 'invalid name content failing firstName regex',
                 });
             }
         }
         else {
-            throw new error_1.InputError({
-                source: typeof value,
-                message: 'expecting types string | FirstName',
-            });
+            throw new error_1.InputError({ source: typeof value, message: 'expecting types string or FirstName' });
         }
     }
 }
@@ -91,7 +88,7 @@ _b = FirstNameValidator;
 _FirstNameValidator_validator = { value: void 0 };
 class MiddleNameValidator {
     static create() {
-        return __classPrivateFieldGet(this, _c, "f", _MiddleNameValidator_validator) || (__classPrivateFieldSet(this, _c, new this(), "f", _MiddleNameValidator_validator));
+        return __classPrivateFieldGet(this, _c, "f", _MiddleNameValidator_validator) || (__classPrivateFieldSet(this, _c, new _c(), "f", _MiddleNameValidator_validator));
     }
     validate(value) {
         if (typeof value === 'string') {
@@ -99,7 +96,7 @@ class MiddleNameValidator {
                 throw new error_1.ValidationError({
                     source: value,
                     nameType: 'middleName',
-                    message: 'invalid content',
+                    message: 'invalid name content failing middleName regex',
                 });
             }
         }
@@ -111,7 +108,7 @@ class MiddleNameValidator {
             }
             catch (error) {
                 throw new error_1.ValidationError({
-                    source: value,
+                    source: toNameSource(value),
                     nameType: 'middleName',
                     message: error === null || error === void 0 ? void 0 : error.message,
                 });
@@ -120,7 +117,7 @@ class MiddleNameValidator {
         else {
             throw new error_1.InputError({
                 source: typeof value,
-                message: 'expecting types of string | string[] | Name[]',
+                message: 'expecting types of string, string[] or Name[]',
             });
         }
     }
@@ -129,7 +126,7 @@ _c = MiddleNameValidator;
 _MiddleNameValidator_validator = { value: void 0 };
 class LastNameValidator {
     static create() {
-        return __classPrivateFieldGet(this, _d, "f", _LastNameValidator_validator) || (__classPrivateFieldSet(this, _d, new this(), "f", _LastNameValidator_validator));
+        return __classPrivateFieldGet(this, _d, "f", _LastNameValidator_validator) || (__classPrivateFieldSet(this, _d, new _d(), "f", _LastNameValidator_validator));
     }
     validate(value) {
         if (value instanceof name_1.LastName) {
@@ -140,15 +137,12 @@ class LastNameValidator {
                 throw new error_1.ValidationError({
                     source: value,
                     nameType: 'lastName',
-                    message: 'invalid content',
+                    message: 'invalid name content failing lastName regex',
                 });
             }
         }
         else {
-            throw new error_1.InputError({
-                source: typeof value,
-                message: 'expecting types string | LastName',
-            });
+            throw new error_1.InputError({ source: typeof value, message: 'expecting types string or LastName' });
         }
     }
 }
@@ -156,21 +150,21 @@ _d = LastNameValidator;
 _LastNameValidator_validator = { value: void 0 };
 class NameValidator {
     static create() {
-        return __classPrivateFieldGet(this, _e, "f", _NameValidator_validator) || (__classPrivateFieldSet(this, _e, new this(), "f", _NameValidator_validator));
+        return __classPrivateFieldGet(this, _e, "f", _NameValidator_validator) || (__classPrivateFieldSet(this, _e, new _e(), "f", _NameValidator_validator));
     }
     validate(name, type) {
         if (type && name.type !== type) {
             throw new error_1.ValidationError({
-                source: [name],
+                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 error_1.ValidationError({
-                source: [name],
+                source: name.toString(),
                 nameType: name.type.toString(),
-                message: 'invalid content',
+                message: 'invalid name content failing namon regex',
             });
         }
     }
@@ -179,18 +173,16 @@ _e = NameValidator;
 _NameValidator_validator = { value: void 0 };
 class NamaValidator {
     static create() {
-        return __classPrivateFieldGet(this, _f, "f", _NamaValidator_validator) || (__classPrivateFieldSet(this, _f, new this(), "f", _NamaValidator_validator));
+        return __classPrivateFieldGet(this, _f, "f", _NamaValidator_validator) || (__classPrivateFieldSet(this, _f, new _f(), "f", _NamaValidator_validator));
     }
     validate(value) {
         this.validateKeys(value);
         Validators.firstName.validate(value.get(types_1.Namon.FIRST_NAME));
         Validators.lastName.validate(value.get(types_1.Namon.LAST_NAME));
-        if (value.has(types_1.Namon.PREFIX)) {
+        if (value.has(types_1.Namon.PREFIX))
             Validators.namon.validate(value.get(types_1.Namon.PREFIX));
-        }
-        if (value.has(types_1.Namon.SUFFIX)) {
+        if (value.has(types_1.Namon.SUFFIX))
             Validators.namon.validate(value.get(types_1.Namon.SUFFIX));
-        }
     }
     validateKeys(nama) {
         if (!nama.size) {
@@ -199,20 +191,14 @@ class NamaValidator {
         else if (nama.size < constants_1.MIN_NUMBER_OF_NAME_PARTS || nama.size > constants_1.MAX_NUMBER_OF_NAME_PARTS) {
             throw new error_1.InputError({
                 source: [...nama.values()],
-                message: `expecting ${constants_1.MIN_NUMBER_OF_NAME_PARTS}-${constants_1.MIN_NUMBER_OF_NAME_PARTS} fields`,
+                message: `expecting ${constants_1.MIN_NUMBER_OF_NAME_PARTS}-${constants_1.MAX_NUMBER_OF_NAME_PARTS} fields`,
             });
         }
         if (!nama.has(types_1.Namon.FIRST_NAME)) {
-            throw new error_1.InputError({
-                source: [...nama.values()],
-                message: '"firstName" is a required key',
-            });
+            throw new error_1.InputError({ source: [...nama.values()], message: '"firstName" is a required key' });
         }
         if (!nama.has(types_1.Namon.LAST_NAME)) {
-            throw new error_1.InputError({
-                source: [...nama.values()],
-                message: '"lastName" is a required key',
-            });
+            throw new error_1.InputError({ source: [...nama.values()], message: '"lastName" is a required key' });
         }
     }
 }
@@ -245,18 +231,18 @@ class ArrayNameValidator {
         _ArrayNameValidator_instances.add(this);
     }
     static create() {
-        return __classPrivateFieldGet(this, _g, "f", _ArrayNameValidator_validator) || (__classPrivateFieldSet(this, _g, new this(), "f", _ArrayNameValidator_validator));
+        return __classPrivateFieldGet(this, _g, "f", _ArrayNameValidator_validator) || (__classPrivateFieldSet(this, _g, new _g(), "f", _ArrayNameValidator_validator));
     }
     validate(value) {
         if (value.length < constants_1.MIN_NUMBER_OF_NAME_PARTS) {
             throw new error_1.InputError({
-                source: value,
+                source: toNameSource(value),
                 message: `expecting at least ${constants_1.MIN_NUMBER_OF_NAME_PARTS} elements`,
             });
         }
         if (!__classPrivateFieldGet(this, _ArrayNameValidator_instances, "m", _ArrayNameValidator_hasBasicNames).call(this, value)) {
             throw new error_1.InputError({
-                source: value,
+                source: toNameSource(value),
                 message: 'both first and last names are required',
             });
         }

package/dist/types/builder.d.ts

@@ -1,6 +1,6 @@
 import { Name } from './name';
-import { Namefully } from './namefully';
 import { Config } from './config';
+import { Namefully } from './namefully';
 type VoidCallback = () => void;
 type Callback<Type, Return> = (value: Type) => Return;
 /**
@@ -44,9 +44,11 @@ declare abstract class Builder<T, I> {
  * to finally construct a complete Namefully instance.
  *
  * @example
+ * ```js
  * const builder = NameBuilder.of([Name.first('Thomas'), Name.last('Edison')]);
  * builder.add(Name.middle('Alva'));
  * console.log(builder.build()); // 'Thomas Alva Edison'
+ * ```
  */
 export declare class NameBuilder extends Builder<Name, Namefully> {
     private constructor();
@@ -66,7 +68,7 @@ export declare class NameBuilder extends Builder<Name, Namefully> {
      * Builds an instance of Namefully from the previously collected names.
      *
      * Regardless of how the names are added, both first and last names must exist
-     * to complete a fine build. Otherwise, it throws a NameException.
+     * to complete a fine build. Otherwise, it throws a NameError.
      */
     build(config?: Partial<Config>): Namefully;
 }

package/dist/types/config.d.ts

@@ -89,9 +89,6 @@ export declare class Config {
     clone(): Config;
     /** Resets the configuration by setting it back to its default values. */
     reset(): void;
-    /**
-     * Alters the name order between the first and last name, and rearrange the
-     * order of appearance of a name set.
-     */
-    updateOrder(order: NameOrder): void;
+    /** Allows the possibility to alter behavior-related options after creating a name set. */
+    update({ orderedBy, title, ending }: Partial<Pick<Config, 'orderedBy' | 'title' | 'ending'>>): void;
 }

package/dist/types/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "1.3.0";
+export declare const VERSION = "1.3.1";
 export declare const MIN_NUMBER_OF_NAME_PARTS = 2;
 export declare const MAX_NUMBER_OF_NAME_PARTS = 5;
-export declare const ALLOWED_TOKENS: string[];
+export declare const ALLOWED_FORMAT_TOKENS = " .,_-()[]<>'\"bBfFlLmMnNoOpPsS$";

package/dist/types/error.d.ts

@@ -1,13 +1,10 @@
-import { Name } from './name';
 import { Nullable } from './types';
-type NameSource = Nullable<string | string[] | Name[]>;
+type NameSource = Nullable<string | string[]>;
 interface ErrorMessage {
     source: NameSource;
     message?: string;
 }
-/**
- * The error types supported by `Namefully`.
- */
+/** The error types supported by `Namefully`. */
 export declare enum NameErrorType {
     /**
      * Thrown when a name entry/argument is incorrect.
@@ -30,9 +27,7 @@ export declare enum NameErrorType {
      * See also: `NotAllowedError`, `Namefully.format`.
      */
     NOT_ALLOWED = 2,
-    /**
-     * Thrown by any other unknown sources or unexpected situation.
-     */
+    /** Thrown by any other unknown sources or unexpected situation. */
     UNKNOWN = 3
 }
 /**
@@ -45,8 +40,8 @@ export declare enum NameErrorType {
  * program failure. Au contraire, it is expected that a programmer using this utility
  * would consider validating a name using its own business rules. That is not
  * this utility's job to guess those rules. So, the predefined `ValidationRules`
- * obey some common validation techniques when it comes to sanitizing a person
- * name. For this reason, the [Config.bypass] is set to `true` by default,
+ * obey some common validation techniques when it comes to sanitizing a personal
+ * name. For this reason, the `Config.bypass` is set to `true` by default,
  * indicating that those predefined rules should be skipped for the sake of the
  * program.
  *
@@ -55,7 +50,7 @@ export declare enum NameErrorType {
  *
  * A name error intends to provide useful information about what causes the error
  * and let the user take initiative on what happens next to the given name:
- * reconstructing it or skipping it.
+ * reconstructing it or discarding it.
  */
 export declare class NameError extends Error {
     readonly source: NameSource;
@@ -63,8 +58,8 @@ export declare class NameError extends Error {
     /**
      * Creates an error with a message describing the issue for a name source.
      * @param source name input that caused the error
-     * @param message a message describing the failure.
-     * @param type of `NameErrorType`
+     * @param message describing the failure.
+     * @param type of error via `NameErrorType`
      */
     constructor(source: NameSource, message?: string, type?: NameErrorType);
     /** The actual source input which caused the error. */
@@ -77,9 +72,9 @@ export declare class NameError extends Error {
 /**
  * An error thrown when a name source input is incorrect.
  *
- * A `Name` is a name for this utility under certain criteria (i.e., 2+ chars),
+ * A `Name` is a name for this utility under certain criteria (i.e., 1+ chars),
  * hence, a wrong input will cause this kind of error. Another common reason
- * may be a wrong key in a Json name parsing mechanism.
+ * may be a wrong key in a JSON name parsing mechanism.
  *
  * Keep in mind that this error is different from a `ValidationError`.
  */
@@ -151,7 +146,7 @@ export declare class UnknownError extends NameError {
      * Optionally, the original error revealing the true nature of the failure.
      */
     constructor(error: ErrorMessage & {
-        error?: Error;
+        origin?: Error;
     });
     toString(): string;
 }