namefully 1.3.0 → 2.0.0

package/dist/esm/utils.js

@@ -0,0 +1,96 @@
+import { MIN_NUMBER_OF_NAME_PARTS, MAX_NUMBER_OF_NAME_PARTS } from './constants.js';
+import { NameOrder, CapsRange } from './types.js';
+export class NameIndex {
+    prefix;
+    firstName;
+    middleName;
+    lastName;
+    suffix;
+    static get min() {
+        return MIN_NUMBER_OF_NAME_PARTS;
+    }
+    static get max() {
+        return 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 === 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();
+            }
+        }
+    }
+    static only({ prefix = -1, firstName, middleName = -1, lastName, suffix = -1 }) {
+        return new this(prefix, firstName, middleName, lastName, suffix);
+    }
+    toJson() {
+        return {
+            prefix: this.prefix,
+            firstName: this.firstName,
+            middleName: this.middleName,
+            lastName: this.lastName,
+            suffix: this.suffix,
+        };
+    }
+}
+export function capitalize(str, range = CapsRange.INITIAL) {
+    if (!str || range === CapsRange.NONE)
+        return str;
+    const initial = str[0].toUpperCase();
+    const rest = str.slice(1).toLowerCase();
+    return range === CapsRange.INITIAL ? initial.concat(rest) : str.toUpperCase();
+}
+export function decapitalize(str, range = CapsRange.INITIAL) {
+    if (!str || range === CapsRange.NONE)
+        return str;
+    const initial = str[0].toLowerCase();
+    const rest = str.slice(1);
+    return range === CapsRange.INITIAL ? initial.concat(rest) : str.toLowerCase();
+}
+export function toggleCase(str) {
+    const chars = [];
+    for (const c of str) {
+        if (c === c.toUpperCase()) {
+            chars.push(c.toLowerCase());
+        }
+        else {
+            chars.push(c.toUpperCase());
+        }
+    }
+    return chars.join('');
+}
+export function isStringArray(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((e) => typeof e === 'string');
+}

package/dist/{types → esm}/validator.d.ts

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

package/dist/esm/validator.js

@@ -0,0 +1,259 @@
+import { MIN_NUMBER_OF_NAME_PARTS, MAX_NUMBER_OF_NAME_PARTS } from './constants.js';
+import { InputError, ValidationError } from './error.js';
+import { FirstName, LastName, Name, isNameArray } from './name.js';
+import { Namon } from './types.js';
+import { NameIndex } from './utils.js';
+class ValidationRule {
+    static base = /[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]/;
+    static namon = new RegExp(`^${ValidationRule.base.source}+(([' -]${ValidationRule.base.source})?${ValidationRule.base.source}*)*$`);
+    static firstName = ValidationRule.namon;
+    static middleName = new RegExp(`^${ValidationRule.base.source}+(([' -]${ValidationRule.base.source})?${ValidationRule.base.source}*)*$`);
+    static lastName = ValidationRule.namon;
+}
+const toNameSource = (values) => {
+    return isNameArray(values) ? values.map((n) => n.toString()).join(' ') : '';
+};
+class ArrayValidator {
+    validate(values) {
+        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`,
+            });
+        }
+    }
+}
+class NamonValidator {
+    static #validator;
+    static create() {
+        return this.#validator || (this.#validator = new this());
+    }
+    validate(value, type) {
+        if (value instanceof Name) {
+            NameValidator.create().validate(value, type);
+        }
+        else if (typeof value === 'string') {
+            if (!ValidationRule.namon.test(value)) {
+                throw new ValidationError({
+                    source: value,
+                    nameType: 'namon',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else {
+            throw new InputError({
+                source: typeof value,
+                message: 'expecting types of string | Name',
+            });
+        }
+    }
+}
+class FirstNameValidator {
+    static #validator;
+    static create() {
+        return this.#validator || (this.#validator = new this());
+    }
+    validate(value) {
+        if (value instanceof FirstName) {
+            value.asNames.forEach((name) => this.validate(name.value));
+        }
+        else if (typeof value === 'string') {
+            if (!ValidationRule.firstName.test(value)) {
+                throw new ValidationError({
+                    source: value,
+                    nameType: 'firstName',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else {
+            throw new InputError({
+                source: typeof value,
+                message: 'expecting types string | FirstName',
+            });
+        }
+    }
+}
+class MiddleNameValidator {
+    static #validator;
+    static create() {
+        return this.#validator || (this.#validator = new this());
+    }
+    validate(value) {
+        if (typeof value === 'string') {
+            if (!ValidationRule.middleName.test(value)) {
+                throw new 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, Namon.MIDDLE_NAME);
+            }
+            catch (error) {
+                throw new ValidationError({
+                    source: toNameSource(value),
+                    nameType: 'middleName',
+                    message: error?.message,
+                });
+            }
+        }
+        else {
+            throw new InputError({
+                source: typeof value,
+                message: 'expecting types of string | string[] | Name[]',
+            });
+        }
+    }
+}
+class LastNameValidator {
+    static #validator;
+    static create() {
+        return this.#validator || (this.#validator = new this());
+    }
+    validate(value) {
+        if (value instanceof LastName) {
+            value.asNames.forEach((name) => this.validate(name.value));
+        }
+        else if (typeof value === 'string') {
+            if (!ValidationRule.lastName.test(value)) {
+                throw new ValidationError({
+                    source: value,
+                    nameType: 'lastName',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else {
+            throw new InputError({
+                source: typeof value,
+                message: 'expecting types string | LastName',
+            });
+        }
+    }
+}
+class NameValidator {
+    static #validator;
+    static create() {
+        return this.#validator || (this.#validator = new this());
+    }
+    validate(name, type) {
+        if (type && name.type !== type) {
+            throw new ValidationError({
+                source: name.toString(),
+                nameType: name.type.toString(),
+                message: 'wrong type',
+            });
+        }
+        if (!ValidationRule.namon.test(name.value)) {
+            throw new ValidationError({
+                source: name.toString(),
+                nameType: name.type.toString(),
+                message: 'invalid content',
+            });
+        }
+    }
+}
+export class NamaValidator {
+    static #validator;
+    static create() {
+        return this.#validator || (this.#validator = new this());
+    }
+    validate(value) {
+        this.validateKeys(value);
+        Validators.firstName.validate(value.get(Namon.FIRST_NAME));
+        Validators.lastName.validate(value.get(Namon.LAST_NAME));
+        if (value.has(Namon.PREFIX))
+            Validators.namon.validate(value.get(Namon.PREFIX));
+        if (value.has(Namon.SUFFIX))
+            Validators.namon.validate(value.get(Namon.SUFFIX));
+    }
+    validateKeys(nama) {
+        if (!nama.size) {
+            throw new InputError({ source: undefined, message: 'Map<k,v> must not be empty' });
+        }
+        else if (nama.size < MIN_NUMBER_OF_NAME_PARTS || nama.size > MAX_NUMBER_OF_NAME_PARTS) {
+            throw new InputError({
+                source: [...nama.values()],
+                message: `expecting ${MIN_NUMBER_OF_NAME_PARTS}-${MIN_NUMBER_OF_NAME_PARTS} fields`,
+            });
+        }
+        if (!nama.has(Namon.FIRST_NAME)) {
+            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',
+            });
+        }
+    }
+}
+export class ArrayStringValidator extends ArrayValidator {
+    index;
+    constructor(index = NameIndex.base()) {
+        super();
+        this.index = index;
+    }
+    validate(values) {
+        this.validateIndex(values);
+        Validators.firstName.validate(values[this.index.firstName]);
+        Validators.lastName.validate(values[this.index.lastName]);
+        if (values.length >= 3)
+            Validators.middleName.validate(values[this.index.middleName]);
+        if (values.length >= 4)
+            Validators.namon.validate(values[this.index.prefix]);
+        if (values.length === 5)
+            Validators.namon.validate(values[this.index.suffix]);
+    }
+    validateIndex(values) {
+        super.validate(values);
+    }
+}
+export class ArrayNameValidator {
+    static #validator;
+    static create() {
+        return this.#validator || (this.#validator = new this());
+    }
+    validate(value) {
+        if (value.length < MIN_NUMBER_OF_NAME_PARTS) {
+            throw new InputError({
+                source: toNameSource(value),
+                message: `expecting at least ${MIN_NUMBER_OF_NAME_PARTS} elements`,
+            });
+        }
+        if (!this.#hasBasicNames(value)) {
+            throw new InputError({
+                source: toNameSource(value),
+                message: 'both first and last names are required',
+            });
+        }
+    }
+    #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 === MIN_NUMBER_OF_NAME_PARTS;
+    }
+}
+export class Validators {
+    static namon = NamonValidator.create();
+    static nama = NamaValidator.create();
+    static prefix = NamonValidator.create();
+    static firstName = FirstNameValidator.create();
+    static middleName = MiddleNameValidator.create();
+    static lastName = LastNameValidator.create();
+    static suffix = NamonValidator.create();
+}