namefully 1.1.0 → 1.2.1

package/dist/lib/parser.js

@@ -0,0 +1,138 @@
+"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");
+class Parser {
+    constructor(raw) {
+        this.raw = raw;
+    }
+    static build(text) {
+        const parts = text.trim().split(types_1.Separator.SPACE.token);
+        const length = parts.length;
+        if (length < 2) {
+            throw new error_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) {
+        try {
+            return Promise.resolve(Parser.build(text));
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+}
+exports.Parser = Parser;
+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);
+    }
+}
+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);
+        if (config.bypass) {
+            validator.validateIndex(raw);
+        }
+        else {
+            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]));
+        if (raw.length >= 3)
+            fullName.setMiddleName(raw[middleName].split(config.separator.token));
+        if (raw.length >= 4)
+            fullName.setPrefix(name_1.Name.prefix(raw[prefix]));
+        if (raw.length === 5)
+            fullName.setSuffix(name_1.Name.suffix(raw[suffix]));
+        return fullName;
+    }
+}
+exports.ArrayStringParser = ArrayStringParser;
+class NamaParser extends Parser {
+    constructor() {
+        super(...arguments);
+        _NamaParser_instances.add(this);
+    }
+    parse(options) {
+        const config = config_1.Config.merge(options);
+        if (config.bypass) {
+            validator_1.NamaValidator.create().validateKeys(__classPrivateFieldGet(this, _NamaParser_instances, "m", _NamaParser_asNama).call(this));
+        }
+        else {
+            validator_1.NamaValidator.create().validate(__classPrivateFieldGet(this, _NamaParser_instances, "m", _NamaParser_asNama).call(this));
+        }
+        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);
+        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_1.FirstName ? name : new name_1.FirstName(name.value));
+            }
+            else if (name.isMiddleName) {
+                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);
+            }
+        }
+        return fullName;
+    }
+}
+exports.ArrayNameParser = ArrayNameParser;

package/dist/lib/types.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Separator = exports.Namon = exports.CapsRange = exports.Flat = exports.NameType = exports.NameOrder = exports.Surname = exports.Title = void 0;
+var Title;
+(function (Title) {
+    Title["US"] = "US";
+    Title["UK"] = "UK";
+})(Title || (exports.Title = Title = {}));
+var Surname;
+(function (Surname) {
+    Surname["FATHER"] = "father";
+    Surname["MOTHER"] = "mother";
+    Surname["HYPHENATED"] = "hyphenated";
+    Surname["ALL"] = "all";
+})(Surname || (exports.Surname = Surname = {}));
+var NameOrder;
+(function (NameOrder) {
+    NameOrder["FIRST_NAME"] = "firstName";
+    NameOrder["LAST_NAME"] = "lastName";
+})(NameOrder || (exports.NameOrder = NameOrder = {}));
+var NameType;
+(function (NameType) {
+    NameType["FIRST_NAME"] = "firstName";
+    NameType["MIDDLE_NAME"] = "middleName";
+    NameType["LAST_NAME"] = "lastName";
+    NameType["BIRTH_NAME"] = "birthName";
+})(NameType || (exports.NameType = NameType = {}));
+var Flat;
+(function (Flat) {
+    Flat["FIRST_NAME"] = "firstName";
+    Flat["MIDDLE_NAME"] = "middleName";
+    Flat["LAST_NAME"] = "lastName";
+    Flat["FIRST_MID"] = "firstMid";
+    Flat["MID_LAST"] = "midLast";
+    Flat["ALL"] = "all";
+})(Flat || (exports.Flat = Flat = {}));
+var CapsRange;
+(function (CapsRange) {
+    CapsRange[CapsRange["NONE"] = 0] = "NONE";
+    CapsRange[CapsRange["INITIAL"] = 1] = "INITIAL";
+    CapsRange[CapsRange["ALL"] = 2] = "ALL";
+})(CapsRange || (exports.CapsRange = CapsRange = {}));
+class Namon {
+    constructor(index, key) {
+        this.index = index;
+        this.key = key;
+    }
+    static has(key) {
+        return Namon.all.has(key);
+    }
+    static cast(key) {
+        return Namon.has(key) ? Namon.all.get(key) : undefined;
+    }
+    toString() {
+        return `Namon.${this.key}`;
+    }
+    equal(other) {
+        return other instanceof Namon && other.index === this.index && other.key === this.key;
+    }
+}
+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 {
+    constructor(name, token) {
+        this.name = name;
+        this.token = token;
+    }
+    toString() {
+        return `Separator.${this.name}`;
+    }
+}
+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/utils.js

@@ -0,0 +1,92 @@
+"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");
+class NameIndex {
+    static get min() {
+        return constants_1.MIN_NUMBER_OF_NAME_PARTS;
+    }
+    static get max() {
+        return constants_1.MAX_NUMBER_OF_NAME_PARTS;
+    }
+    constructor(prefix, firstName, middleName, lastName, suffix) {
+        this.prefix = prefix;
+        this.firstName = firstName;
+        this.middleName = middleName;
+        this.lastName = lastName;
+        this.suffix = suffix;
+    }
+    static base() {
+        return new this(-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);
+                case 3:
+                    return new this(-1, 0, 1, 2, -1);
+                case 4:
+                    return new this(0, 1, 2, 3, -1);
+                case 5:
+                    return new this(0, 1, 2, 3, 4);
+                default:
+                    return NameIndex.base();
+            }
+        }
+        else {
+            switch (count) {
+                case 2:
+                    return new this(-1, 1, -1, 0, -1);
+                case 3:
+                    return new this(-1, 1, 2, 0, -1);
+                case 4:
+                    return new this(0, 2, 3, 1, -1);
+                case 5:
+                    return new this(0, 2, 3, 1, 4);
+                default:
+                    return NameIndex.base();
+            }
+        }
+    }
+}
+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();
+    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);
+    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('');
+}
+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

@@ -0,0 +1,301 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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");
+class ValidationRule {
+}
+ValidationRule.base = /[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]/;
+ValidationRule.namon = new RegExp(`^${ValidationRule.base.source}+(([' -]${ValidationRule.base.source})?${ValidationRule.base.source}*)*$`);
+ValidationRule.firstName = ValidationRule.namon;
+ValidationRule.middleName = new RegExp(`^${ValidationRule.base.source}+(([' -]${ValidationRule.base.source})?${ValidationRule.base.source}*)*$`);
+ValidationRule.lastName = ValidationRule.namon;
+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`,
+            });
+        }
+    }
+}
+class NamonValidator {
+    static create() {
+        return __classPrivateFieldGet(this, _a, "f", _NamonValidator_validator) || (__classPrivateFieldSet(this, _a, new this(), "f", _NamonValidator_validator));
+    }
+    validate(value, type) {
+        if (value instanceof name_1.Name) {
+            NameValidator.create().validate(value, type);
+        }
+        else if (typeof value === 'string') {
+            if (!ValidationRule.namon.test(value)) {
+                throw new error_1.ValidationError({
+                    source: value,
+                    nameType: 'namon',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else {
+            throw new error_1.InputError({
+                source: typeof value,
+                message: 'expecting types of string | Name',
+            });
+        }
+    }
+}
+_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));
+    }
+    validate(value) {
+        if (value instanceof name_1.FirstName) {
+            value.asNames.forEach((name) => this.validate(name.value));
+        }
+        else if (typeof value === 'string') {
+            if (!ValidationRule.firstName.test(value)) {
+                throw new error_1.ValidationError({
+                    source: value,
+                    nameType: 'firstName',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else {
+            throw new error_1.InputError({
+                source: typeof value,
+                message: 'expecting types string | FirstName',
+            });
+        }
+    }
+}
+_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));
+    }
+    validate(value) {
+        if (typeof value === 'string') {
+            if (!ValidationRule.middleName.test(value)) {
+                throw new error_1.ValidationError({
+                    source: value,
+                    nameType: 'middleName',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else if (Array.isArray(value)) {
+            try {
+                const validator = NamonValidator.create();
+                for (const name of value)
+                    validator.validate(name, types_1.Namon.MIDDLE_NAME);
+            }
+            catch (error) {
+                throw new error_1.ValidationError({
+                    source: value,
+                    nameType: 'middleName',
+                    message: error === null || error === void 0 ? void 0 : error.message,
+                });
+            }
+        }
+        else {
+            throw new error_1.InputError({
+                source: typeof value,
+                message: 'expecting types of string | string[] | Name[]',
+            });
+        }
+    }
+}
+_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));
+    }
+    validate(value) {
+        if (value instanceof name_1.LastName) {
+            value.asNames.forEach((name) => this.validate(name.value));
+        }
+        else if (typeof value === 'string') {
+            if (!ValidationRule.lastName.test(value)) {
+                throw new error_1.ValidationError({
+                    source: value,
+                    nameType: 'lastName',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else {
+            throw new error_1.InputError({
+                source: typeof value,
+                message: 'expecting types string | LastName',
+            });
+        }
+    }
+}
+_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));
+    }
+    validate(name, type) {
+        if (type && name.type !== type) {
+            throw new error_1.ValidationError({
+                source: [name],
+                nameType: name.type.toString(),
+                message: 'wrong type',
+            });
+        }
+        if (!ValidationRule.namon.test(name.value)) {
+            throw new error_1.ValidationError({
+                source: [name],
+                nameType: name.type.toString(),
+                message: 'invalid content',
+            });
+        }
+    }
+}
+_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));
+    }
+    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)) {
+            Validators.namon.validate(value.get(types_1.Namon.PREFIX));
+        }
+        if (value.has(types_1.Namon.SUFFIX)) {
+            Validators.namon.validate(value.get(types_1.Namon.SUFFIX));
+        }
+    }
+    validateKeys(nama) {
+        if (!nama.size) {
+            throw new error_1.InputError({ source: undefined, message: 'Map<k,v> must not be empty' });
+        }
+        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`,
+            });
+        }
+        if (!nama.has(types_1.Namon.FIRST_NAME)) {
+            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',
+            });
+        }
+    }
+}
+exports.NamaValidator = NamaValidator;
+_f = NamaValidator;
+_NamaValidator_validator = { value: void 0 };
+class ArrayStringValidator extends ArrayValidator {
+    constructor(index = utils_1.NameIndex.base()) {
+        super();
+        this.index = index;
+    }
+    validate(values) {
+        this.validateIndex(values);
+        switch (values.length) {
+            case 2:
+                Validators.firstName.validate(values[this.index.firstName]);
+                Validators.lastName.validate(values[this.index.lastName]);
+                break;
+            case 3:
+                Validators.firstName.validate(values[this.index.firstName]);
+                Validators.middleName.validate(values[this.index.middleName]);
+                Validators.lastName.validate(values[this.index.lastName]);
+                break;
+            case 4:
+                Validators.namon.validate(values[this.index.prefix]);
+                Validators.firstName.validate(values[this.index.firstName]);
+                Validators.middleName.validate(values[this.index.middleName]);
+                Validators.lastName.validate(values[this.index.lastName]);
+                break;
+            case 5:
+                Validators.namon.validate(values[this.index.prefix]);
+                Validators.firstName.validate(values[this.index.firstName]);
+                Validators.middleName.validate(values[this.index.middleName]);
+                Validators.lastName.validate(values[this.index.lastName]);
+                Validators.namon.validate(values[this.index.suffix]);
+                break;
+        }
+    }
+    validateIndex(values) {
+        super.validate(values);
+    }
+}
+exports.ArrayStringValidator = ArrayStringValidator;
+class ArrayNameValidator {
+    constructor() {
+        _ArrayNameValidator_instances.add(this);
+    }
+    static create() {
+        return __classPrivateFieldGet(this, _g, "f", _ArrayNameValidator_validator) || (__classPrivateFieldSet(this, _g, new this(), "f", _ArrayNameValidator_validator));
+    }
+    validate(value) {
+        if (value.length < constants_1.MIN_NUMBER_OF_NAME_PARTS) {
+            throw new error_1.InputError({
+                source: 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,
+                message: 'both first and last names are required',
+            });
+        }
+    }
+}
+exports.ArrayNameValidator = ArrayNameValidator;
+_g = ArrayNameValidator, _ArrayNameValidator_instances = new WeakSet(), _ArrayNameValidator_hasBasicNames = function _ArrayNameValidator_hasBasicNames(names) {
+    const accumulator = {};
+    for (const name of names) {
+        if (name.isFirstName || name.isLastName) {
+            accumulator[name.type.key] = name.toString();
+        }
+    }
+    return Object.keys(accumulator).length === constants_1.MIN_NUMBER_OF_NAME_PARTS;
+};
+_ArrayNameValidator_validator = { value: void 0 };
+class Validators {
+}
+exports.Validators = Validators;
+Validators.namon = NamonValidator.create();
+Validators.nama = NamaValidator.create();
+Validators.prefix = NamonValidator.create();
+Validators.firstName = FirstNameValidator.create();
+Validators.middleName = MiddleNameValidator.create();
+Validators.lastName = LastNameValidator.create();
+Validators.suffix = NamonValidator.create();