namefully 1.3.0 → 2.0.0

package/dist/cjs/namefully.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Namefully = void 0;
+const constants_js_1 = require("./constants.js");
+const error_js_1 = require("./error.js");
+const name_js_1 = require("./name.js");
+const parser_js_1 = require("./parser.js");
+const types_js_1 = require("./types.js");
+const utils_js_1 = require("./utils.js");
+class Namefully {
+    #fullName;
+    constructor(names, options) {
+        this.#fullName = this.#toParser(names).parse(options);
+    }
+    static tryParse(text, index) {
+        try {
+            return new Namefully(parser_js_1.Parser.build(text, index));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    static async parse(text, index) {
+        return parser_js_1.Parser.buildAsync(text, index).then((parser) => new Namefully(parser));
+    }
+    get config() {
+        return this.#fullName.config;
+    }
+    get length() {
+        return this.birth.length;
+    }
+    get prefix() {
+        return this.#fullName.prefix?.toString();
+    }
+    get first() {
+        return this.firstName();
+    }
+    get middle() {
+        return this.hasMiddle ? this.middleName()[0] : undefined;
+    }
+    get hasMiddle() {
+        return this.#fullName.has(types_js_1.Namon.MIDDLE_NAME);
+    }
+    get last() {
+        return this.lastName();
+    }
+    get suffix() {
+        return this.#fullName.suffix?.toString();
+    }
+    get birth() {
+        return this.birthName();
+    }
+    get short() {
+        return this.shorten();
+    }
+    get long() {
+        return this.birth;
+    }
+    get full() {
+        return this.fullName();
+    }
+    get public() {
+        return this.format('f $l');
+    }
+    get salutation() {
+        return this.format('p l');
+    }
+    toString() {
+        return this.full;
+    }
+    get(namon) {
+        if (namon.equal(types_js_1.Namon.PREFIX))
+            return this.#fullName.prefix;
+        if (namon.equal(types_js_1.Namon.FIRST_NAME))
+            return this.#fullName.firstName;
+        if (namon.equal(types_js_1.Namon.MIDDLE_NAME))
+            return this.#fullName.middleName;
+        if (namon.equal(types_js_1.Namon.LAST_NAME))
+            return this.#fullName.lastName;
+        if (namon.equal(types_js_1.Namon.SUFFIX))
+            return this.#fullName.suffix;
+        return undefined;
+    }
+    equal(other) {
+        return this.toString() === other.toString();
+    }
+    toJson() {
+        return {
+            prefix: this.prefix,
+            firstName: this.first,
+            middleName: this.middleName(),
+            lastName: this.last,
+            suffix: this.suffix,
+        };
+    }
+    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 === types_js_1.NameOrder.FIRST_NAME) {
+            names.push(this.first, ...this.middleName(), this.last + sep);
+        }
+        else {
+            names.push(this.last, this.first, this.middleName().join(' ') + sep);
+        }
+        if (this.suffix)
+            names.push(this.suffix);
+        return names.join(' ').trim();
+    }
+    birthName(orderedBy) {
+        orderedBy = orderedBy || this.config.orderedBy;
+        return orderedBy === types_js_1.NameOrder.FIRST_NAME
+            ? [this.first, ...this.middleName(), this.last].join(' ')
+            : [this.last, this.first, ...this.middleName()].join(' ');
+    }
+    firstName(withMore = true) {
+        return this.#fullName.firstName.toString(withMore);
+    }
+    middleName() {
+        return this.#fullName.middleName.map((n) => n.value);
+    }
+    lastName(format) {
+        return this.#fullName.lastName.toString(format);
+    }
+    initials(options) {
+        const firstInits = this.#fullName.firstName.initials();
+        const midInits = this.#fullName.middleName.map((n) => n.initials()[0]);
+        const lastInits = this.#fullName.lastName.initials();
+        if (options?.asJson)
+            return { firstName: firstInits, middleName: midInits, lastName: lastInits };
+        const initials = [];
+        const { orderedBy = this.config.orderedBy, only = types_js_1.NameType.BIRTH_NAME } = options ?? {};
+        if (only !== types_js_1.NameType.BIRTH_NAME) {
+            if (only === types_js_1.NameType.FIRST_NAME) {
+                initials.push(...firstInits);
+            }
+            else if (only === types_js_1.NameType.MIDDLE_NAME) {
+                initials.push(...midInits);
+            }
+            else {
+                initials.push(...lastInits);
+            }
+        }
+        else if (orderedBy === types_js_1.NameOrder.FIRST_NAME) {
+            initials.push(...firstInits, ...midInits, ...lastInits);
+        }
+        else {
+            initials.push(...lastInits, ...firstInits, ...midInits);
+        }
+        return initials;
+    }
+    shorten(orderedBy) {
+        orderedBy = orderedBy || this.config.orderedBy;
+        return orderedBy === types_js_1.NameOrder.FIRST_NAME
+            ? [this.#fullName.firstName.value, this.#fullName.lastName.toString()].join(' ')
+            : [this.#fullName.lastName.toString(), this.#fullName.firstName.value].join(' ');
+    }
+    flatten(options) {
+        const { by = types_js_1.Flat.MIDDLE_NAME, limit = 20, recursive = false, withMore = false, withPeriod = true, surname, } = options;
+        if (this.length <= limit)
+            return this.full;
+        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 : '';
+        let name = [];
+        if (this.config.orderedBy === types_js_1.NameOrder.FIRST_NAME) {
+            switch (by) {
+                case types_js_1.Flat.FIRST_NAME:
+                    name = hasMid ? [f, mn, ln] : [f, ln];
+                    break;
+                case types_js_1.Flat.LAST_NAME:
+                    name = hasMid ? [fn, mn, l] : [fn, l];
+                    break;
+                case types_js_1.Flat.MIDDLE_NAME:
+                    name = hasMid ? [fn, m, ln] : [fn, ln];
+                    break;
+                case types_js_1.Flat.FIRST_MID:
+                    name = hasMid ? [f, m, ln] : [f, ln];
+                    break;
+                case types_js_1.Flat.MID_LAST:
+                    name = hasMid ? [fn, m, l] : [fn, l];
+                    break;
+                case types_js_1.Flat.ALL:
+                    name = hasMid ? [f, m, l] : [f, l];
+                    break;
+            }
+        }
+        else {
+            switch (by) {
+                case types_js_1.Flat.FIRST_NAME:
+                    name = hasMid ? [ln, f, mn] : [ln, f];
+                    break;
+                case types_js_1.Flat.LAST_NAME:
+                    name = hasMid ? [l, fn, mn] : [l, fn];
+                    break;
+                case types_js_1.Flat.MIDDLE_NAME:
+                    name = hasMid ? [ln, fn, m] : [ln, fn];
+                    break;
+                case types_js_1.Flat.FIRST_MID:
+                    name = hasMid ? [ln, f, m] : [ln, f];
+                    break;
+                case types_js_1.Flat.MID_LAST:
+                    name = hasMid ? [l, fn, m] : [l, fn];
+                    break;
+                case types_js_1.Flat.ALL:
+                    name = hasMid ? [l, f, m] : [l, f];
+                    break;
+            }
+        }
+        const flat = name.join(' ');
+        if (recursive && flat.length > limit) {
+            const next = by === types_js_1.Flat.FIRST_NAME
+                ? types_js_1.Flat.MIDDLE_NAME
+                : by === types_js_1.Flat.MIDDLE_NAME
+                    ? types_js_1.Flat.LAST_NAME
+                    : by === types_js_1.Flat.LAST_NAME
+                        ? types_js_1.Flat.FIRST_MID
+                        : by === types_js_1.Flat.FIRST_MID
+                            ? types_js_1.Flat.MID_LAST
+                            : by === types_js_1.Flat.MID_LAST
+                                ? types_js_1.Flat.ALL
+                                : by === types_js_1.Flat.ALL
+                                    ? types_js_1.Flat.ALL
+                                    : by;
+            if (next === by)
+                return flat;
+            return this.flatten({ ...options, by: next });
+        }
+        return flat;
+    }
+    zip(by = types_js_1.Flat.MID_LAST, withPeriod = true) {
+        return this.flatten({ limit: 0, by, withPeriod });
+    }
+    format(pattern) {
+        if (pattern === 'short')
+            return this.short;
+        if (pattern === 'long')
+            return this.long;
+        if (pattern === 'public')
+            return this.public;
+        if (pattern === 'official')
+            pattern = 'o';
+        let group = '';
+        const formatted = [];
+        for (const char of pattern.split('')) {
+            if (constants_js_1.ALLOWED_TOKENS.indexOf(char) === -1) {
+                throw new error_js_1.NotAllowedError({
+                    source: this.full,
+                    operation: 'format',
+                    message: `unsupported character <${char}> from ${pattern}.`,
+                });
+            }
+            group += char;
+            if (char === '$')
+                continue;
+            formatted.push(this.#map(group) ?? '');
+            group = '';
+        }
+        return formatted.join('').trim();
+    }
+    flip() {
+        this.config.updateOrder(this.config.orderedBy === types_js_1.NameOrder.FIRST_NAME ? types_js_1.NameOrder.LAST_NAME : types_js_1.NameOrder.FIRST_NAME);
+    }
+    split(separator = /[' -]/g) {
+        return this.birth.replace(separator, ' ').split(' ');
+    }
+    join(separator = '') {
+        return this.split().join(separator);
+    }
+    toUpperCase() {
+        return this.birth.toUpperCase();
+    }
+    toLowerCase() {
+        return this.birth.toLowerCase();
+    }
+    toCamelCase() {
+        return (0, utils_js_1.decapitalize)(this.toPascalCase());
+    }
+    toPascalCase() {
+        return this.split()
+            .map((n) => (0, utils_js_1.capitalize)(n))
+            .join('');
+    }
+    toSnakeCase() {
+        return this.split()
+            .map((n) => n.toLowerCase())
+            .join('_');
+    }
+    toHyphenCase() {
+        return this.split()
+            .map((n) => n.toLowerCase())
+            .join('-');
+    }
+    toDotCase() {
+        return this.split()
+            .map((n) => n.toLowerCase())
+            .join('.');
+    }
+    toToggleCase() {
+        return (0, utils_js_1.toggleCase)(this.birth);
+    }
+    #toParser(raw) {
+        if (raw instanceof parser_js_1.Parser)
+            return raw;
+        if (typeof raw === 'string')
+            return new parser_js_1.StringParser(raw);
+        if ((0, utils_js_1.isStringArray)(raw))
+            return new parser_js_1.ArrayStringParser(raw);
+        if ((0, name_js_1.isNameArray)(raw))
+            return new parser_js_1.ArrayNameParser(raw);
+        if (typeof raw === 'object')
+            return new parser_js_1.NamaParser(raw);
+        throw new error_js_1.InputError({ source: raw, message: 'Cannot parse raw data. Review expected data types.' });
+    }
+    #map(char) {
+        switch (char) {
+            case '.':
+            case ',':
+            case ' ':
+            case '-':
+            case '_':
+                return char;
+            case 'b':
+                return this.birth;
+            case 'B':
+                return this.birth.toUpperCase();
+            case 'f':
+                return this.first;
+            case 'F':
+                return this.first.toUpperCase();
+            case 'l':
+                return this.last;
+            case 'L':
+                return this.last.toUpperCase();
+            case 'm':
+            case 'M':
+                return char === 'm' ? this.middleName().join(' ') : this.middleName().join(' ').toUpperCase();
+            case 'o':
+            case 'O':
+                return ((character) => {
+                    const sep = this.config.ending ? ',' : '', names = [];
+                    if (this.prefix)
+                        names.push(this.prefix);
+                    names.push(`${this.last},`.toUpperCase());
+                    if (this.hasMiddle) {
+                        names.push(this.first, this.middleName().join(' ') + sep);
+                    }
+                    else {
+                        names.push(this.first + sep);
+                    }
+                    if (this.suffix)
+                        names.push(this.suffix);
+                    const nama = names.join(' ').trim();
+                    return character === 'o' ? nama : nama.toUpperCase();
+                })(char);
+            case 'p':
+                return this.prefix;
+            case 'P':
+                return this.prefix?.toUpperCase();
+            case 's':
+                return this.suffix;
+            case 'S':
+                return this.suffix?.toUpperCase();
+            case '$f':
+            case '$F':
+                return this.#fullName.firstName.initials()[0];
+            case '$l':
+            case '$L':
+                return this.#fullName.lastName.initials()[0];
+            case '$m':
+            case '$M':
+                return this.hasMiddle ? this.middle[0] : undefined;
+            default:
+                return undefined;
+        }
+    }
+}
+exports.Namefully = Namefully;
+exports.default = (names, options) => {
+    return new Namefully(names, options);
+};

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/cjs/parser.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayNameParser = exports.NamaParser = exports.ArrayStringParser = exports.StringParser = exports.Parser = void 0;
+const fullname_js_1 = require("./fullname.js");
+const config_js_1 = require("./config.js");
+const utils_js_1 = require("./utils.js");
+const validator_js_1 = require("./validator.js");
+const name_js_1 = require("./name.js");
+const types_js_1 = require("./types.js");
+const error_js_1 = require("./error.js");
+class Parser {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    static build(text, index) {
+        const parts = text.trim().split(types_js_1.Separator.SPACE.token);
+        const length = parts.length;
+        if (index instanceof utils_js_1.NameIndex) {
+            const names = Object.entries(index.toJson())
+                .filter(([, position]) => position > -1 && position < length)
+                .map(([key, position]) => new name_js_1.Name(parts[position], types_js_1.Namon.all.get(key)));
+            return new ArrayNameParser(names);
+        }
+        if (length < 2) {
+            throw new error_js_1.InputError({
+                source: text,
+                message: 'cannot build from invalid input',
+            });
+        }
+        else if (length === 2 || length === 3) {
+            return new StringParser(text);
+        }
+        else {
+            const last = parts.pop();
+            const [first, ...middles] = parts;
+            return new ArrayStringParser([first, middles.join(' '), last]);
+        }
+    }
+    static buildAsync(text, index) {
+        try {
+            return Promise.resolve(Parser.build(text, index));
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+}
+exports.Parser = Parser;
+class StringParser extends Parser {
+    parse(options) {
+        const config = config_js_1.Config.merge(options);
+        const names = this.raw.split(config.separator.token);
+        return new ArrayStringParser(names).parse(options);
+    }
+}
+exports.StringParser = StringParser;
+class ArrayStringParser extends Parser {
+    parse(options) {
+        const config = config_js_1.Config.merge(options);
+        const fullName = new fullname_js_1.FullName(config);
+        const raw = this.raw.map((n) => n.trim());
+        const index = utils_js_1.NameIndex.when(config.orderedBy, raw.length);
+        const validator = new validator_js_1.ArrayStringValidator(index);
+        if (config.bypass) {
+            validator.validateIndex(raw);
+        }
+        else {
+            validator.validate(raw);
+        }
+        const { firstName, lastName, middleName, prefix, suffix } = index;
+        fullName.setFirstName(new name_js_1.FirstName(raw[firstName]));
+        fullName.setLastName(new name_js_1.LastName(raw[lastName]));
+        if (raw.length >= 3)
+            fullName.setMiddleName(raw[middleName].split(config.separator.token));
+        if (raw.length >= 4)
+            fullName.setPrefix(name_js_1.Name.prefix(raw[prefix]));
+        if (raw.length === 5)
+            fullName.setSuffix(name_js_1.Name.suffix(raw[suffix]));
+        return fullName;
+    }
+}
+exports.ArrayStringParser = ArrayStringParser;
+class NamaParser extends Parser {
+    parse(options) {
+        const config = config_js_1.Config.merge(options);
+        if (config.bypass) {
+            validator_js_1.NamaValidator.create().validateKeys(this.#asNama());
+        }
+        else {
+            validator_js_1.NamaValidator.create().validate(this.#asNama());
+        }
+        return fullname_js_1.FullName.parse(this.raw, config);
+    }
+    #asNama() {
+        return new Map(Object.entries(this.raw).map(([key, value]) => {
+            const namon = types_js_1.Namon.cast(key);
+            if (!namon) {
+                throw new error_js_1.InputError({
+                    source: Object.values(this.raw).join(' '),
+                    message: `unsupported key "${key}"`,
+                });
+            }
+            return [namon, value];
+        }));
+    }
+}
+exports.NamaParser = NamaParser;
+class ArrayNameParser extends Parser {
+    parse(options) {
+        const config = config_js_1.Config.merge(options);
+        const fullName = new fullname_js_1.FullName(config);
+        validator_js_1.ArrayNameValidator.create().validate(this.raw);
+        for (const name of this.raw) {
+            if (name.isPrefix) {
+                fullName.setPrefix(name);
+            }
+            else if (name.isSuffix) {
+                fullName.setSuffix(name);
+            }
+            else if (name.isFirstName) {
+                fullName.setFirstName(name instanceof name_js_1.FirstName ? name : new name_js_1.FirstName(name.value));
+            }
+            else if (name.isMiddleName) {
+                fullName.middleName.push(name);
+            }
+            else if (name.isLastName) {
+                const lastName = new name_js_1.LastName(name.value, name instanceof name_js_1.LastName ? name.mother : undefined, config.surname);
+                fullName.setLastName(lastName);
+            }
+        }
+        return fullName;
+    }
+}
+exports.ArrayNameParser = ArrayNameParser;

package/dist/{lib → cjs}/types.js

@@ -41,6 +41,21 @@ var CapsRange;
     CapsRange[CapsRange["ALL"] = 2] = "ALL";
 })(CapsRange || (exports.CapsRange = CapsRange = {}));
 class Namon {
+    index;
+    key;
+    static PREFIX = new Namon(0, 'prefix');
+    static FIRST_NAME = new Namon(1, 'firstName');
+    static MIDDLE_NAME = new Namon(2, 'middleName');
+    static LAST_NAME = new Namon(3, 'lastName');
+    static SUFFIX = new Namon(4, 'suffix');
+    static values = [Namon.PREFIX, Namon.FIRST_NAME, Namon.MIDDLE_NAME, Namon.LAST_NAME, Namon.SUFFIX];
+    static all = new Map([
+        [Namon.PREFIX.key, Namon.PREFIX],
+        [Namon.FIRST_NAME.key, Namon.FIRST_NAME],
+        [Namon.MIDDLE_NAME.key, Namon.MIDDLE_NAME],
+        [Namon.LAST_NAME.key, Namon.LAST_NAME],
+        [Namon.SUFFIX.key, Namon.SUFFIX],
+    ]);
     constructor(index, key) {
         this.index = index;
         this.key = key;
@@ -59,20 +74,32 @@ class Namon {
     }
 }
 exports.Namon = Namon;
-Namon.PREFIX = new Namon(0, 'prefix');
-Namon.FIRST_NAME = new Namon(1, 'firstName');
-Namon.MIDDLE_NAME = new Namon(2, 'middleName');
-Namon.LAST_NAME = new Namon(3, 'lastName');
-Namon.SUFFIX = new Namon(4, 'suffix');
-Namon.values = [Namon.PREFIX, Namon.FIRST_NAME, Namon.MIDDLE_NAME, Namon.LAST_NAME, Namon.SUFFIX];
-Namon.all = new Map([
-    [Namon.PREFIX.key, Namon.PREFIX],
-    [Namon.FIRST_NAME.key, Namon.FIRST_NAME],
-    [Namon.MIDDLE_NAME.key, Namon.MIDDLE_NAME],
-    [Namon.LAST_NAME.key, Namon.LAST_NAME],
-    [Namon.SUFFIX.key, Namon.SUFFIX],
-]);
 class Separator {
+    name;
+    token;
+    static COMMA = new Separator('comma', ',');
+    static COLON = new Separator('colon', ':');
+    static DOUBLE_QUOTE = new Separator('doubleQuote', '"');
+    static EMPTY = new Separator('empty', '');
+    static HYPHEN = new Separator('hyphen', '-');
+    static PERIOD = new Separator('period', '.');
+    static SEMI_COLON = new Separator('semiColon', ';');
+    static SINGLE_QUOTE = new Separator('singleQuote', `'`);
+    static SPACE = new Separator('space', ' ');
+    static UNDERSCORE = new Separator('underscore', '_');
+    static all = new Map([
+        [Separator.COMMA.name, Separator.COMMA],
+        [Separator.COLON.name, Separator.COLON],
+        [Separator.DOUBLE_QUOTE.name, Separator.DOUBLE_QUOTE],
+        [Separator.EMPTY.name, Separator.EMPTY],
+        [Separator.HYPHEN.name, Separator.HYPHEN],
+        [Separator.PERIOD.name, Separator.PERIOD],
+        [Separator.SEMI_COLON.name, Separator.SEMI_COLON],
+        [Separator.SINGLE_QUOTE.name, Separator.SINGLE_QUOTE],
+        [Separator.SPACE.name, Separator.SPACE],
+        [Separator.UNDERSCORE.name, Separator.UNDERSCORE],
+    ]);
+    static tokens = [...Separator.all.values()].map((s) => s.token);
     constructor(name, token) {
         this.name = name;
         this.token = token;
@@ -82,26 +109,3 @@ class Separator {
     }
 }
 exports.Separator = Separator;
-Separator.COMMA = new Separator('comma', ',');
-Separator.COLON = new Separator('colon', ':');
-Separator.DOUBLE_QUOTE = new Separator('doubleQuote', '"');
-Separator.EMPTY = new Separator('empty', '');
-Separator.HYPHEN = new Separator('hyphen', '-');
-Separator.PERIOD = new Separator('period', '.');
-Separator.SEMI_COLON = new Separator('semiColon', ';');
-Separator.SINGLE_QUOTE = new Separator('singleQuote', `'`);
-Separator.SPACE = new Separator('space', ' ');
-Separator.UNDERSCORE = new Separator('underscore', '_');
-Separator.all = new Map([
-    [Separator.COMMA.name, Separator.COMMA],
-    [Separator.COLON.name, Separator.COLON],
-    [Separator.DOUBLE_QUOTE.name, Separator.DOUBLE_QUOTE],
-    [Separator.EMPTY.name, Separator.EMPTY],
-    [Separator.HYPHEN.name, Separator.HYPHEN],
-    [Separator.PERIOD.name, Separator.PERIOD],
-    [Separator.SEMI_COLON.name, Separator.SEMI_COLON],
-    [Separator.SINGLE_QUOTE.name, Separator.SINGLE_QUOTE],
-    [Separator.SPACE.name, Separator.SPACE],
-    [Separator.UNDERSCORE.name, Separator.UNDERSCORE],
-]);
-Separator.tokens = [...Separator.all.values()].map((s) => s.token);

package/dist/{lib → cjs}/utils.js

@@ -1,15 +1,19 @@
 "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");
-const types_1 = require("./types");
+exports.isStringArray = exports.toggleCase = exports.decapitalize = exports.capitalize = exports.NameIndex = void 0;
+const constants_js_1 = require("./constants.js");
+const types_js_1 = require("./types.js");
 class NameIndex {
+    prefix;
+    firstName;
+    middleName;
+    lastName;
+    suffix;
     static get min() {
-        return constants_1.MIN_NUMBER_OF_NAME_PARTS;
+        return constants_js_1.MIN_NUMBER_OF_NAME_PARTS;
     }
     static get max() {
-        return constants_1.MAX_NUMBER_OF_NAME_PARTS;
+        return constants_js_1.MAX_NUMBER_OF_NAME_PARTS;
     }
     constructor(prefix, firstName, middleName, lastName, suffix) {
         this.prefix = prefix;
@@ -22,7 +26,7 @@ class NameIndex {
         return new this(-1, 0, -1, 1, -1);
     }
     static when(order, count = 2) {
-        if (order === types_1.NameOrder.FIRST_NAME) {
+        if (order === types_js_1.NameOrder.FIRST_NAME) {
             switch (count) {
                 case 2:
                     return new this(-1, 0, -1, 1, -1);
@@ -65,20 +69,20 @@ class NameIndex {
     }
 }
 exports.NameIndex = NameIndex;
-function capitalize(str, range = types_1.CapsRange.INITIAL) {
-    if (!str || range === types_1.CapsRange.NONE)
+function capitalize(str, range = types_js_1.CapsRange.INITIAL) {
+    if (!str || range === types_js_1.CapsRange.NONE)
         return str;
     const initial = str[0].toUpperCase();
     const rest = str.slice(1).toLowerCase();
-    return range === types_1.CapsRange.INITIAL ? initial.concat(rest) : str.toUpperCase();
+    return range === types_js_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)
+function decapitalize(str, range = types_js_1.CapsRange.INITIAL) {
+    if (!str || range === types_js_1.CapsRange.NONE)
         return str;
     const initial = str[0].toLowerCase();
     const rest = str.slice(1);
-    return range === types_1.CapsRange.INITIAL ? initial.concat(rest) : str.toLowerCase();
+    return range === types_js_1.CapsRange.INITIAL ? initial.concat(rest) : str.toLowerCase();
 }
 exports.decapitalize = decapitalize;
 function toggleCase(str) {
@@ -98,7 +102,3 @@ 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;