dschnelldavis / parse-full-name Goto Github PK

The functions returns only last in case string is passed B05-1005
In my opinion, it should return return

{
  title: '',
  first: 'B05',
  middle: '-',
  last: '1005',
  nick: '',
  suffix: '',
  error: []
}

Also, is there a way we can choose which part to include in which case by passing preferences?

This may be related to issue 11, NPM version not up to date.

When testing the names "Nicholas Runolfsdottir I" and "Nicholas Runolfsdottir V", I and V were output as last initials, respectively. II, III, and IV all work as intended (Runolfsdottir is output as last name).

I see V is on the list of suffixes in this repository, but have not had a chance to check if the latest version available here has the same issue. Regardless, the version downloaded from NPM does.

I'll just leave this here for now, until I can make a pull request to include the Typescript definitions.

declare module "parse-full-name" {
    export type PartToReturnSingle = "title" | "first" | "middle" | "last" | "nick" | "suffix" | "error";
    export type PartToReturnAll = "all" | undefined | null;
    export type FixCase = -1 | 0 | 1;

    export interface FullNameParsed {
        title: string;
        first: string;
        middle: string;
        last: string;
        nick: string;
        suffix: string;
        error: string[];
    }

    export function parseFullName(nameToParse: string, partToReturn: PartToReturnSingle, fixCase?: FixCase, stopOnError?: boolean, useLongLists?: boolean): string;
    export function parseFullName(nameToParse: string, partToReturn?: PartToReturnAll, fixCase?: FixCase, stopOnError?: boolean, useLongLists?: boolean): FullNameParsed;
    export function parseFullName(nameToParse: string, partToReturn?: PartToReturnAll | PartToReturnSingle, fixCase?: FixCase, stopOnError?: boolean, useLongLists?: boolean): string | FullNameParsed;
}

The result is:

{
  title: '',
  first: 'Marco',
  middle: 'Antonio Reyes ',
  last: 'Gonzalez',
  nick: '',
  suffix: '',
  error: []
}

When it must be:

{
  title: '',
  first: 'Marco',
  middle: 'Antonio',
  last: 'Reyes Gonzalez',
  nick: '',
  suffix: '',
  error: []
}

Parsing for names like "Joe van den Berg" are returning 'Berg' as the last name. The last name should be "van den Berg".
Also tried "Joe Van Den Berg" but that did not help.
However, it is working for names similar like "Joe van der Berg".

"Van de Berg", "van den Berg" and "van der Berg" should probably all work -- they mean the same thing in general "from the mountain" and are very common Dutch surnames (see https://www.dutchgenealogy.nl/popular-dutch-surnames/).

Otherwise-- thanks much for what you have-- seems well documented and well thought out.

There in a typo in the title 'first lieutient'
Should be 'first lieutenant'

Not much explanation needed, I think. Does this code have a license?

A common German firstname is "Karl-Heinz" or generally a firstname often consists of two parts connected with a hyphen. For some reason the second part is not capitalized.

Example Input: 'Full Name [nickname1] (nickname2)'
Expected Result: {title: "", first: "FirstName", middle: "", last: "LastName", nick: "nickname1 nickname2", suffix: ""}
Actual Result: {title: "", first: "FirstName", middle: "LastName", last: "(nickname2)", nick: "nickname1", suffix: ""}

Input : "Daniel"
Output : { first: "", middle: "", last: "Daniel" }

Expected : { first: "Daniel", middle: "", last: "" }

Screenshot attached.

Hi,

I can see that in 7c5ada9 you've added a list of gender-neutral titles to the library, but the version on NPM doesn't appear to include those. Is there a way to reference the master version from GitHub, or could the NPM version be updated to include these?

Thanks! This is such a helpful library 😁

'van den' is treated like a middle name, unlike 'van der', 'van de', etc.

parse('Johannes van den Bosch').last // 'Bosch'
parse('Johannes van der Bosch').last // 'van der Bosch'
parse('Johannes van de Bosch').last  // 'van de Bosch'

"Karyn Fernandes" does not parse properly.

Parsing Smith,John
Results in {error: [], first: "John", last: "Smith", middle: "", nick: "", suffix: "", title: ""}

While parsing Smith,John
Results in {error: [], first: "", last: "Smith,John", middle: "", nick: "", suffix: "", title: ""}

The latter fails consistently regardless of the name if there is a "space" missing after the "comma" .

Just filing my discovery here, if anyone haves a clue if this is by design, or an actual bug - that would be pretty helpful. Thanks.

I tested full name 'Robert E Ward', it returned
{ title: '',
first: '',
middle: '',
last: 'Robert E Ward',
nick: '',
suffix: '',
error: [] }

The titleList has a few duplicated values, like mr, ms, dr...

Is this a mistake or it is expected ?

Hi, Does anyone have a Python 3.6+ version of this package?

Thank you for this library. I really like the case-fixing that it provides.

When I call this library like parseFullName('steven'), the result is that steven is returned as the last name. This seems counterintuitive to me and should be returned as the first name.

Hi I'd like to keep using this in my web project, but your'e using Node syntax

Could you replace your first line with:
export function parseFullName(

Don't know if that works in Node.js, but it does work with my PWA project.

a name such as Ezekiel Johnson would be fine as is and returns
{ title: '', first: 'Ezekiel', middle: '', last: 'Johnson', nick: '', suffix: '', error: [] }

but Ezekiel Johnson with a blank space at the end results in

{ title: '', first: 'Ezekiel', middle: 'Johnson', last: '', nick: '', suffix: '', error: [] }

When a full name containing the middle initial "E" or "Y" is inputted into this module, the result is that the first, middle, and last name tokens are interpreted together as the last name.

Examples

input -> "Jimmie E French"
output -> {"title":"","first":"","middle":"","last":"Jimmie E French","nick":"","suffix":"","error":[]}

input -> "Brent Y Hickok II"
output -> {"title":"","first":"","middle":"","last":"Brent Y Hickok","nick":"","suffix":"II","error":[]}

Currently, post-nominal letters (eg: M.D.) are treated like a suffix, however names often place a comma between the name, and the post-nominal letters. Here is an example:

John Doe III, M.D.

In this example, III is the suffix, and M.D. is the post-nominal letters. Since the syntax and placement are different, they should be parsed into separate fields.

Parsed Result is :

{"title":"","first":"LEED","middle":"AP\…:"John Doe","nick":"","suffix":"","error":[]}

let result = {
"title": "",
"first": "",
"middle": "",
"last": "Jim e Something",
"nick": "",
"suffix": "",
"error": []
}