namefully 2.0.0 → 2.0.2

package/dist/namefully.js

@@ -4,10 +4,10 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.namefully = {}));
 })(this, (function (exports) { 'use strict';
 
-    const VERSION = '2.0.0';
+    const VERSION = '2.0.2';
     const MIN_NUMBER_OF_NAME_PARTS = 2;
     const MAX_NUMBER_OF_NAME_PARTS = 5;
-    const ALLOWED_TOKENS = [
+    const ALLOWED_FORMAT_TOKENS = [
         '.',
         ',',
         ' ',
@@ -159,19 +159,19 @@
             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 === exports.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();
                 }
@@ -179,20 +179,20 @@
             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 {
@@ -203,32 +203,25 @@
                 suffix: this.suffix,
             };
         }
+        json = this.toJson;
     }
     function capitalize(str, range = exports.CapsRange.INITIAL) {
         if (!str || range === exports.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 === exports.CapsRange.INITIAL ? initial.concat(rest) : str.toUpperCase();
     }
     function decapitalize(str, range = exports.CapsRange.INITIAL) {
         if (!str || range === exports.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 === exports.CapsRange.INITIAL ? initial.concat(rest) : str.toLowerCase();
     }
     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('');
     }
     function isStringArray(value) {
         return Array.isArray(value) && value.length > 0 && value.every((e) => typeof e === 'string');
@@ -251,14 +244,11 @@
             this.name = 'NameError';
         }
         get sourceAsString() {
-            let input = '';
-            if (!this.source)
-                input = '<undefined>';
             if (typeof this.source === 'string')
-                input = this.source;
+                return this.source;
             if (isStringArray(this.source))
-                input = this.source.join(' ');
-            return input;
+                return this.source.join(' ');
+            return '<undefined>';
         }
         get hasMessage() {
             return this.message.trim().length > 0;
@@ -310,7 +300,7 @@
         origin;
         constructor(error) {
             super(error.source, error.message, exports.NameErrorType.UNKNOWN);
-            this.origin = error.error;
+            this.origin = error.origin;
             this.name = 'UnknownError';
         }
         toString() {
@@ -360,19 +350,19 @@
             return this.type === Namon.SUFFIX;
         }
         static prefix(value) {
-            return new this(value, Namon.PREFIX);
+            return new Name(value, Namon.PREFIX);
         }
         static first(value) {
-            return new this(value, Namon.FIRST_NAME);
+            return new Name(value, Namon.FIRST_NAME);
         }
         static middle(value) {
-            return new this(value, Namon.MIDDLE_NAME);
+            return new Name(value, Namon.MIDDLE_NAME);
         }
         static last(value) {
-            return new this(value, Namon.LAST_NAME);
+            return new Name(value, Namon.LAST_NAME);
         }
         static suffix(value) {
-            return new this(value, Namon.SUFFIX);
+            return new Name(value, Namon.SUFFIX);
         }
         initials() {
             return [this.initial];
@@ -392,8 +382,8 @@
             return this;
         }
         validate(name) {
-            if (name && name?.trim()?.length < 2) {
-                throw new InputError({ source: name, message: 'must be 2+ characters' });
+            if (typeof name === 'string' && name.trim().length < 1) {
+                throw new InputError({ source: name, message: 'must be 1+ characters' });
             }
         }
     }
@@ -401,7 +391,7 @@
         #more;
         constructor(value, ...more) {
             super(value, Namon.FIRST_NAME);
-            more.forEach((n) => this.validate(n));
+            more.forEach(this.validate);
             this.#more = more;
         }
         get hasMore() {
@@ -412,9 +402,8 @@
         }
         get asNames() {
             const names = [Name.first(this.value)];
-            if (this.hasMore) {
-                names.push(...this.#more.map((n) => Name.first(n)));
-            }
+            if (this.hasMore)
+                names.push(...this.#more.map(Name.first));
             return names;
         }
         get more() {
@@ -425,9 +414,8 @@
         }
         initials(withMore = false) {
             const inits = [this.initial];
-            if (withMore && this.hasMore) {
+            if (withMore && this.hasMore)
                 inits.push(...this.#more.map((n) => n[0]));
-            }
             return inits;
         }
         caps(range) {
@@ -489,34 +477,32 @@
             }
         }
         initials(format) {
-            format = format || this.format;
             const inits = [];
-            switch (format) {
-                case exports.Surname.MOTHER:
-                    if (this.#mother)
-                        inits.push(this.#mother[0]);
-                    break;
+            switch (format ?? this.format) {
                 case exports.Surname.HYPHENATED:
                 case exports.Surname.ALL:
                     inits.push(this.initial);
                     if (this.#mother)
                         inits.push(this.#mother[0]);
                     break;
-                case exports.Surname.FATHER:
+                case exports.Surname.MOTHER:
+                    if (this.#mother)
+                        inits.push(this.#mother[0]);
+                    break;
                 default:
                     inits.push(this.initial);
             }
             return inits;
         }
         caps(range) {
-            range = range || this.capsRange;
+            range ??= this.capsRange;
             this.value = capitalize(this.value, range);
             if (this.hasMother)
                 this.#mother = capitalize(this.#mother, range);
             return this;
         }
         decaps(range) {
-            range = range || this.capsRange;
+            range ??= this.capsRange;
             this.value = decapitalize(this.value, range);
             if (this.hasMother)
                 this.#mother = decapitalize(this.#mother, range);
@@ -574,7 +560,7 @@
         }
         static create(name = defaultName) {
             if (!_a.cache.has(name))
-                _a.cache.set(name, new this(name));
+                _a.cache.set(name, new _a(name));
             return _a.cache.get(name);
         }
         static merge(other) {
@@ -615,10 +601,19 @@
             this.#surname = exports.Surname.FATHER;
             _a.cache.set(this.name, this);
         }
-        updateOrder(order) {
-            if (order && order !== this.#orderedBy) {
-                _a.cache.get(this.name).#orderedBy = order;
-            }
+        updateOrder(orderedBy) {
+            this.update({ orderedBy });
+        }
+        update({ orderedBy, title, ending }) {
+            const config = _a.cache.get(this.name);
+            if (!config)
+                return;
+            if (orderedBy !== this.#orderedBy)
+                config.#orderedBy = orderedBy;
+            if (title !== this.#title)
+                config.#title = title;
+            if (ending !== this.#ending)
+                config.#ending = ending;
         }
         #genNewName(name) {
             return name === this.name || _a.cache.has(name) ? this.#genNewName(name + copyAlias) : name;
@@ -641,7 +636,7 @@
             if (values.length === 0 || values.length < MIN_NUMBER_OF_NAME_PARTS || values.length > MAX_NUMBER_OF_NAME_PARTS) {
                 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_NUMBER_OF_NAME_PARTS}-${MAX_NUMBER_OF_NAME_PARTS} elements`,
                 });
             }
         }
@@ -649,7 +644,7 @@
     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) {
@@ -660,22 +655,19 @@
                     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) {
@@ -686,22 +678,19 @@
                     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') {
@@ -709,7 +698,7 @@
                     throw new ValidationError({
                         source: value,
                         nameType: 'middleName',
-                        message: 'invalid content',
+                        message: 'invalid name content failing middleName regex',
                     });
                 }
             }
@@ -730,7 +719,7 @@
             else {
                 throw new InputError({
                     source: typeof value,
-                    message: 'expecting types of string | string[] | Name[]',
+                    message: 'expecting types of string, string[] or Name[]',
                 });
             }
         }
@@ -738,7 +727,7 @@
     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) {
@@ -749,36 +738,33 @@
                     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',
                 });
             }
         }
@@ -786,7 +772,7 @@
     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);
@@ -804,20 +790,14 @@
             else if (nama.size < MIN_NUMBER_OF_NAME_PARTS || nama.size > MAX_NUMBER_OF_NAME_PARTS) {
                 throw new InputError({
                     source: [...nama.values()],
-                    message: `expecting ${MIN_NUMBER_OF_NAME_PARTS}-${MIN_NUMBER_OF_NAME_PARTS} fields`,
+                    message: `expecting ${MIN_NUMBER_OF_NAME_PARTS}-${MAX_NUMBER_OF_NAME_PARTS} 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' });
             }
         }
     }
@@ -845,7 +825,7 @@
     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) {
@@ -911,13 +891,12 @@
         }
         static parse(json, config) {
             try {
-                const fullName = new FullName(config);
-                fullName.setPrefix(json.prefix);
-                fullName.setFirstName(json.firstName);
-                fullName.setMiddleName(json.middleName ?? []);
-                fullName.setLastName(json.lastName);
-                fullName.setSuffix(json.suffix);
-                return fullName;
+                return new FullName(config)
+                    .setPrefix(json.prefix)
+                    .setFirstName(json.firstName)
+                    .setMiddleName(json.middleName ?? [])
+                    .setLastName(json.lastName)
+                    .setSuffix(json.suffix);
             }
             catch (error) {
                 if (error instanceof NameError)
@@ -925,7 +904,7 @@
                 throw new UnknownError({
                     source: Object.values(json).join(' '),
                     message: 'could not parse JSON content',
-                    error: error instanceof Error ? error : new Error(String(error)),
+                    origin: error instanceof Error ? error : new Error(String(error)),
                 });
             }
         }
@@ -955,7 +934,7 @@
                 return this;
             if (!this.#config.bypass)
                 Validators.middleName.validate(names);
-            this.#middleName = names.map((name) => (name instanceof Name ? name : Name.middle(name)));
+            this.#middleName = names.map((n) => (n instanceof Name ? n : Name.middle(n)));
             return this;
         }
         setSuffix(name) {
@@ -984,7 +963,7 @@
             const parts = text.trim().split(Separator.SPACE.token);
             const length = parts.length;
             if (index instanceof NameIndex) {
-                const names = Object.entries(index.toJson())
+                const names = Object.entries(index.json())
                     .filter(([, position]) => position > -1 && position < length)
                     .map(([key, position]) => new Name(parts[position], Namon.all.get(key)));
                 return new ArrayNameParser(names);
@@ -1048,16 +1027,7 @@
     class NamaParser extends Parser {
         parse(options) {
             const config = Config.merge(options);
-            if (config.bypass) {
-                NamaValidator.create().validateKeys(this.#asNama());
-            }
-            else {
-                NamaValidator.create().validate(this.#asNama());
-            }
-            return FullName.parse(this.raw, config);
-        }
-        #asNama() {
-            return new Map(Object.entries(this.raw).map(([key, value]) => {
+            const names = new Map(Object.entries(this.raw).map(([key, value]) => {
                 const namon = Namon.cast(key);
                 if (!namon) {
                     throw new InputError({
@@ -1067,6 +1037,13 @@
                 }
                 return [namon, value];
             }));
+            if (config.bypass) {
+                NamaValidator.create().validateKeys(names);
+            }
+            else {
+                NamaValidator.create().validate(names);
+            }
+            return FullName.parse(this.raw, config);
         }
     }
     class ArrayNameParser extends Parser {
@@ -1182,16 +1159,16 @@
                 suffix: this.suffix,
             };
         }
+        json = this.toJson;
         has(namon) {
             return this.#fullName.has(namon);
         }
         fullName(orderedBy) {
             const sep = this.config.ending ? ',' : '';
             const names = [];
-            orderedBy = orderedBy || this.config.orderedBy;
             if (this.prefix)
                 names.push(this.prefix);
-            if (orderedBy === exports.NameOrder.FIRST_NAME) {
+            if ((orderedBy ?? this.config.orderedBy) === exports.NameOrder.FIRST_NAME) {
                 names.push(this.first, ...this.middleName(), this.last + sep);
             }
             else {
@@ -1202,7 +1179,7 @@
             return names.join(' ').trim();
         }
         birthName(orderedBy) {
-            orderedBy = orderedBy || this.config.orderedBy;
+            orderedBy ??= this.config.orderedBy;
             return orderedBy === exports.NameOrder.FIRST_NAME
                 ? [this.first, ...this.middleName(), this.last].join(' ')
                 : [this.last, this.first, ...this.middleName()].join(' ');
@@ -1217,50 +1194,42 @@
             return this.#fullName.lastName.toString(format);
         }
         initials(options) {
+            const { orderedBy = this.config.orderedBy, only = exports.NameType.BIRTH_NAME, asJson } = options ?? {};
             const firstInits = this.#fullName.firstName.initials();
-            const midInits = this.#fullName.middleName.map((n) => n.initials()[0]);
+            const midInits = this.#fullName.middleName.map((n) => n.value[0]);
             const lastInits = this.#fullName.lastName.initials();
-            if (options?.asJson)
+            if (asJson)
                 return { firstName: firstInits, middleName: midInits, lastName: lastInits };
-            const initials = [];
-            const { orderedBy = this.config.orderedBy, only = exports.NameType.BIRTH_NAME } = options ?? {};
             if (only !== exports.NameType.BIRTH_NAME) {
-                if (only === exports.NameType.FIRST_NAME) {
-                    initials.push(...firstInits);
-                }
-                else if (only === exports.NameType.MIDDLE_NAME) {
-                    initials.push(...midInits);
-                }
-                else {
-                    initials.push(...lastInits);
-                }
+                return only === exports.NameType.FIRST_NAME ? firstInits : only === exports.NameType.MIDDLE_NAME ? midInits : lastInits;
             }
             else if (orderedBy === exports.NameOrder.FIRST_NAME) {
-                initials.push(...firstInits, ...midInits, ...lastInits);
+                return [...firstInits, ...midInits, ...lastInits];
             }
             else {
-                initials.push(...lastInits, ...firstInits, ...midInits);
+                return [...lastInits, ...firstInits, ...midInits];
             }
-            return initials;
         }
         shorten(orderedBy) {
-            orderedBy = orderedBy || this.config.orderedBy;
+            orderedBy ??= this.config.orderedBy;
+            const { firstName, lastName } = this.#fullName;
             return orderedBy === exports.NameOrder.FIRST_NAME
-                ? [this.#fullName.firstName.value, this.#fullName.lastName.toString()].join(' ')
-                : [this.#fullName.lastName.toString(), this.#fullName.firstName.value].join(' ');
+                ? [firstName.value, lastName.toString()].join(' ')
+                : [lastName.toString(), firstName.value].join(' ');
         }
         flatten(options) {
             const { by = exports.Flat.MIDDLE_NAME, limit = 20, recursive = false, withMore = false, withPeriod = true, surname, } = options;
             if (this.length <= limit)
                 return this.full;
+            const { firstName, lastName, middleName } = this.#fullName;
             const sep = withPeriod ? '.' : '';
-            const fn = this.#fullName.firstName.toString();
-            const mn = this.middleName().join(' ');
-            const ln = this.#fullName.lastName.toString();
             const hasMid = this.hasMiddle;
-            const f = this.#fullName.firstName.initials(withMore).join(sep + ' ') + sep;
-            const l = this.#fullName.lastName.initials(surname).join(sep + ' ') + sep;
-            const m = hasMid ? this.#fullName.middleName.map((n) => n.initials()[0]).join(sep + ' ') + sep : '';
+            const fn = firstName.toString();
+            const mn = this.middleName().join(' ');
+            const ln = lastName.toString();
+            const f = firstName.initials(withMore).join(sep + ' ') + sep;
+            const l = lastName.initials(surname).join(sep + ' ') + sep;
+            const m = hasMid ? middleName.map((n) => n.value[0]).join(sep + ' ') + sep : '';
             let name = [];
             if (this.config.orderedBy === exports.NameOrder.FIRST_NAME) {
                 switch (by) {
@@ -1341,8 +1310,8 @@
                 pattern = 'o';
             let group = '';
             const formatted = [];
-            for (const char of pattern.split('')) {
-                if (ALLOWED_TOKENS.indexOf(char) === -1) {
+            for (const char of pattern) {
+                if (ALLOWED_FORMAT_TOKENS.indexOf(char) === -1) {
                     throw new NotAllowedError({
                         source: this.full,
                         operation: 'format',
@@ -1358,7 +1327,8 @@
             return formatted.join('').trim();
         }
         flip() {
-            this.config.updateOrder(this.config.orderedBy === exports.NameOrder.FIRST_NAME ? exports.NameOrder.LAST_NAME : exports.NameOrder.FIRST_NAME);
+            const order = this.config.orderedBy === exports.NameOrder.FIRST_NAME ? exports.NameOrder.LAST_NAME : exports.NameOrder.FIRST_NAME;
+            this.config.update({ orderedBy: order });
         }
         split(separator = /[' -]/g) {
             return this.birth.replace(separator, ' ').split(' ');
@@ -1409,7 +1379,7 @@
                 return new ArrayNameParser(raw);
             if (typeof raw === 'object')
                 return new NamaParser(raw);
-            throw new InputError({ source: raw, message: 'Cannot parse raw data. Review expected data types.' });
+            throw new InputError({ source: raw, message: 'Cannot parse raw data; review expected data types.' });
         }
         #map(char) {
             switch (char) {
@@ -1437,16 +1407,15 @@
                 case 'o':
                 case 'O':
                     return ((character) => {
-                        const sep = this.config.ending ? ',' : '', names = [];
+                        const sep = this.config.ending ? ',' : '';
+                        const names = [];
                         if (this.prefix)
                             names.push(this.prefix);
                         names.push(`${this.last},`.toUpperCase());
-                        if (this.hasMiddle) {
+                        if (this.hasMiddle)
                             names.push(this.first, this.middleName().join(' ') + sep);
-                        }
-                        else {
+                        else
                             names.push(this.first + sep);
-                        }
                         if (this.suffix)
                             names.push(this.suffix);
                         const nama = names.join(' ').trim();
@@ -1462,10 +1431,10 @@
                     return this.suffix?.toUpperCase();
                 case '$f':
                 case '$F':
-                    return this.#fullName.firstName.initials()[0];
+                    return this.#fullName.firstName.value[0];
                 case '$l':
                 case '$L':
-                    return this.#fullName.lastName.initials()[0];
+                    return this.#fullName.lastName.value[0];
                 case '$m':
                 case '$M':
                     return this.hasMiddle ? this.middle[0] : undefined;