namefully 1.3.0 → 2.0.1

package/dist/esm/parser.js

@@ -0,0 +1,127 @@
+import { Config } from './config.js';
+import { NameIndex } from './utils.js';
+import { InputError } from './error.js';
+import { FullName } from './fullname.js';
+import { Namon, Separator } from './types.js';
+import { FirstName, LastName, Name } from './name.js';
+import { ArrayStringValidator, ArrayNameValidator, NamaValidator } from './validator.js';
+export class Parser {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    static build(text, index) {
+        const parts = text.trim().split(Separator.SPACE.token);
+        const length = parts.length;
+        if (index instanceof NameIndex) {
+            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);
+        }
+        if (length < 2) {
+            throw new 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);
+        }
+    }
+}
+export class StringParser extends Parser {
+    parse(options) {
+        const config = Config.merge(options);
+        const names = this.raw.split(config.separator.token);
+        return new ArrayStringParser(names).parse(options);
+    }
+}
+export class ArrayStringParser extends Parser {
+    parse(options) {
+        const config = Config.merge(options);
+        const fullName = new FullName(config);
+        const raw = this.raw.map((n) => n.trim());
+        const index = NameIndex.when(config.orderedBy, raw.length);
+        const validator = new ArrayStringValidator(index);
+        if (config.bypass) {
+            validator.validateIndex(raw);
+        }
+        else {
+            validator.validate(raw);
+        }
+        const { firstName, lastName, middleName, prefix, suffix } = index;
+        fullName.setFirstName(new FirstName(raw[firstName]));
+        fullName.setLastName(new LastName(raw[lastName]));
+        if (raw.length >= 3)
+            fullName.setMiddleName(raw[middleName].split(config.separator.token));
+        if (raw.length >= 4)
+            fullName.setPrefix(Name.prefix(raw[prefix]));
+        if (raw.length === 5)
+            fullName.setSuffix(Name.suffix(raw[suffix]));
+        return fullName;
+    }
+}
+export 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 namon = Namon.cast(key);
+            if (!namon) {
+                throw new InputError({
+                    source: Object.values(this.raw).join(' '),
+                    message: `unsupported key "${key}"`,
+                });
+            }
+            return [namon, value];
+        }));
+    }
+}
+export class ArrayNameParser extends Parser {
+    parse(options) {
+        const config = Config.merge(options);
+        const fullName = new FullName(config);
+        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 FirstName ? name : new FirstName(name.value));
+            }
+            else if (name.isMiddleName) {
+                fullName.middleName.push(name);
+            }
+            else if (name.isLastName) {
+                const lastName = new LastName(name.value, name instanceof LastName ? name.mother : undefined, config.surname);
+                fullName.setLastName(lastName);
+            }
+        }
+        return fullName;
+    }
+}

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

@@ -1,6 +1,4 @@
-/**
- * Make a type nullable.
- */
+/** Make a type nullable. */
 export type Nullable<T> = T | null | undefined;
 /**
  * The abbreviation type to indicate whether or not to add period to a prefix
@@ -23,25 +21,19 @@ export declare enum Surname {
     HYPHENATED = "hyphenated",
     ALL = "all"
 }
-/**
- * The order of appearance of a `FullName`.
- */
+/** The order of appearance of a `FullName`. */
 export declare enum NameOrder {
     FIRST_NAME = "firstName",
     LAST_NAME = "lastName"
 }
-/**
- * The types of name handled in this according the name standards.
- */
+/** The types of name handled in this according the name standards. */
 export declare enum NameType {
     FIRST_NAME = "firstName",
     MIDDLE_NAME = "middleName",
     LAST_NAME = "lastName",
     BIRTH_NAME = "birthName"
 }
-/**
- * The possible variants to indicate how to flatten a `FullName`.
- */
+/** The possible variants to indicate how to flatten a `FullName`. */
 export declare enum Flat {
     FIRST_NAME = "firstName",
     MIDDLE_NAME = "middleName",
@@ -50,17 +42,13 @@ export declare enum Flat {
     MID_LAST = "midLast",
     ALL = "all"
 }
-/**
- * The range to use when capitalizing a string content.
- */
+/** The range to use when capitalizing a string content. */
 export declare enum CapsRange {
     NONE = 0,
     INITIAL = 1,
     ALL = 2
 }
-/**
- * The types of name handled in this utility according the name standards.
- */
+/** The types of name handled in this utility according the name standards. */
 export declare class Namon {
     readonly index: number;
     readonly key: string;
@@ -69,35 +57,21 @@ export declare class Namon {
     static readonly MIDDLE_NAME: Namon;
     static readonly LAST_NAME: Namon;
     static readonly SUFFIX: Namon;
-    /**
-     * The list of supported name types.
-     */
+    /** The list of supported name types. */
     static readonly values: Namon[];
-    /**
-     * All the predefined name types.
-     */
+    /** All the predefined name types. */
     static readonly all: Map<string, Namon>;
     private constructor();
-    /**
-     * Whether this string key is part of the predefined keys.
-     */
+    /** Whether this string key is part of the predefined keys. */
     static has(key: string): boolean;
-    /**
-     * Makes a string key a namon type.
-     */
+    /** Makes a string key a namon type. */
     static cast(key: string): Nullable<Namon>;
-    /**
-     * String representation of this object.
-     */
+    /** String representation of this object. */
     toString(): string;
-    /**
-     * Whether this and the other value are equal.
-     */
+    /** Whether this and the other value are equal. */
     equal(other: Namon | unknown): boolean;
 }
-/**
- * The token used to indicate how to split string values.
- */
+/** The token used to indicate how to split string values. */
 export declare class Separator {
     readonly name: string;
     readonly token: string;
@@ -111,17 +85,11 @@ export declare class Separator {
     static readonly SINGLE_QUOTE: Separator;
     static readonly SPACE: Separator;
     static readonly UNDERSCORE: Separator;
-    /**
-     * All the available separators.
-     */
+    /** All the available separators. */
     static readonly all: Map<string, Separator>;
-    /**
-     * All the available tokens.
-     */
+    /** All the available tokens. */
     static readonly tokens: string[];
     private constructor();
-    /**
-     * String representation of this object.
-     */
+    /** String representation of this object. */
     toString(): string;
 }

package/dist/esm/types.js

@@ -0,0 +1,106 @@
+export var Title;
+(function (Title) {
+    Title["US"] = "US";
+    Title["UK"] = "UK";
+})(Title || (Title = {}));
+export var Surname;
+(function (Surname) {
+    Surname["FATHER"] = "father";
+    Surname["MOTHER"] = "mother";
+    Surname["HYPHENATED"] = "hyphenated";
+    Surname["ALL"] = "all";
+})(Surname || (Surname = {}));
+export var NameOrder;
+(function (NameOrder) {
+    NameOrder["FIRST_NAME"] = "firstName";
+    NameOrder["LAST_NAME"] = "lastName";
+})(NameOrder || (NameOrder = {}));
+export var NameType;
+(function (NameType) {
+    NameType["FIRST_NAME"] = "firstName";
+    NameType["MIDDLE_NAME"] = "middleName";
+    NameType["LAST_NAME"] = "lastName";
+    NameType["BIRTH_NAME"] = "birthName";
+})(NameType || (NameType = {}));
+export 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 || (Flat = {}));
+export var CapsRange;
+(function (CapsRange) {
+    CapsRange[CapsRange["NONE"] = 0] = "NONE";
+    CapsRange[CapsRange["INITIAL"] = 1] = "INITIAL";
+    CapsRange[CapsRange["ALL"] = 2] = "ALL";
+})(CapsRange || (CapsRange = {}));
+export 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;
+    }
+    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;
+    }
+}
+export 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;
+    }
+    toString() {
+        return `Separator.${this.name}`;
+    }
+}

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

@@ -1,6 +1,6 @@
-import { NameOrder, CapsRange } from './types';
+import { NameOrder, CapsRange } from './types.js';
 /**
- * A fixed set of values to handle specific positions for list of names.
+ * A set of values to handle specific positions for list of names.
  *
  * As for list of names, this helps to follow a specific order based on the
  * count of elements. It is expected that the list has to be between two and
@@ -42,14 +42,12 @@ export declare class NameIndex {
     static when(order: NameOrder, count?: number): NameIndex;
     static only({ prefix, firstName, middleName, lastName, suffix }: Record<string, number>): NameIndex;
     toJson(): Record<string, number>;
+    json: () => Record<string, number>;
 }
-/**
- * Capitalizes a string via a `CapsRange` option.
- */
+/** Capitalizes a string via a `CapsRange` option. */
 export declare function capitalize(str: string, range?: CapsRange): string;
 /** Decapitalizes a string via a `CapsRange` option. */
 export declare function decapitalize(str: string, range?: CapsRange): string;
 /** Toggles a string representation. */
 export declare function toggleCase(str: string): string;
 export declare function isStringArray(value?: unknown): boolean;
-export declare function isNameArray(value?: unknown): boolean;

package/dist/esm/utils.js

@@ -0,0 +1,91 @@
+import { NameOrder, CapsRange } from './types.js';
+import { MIN_NUMBER_OF_NAME_PARTS, MAX_NUMBER_OF_NAME_PARTS } from './constants.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 NameIndex(-1, 0, -1, 1, -1);
+    }
+    static when(order, count = 2) {
+        if (order === NameOrder.FIRST_NAME) {
+            switch (count) {
+                case 2:
+                    return new NameIndex(-1, 0, -1, 1, -1);
+                case 3:
+                    return new NameIndex(-1, 0, 1, 2, -1);
+                case 4:
+                    return new NameIndex(0, 1, 2, 3, -1);
+                case 5:
+                    return new NameIndex(0, 1, 2, 3, 4);
+                default:
+                    return NameIndex.base();
+            }
+        }
+        else {
+            switch (count) {
+                case 2:
+                    return new NameIndex(-1, 1, -1, 0, -1);
+                case 3:
+                    return new NameIndex(-1, 1, 2, 0, -1);
+                case 4:
+                    return new NameIndex(0, 2, 3, 1, -1);
+                case 5:
+                    return new NameIndex(0, 2, 3, 1, 4);
+                default:
+                    return NameIndex.base();
+            }
+        }
+    }
+    static only({ prefix = -1, firstName, middleName = -1, lastName, suffix = -1 }) {
+        return new NameIndex(prefix, firstName, middleName, lastName, suffix);
+    }
+    toJson() {
+        return {
+            prefix: this.prefix,
+            firstName: this.firstName,
+            middleName: this.middleName,
+            lastName: this.lastName,
+            suffix: this.suffix,
+        };
+    }
+    json = this.toJson;
+}
+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) {
+    return str
+        .split('')
+        .map((c) => (c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase()))
+        .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;
 }