A helper library for Turkish noun suffixes written in typescript.

• getPluralSuffix
• makePlural
• getEqualitySuffix
• makeEqual
• getPossesiveSuffix
• makePossesive
• getCaseSuffix
• makeCase
• getCompoundSuffix
• makeCompound
• getVoicedConsonant
• alterToVoicedConsonant
• alterToVowelDrop
• util
  • getComponents
  • getSyllableCount

• AffixiWord

• sounds

• Pronoun
• Case
• Compound

• AffixiWordState

install

npm install affixi

There is no default export in the library, so you can import whatever you need and only the things you need. This makes the library tree-shakable.

import { makePlural, makePossesive, Pronoun } from 'affixi';

makePlural('O'); // Onlar
makePossesive('Akıl', Pronoun.PluralFirst); // Aklımız
makeCase(makePossesive('Ongözlü Köprü', Pronoun.SingularThird), Case.Locative, true); // Ongözlü Köprüsü'nde

getPluralSuffix(base: string) => string

Returns the appropriate plural suffix for a given noun. Suffixes are affected by vowel harmony rules.

e.g:

• Araç > lar
• Bebek > ler

makePlural(base: string) => string

Returns the word base concatenated with the appropriate plural suffix for a given noun.

e.g:

• Araç > Araçlar
• Bebek > Bebekler

getEqualitySuffix(base: string) => string

Returns the appropriate equality suffix for a given noun. These types of suffixes are affected by both vowel harmony, consonant softening, consonant assimilation and buch of other rules.

e.g:

• Çocuk > ça
• Sen > ce

makeEqual(base: string) => string

Returns the word base concatenated with the appropriate equality suffix for a given noun.

e.g:

• Çocuk > Çocukça
• Sen > Sence

getPossesiveSuffix(base: string, pronoun: Pronoun) => string

Returns the appropriate possesive suffix for a given noun and pronoun. These types of suffixes are affected by vowel harmony and given pronoun.

e.g:

• getPossesiveSuffix("Çocuk", Pronoun.SingularFirst) // um
• getPossesiveSuffix("Çocuk", Pronoun.SingularSecond) // un
• getPossesiveSuffix("Sen", Pronoun.SingularSecond) // in

makePossesive(base: string, pronoun: Pronoun, isProperNoun: boolean = false) => string

Returns the word base concatenated with the appropriate possesive suffix for a given noun and pronoun.

Proper nouns are seperated with an apostrophe character.

e.g:

• makePossesive("Çocuk", Pronoun.SingularFirst) // Çocuğum
• makePossesive("Çocuk", Pronoun.SingularSecond) // Çocuğun
• makePossesive("Sen", Pronoun.SingularSecond) // Senin
• makePossesive("Ayşe", Pronoun.SingularFirst, true) // Ayşe'm

getCaseSuffix(base: string, _case: Case) => string

Returns the appropriate case suffix for a given base word and a case

• makeCase('Ev', Case.Ablative) // den
• makeCase('Şehir', Case.Dative) // e
• makeCase('Sinema', Case.Dative) // ya

makeCase(base: string, _case: Case, isProperNoun: boolean = false) => string

Returns the word base concatenated with the appropriate case suffix for a given base word and a case Proper nouns are seperated with an apostrophe character.

• makeCase('Ev', Case.Ablative) // Evden
• makeCase('Balıkesir', Case.Ablative, true) // Balıkesir'den
• makeCase('Şehir', Case.Dative) // Şehre
• makeCase('Sinema', Case.Dative) // Sinemaya

getCompoundSuffix(base: string, compound: Compound) => string

Returns the appropriate compound suffix for a given base word and a compound

• getCompoundSuffix('Köprü', Compound.Compounder) // nün
• getCompoundSuffix('Öğretmen', Compound.Compounder) // in
• getCompoundSuffix('Köprü', Compound.Compoundee) // sü
• getCompoundSuffix('Akıl', Compound.Compoundee) // ı

makeCompound(base: string, compound: Compound, isProperNoun: boolean = false) => string

Returns the word base concatenated with the appropriate compound suffix for a given base word and a compound Proper nouns are seperated with an apostrophe character.

• makeCompound('Köprü', Compound.Compounder) // Köprünün
• makeCompound('Öğretmen', Compound.Compounder) // Öğretmenin
• makeCompound('Köprü', Compound.Compoundee) // Köprüsü
• makeCompound('Akıl', Compound.Compoundee) // Aklı

getVoicedConsonant(base: string) => string | undefined

Some words that end with an unvoiced consonants (p,ç,t,k) may be converted into their voiced counterparts (b,c,d,ğ). If extist, this function returns the voiced consonant. If not returns undefined.

• Ağaç > c
• Sebep > b
• Akıllı > undefined

alterToVoicedConsonant(base: string) => string

This function returns the mutated version of a word with its voiced consonant. If base does not have a voiced counterpart, the base itself is returned.

• Ağaç > Ağac
• Sebep > Sebeb
• Akıllı > Akıllı
• Renk > Reng

alterToVowelDrop(base: string) => string

Some two syllable words that has acute vowels in their last syllable drop that vowel after they are conjugated with a suffix. This function returns the words mutated version with the dropped vowel.

Note: Because certain words are subjected to this phenomenon, these words are kept in an exceptions array. Contributions to this limited list is appreciated.

• Akıl > Akl
• Bağır > Bağr
• Şehir > Şehr

Some utility functions that may help word generation.

util.getComponents(base: string) => WordComponent

This method returns the last letter and the last vowel in the last syllable of a given word. It returns a WordComponent interface.

export interface WordComponent {
  letter: string;
  vowel: string;
}

• Araba > { letter: "a", vowel: "a" }
• Oyuncak > { letter: "k", vowel: "a" }
• Sebep > { letter: "p", vowel: "e" }

util.getSyllableCount(base: string) => number

This method returns the syllable count of a base word. Almost always the syllabale count of a word is equal to the vowel count of a word in Turkish because the stress is delimited by vowels.

• Muvaffak > 3
• Elma > 2
• Süpermarket > 4

AffixiWord is a construct that makes it easier to handle nouns in a complex manner. It holds a state that can be undone and handles aspects like compoundness in itslef. It has a toString method that returns the resulting word and can be used with String(word). All its methods apart from toString return the instance itself so they are chainable.

  base: string; // Given base word
  word: string; // Current state of the word
  isCompound: boolean;
  isProperNoun: boolean;
  history: AffixiWordState[] = [];

See: AffixiWordState

Concatenates the word with the appropriate compound suffix for a given compound type.

makeCompound(type: Compound): AffixiWord

Concatenates the word with the appropriate case suffix for a given case.

makeCase(_case: Case): AffixiWord

Concatenates the word with the completion suffix.

makeComplete(): AffixiWord

Concatenates the word with the possesive suffix for a given pronoun.

  makePossesive(pronoun: Pronoun): AffixiWord

Transforms the word into equal form.

makeEqual(): AffixiWord

Transforms the word into plural form.

makePlural(): AffixiWord

Undoes the last operation

undo(): AffixiWord

Turkish sounds categorized by different metrics.

interface sounds {
  unvoicedStoppingConsonants: string[];
  unvoicedContinuousConsonants: string[];
  voicedStoppingConsonants: string[];
  concatentorConsonants: string[];
  unvoicedConsonants: string[];
  roundedVowels: string[];
  unRoundedVowels: string[];
  backVowels: string[];
  frontVowels: string[];
  acuteVowels: string[];
  wideVowels: string[];
  vowels: string[];
}

enum Pronoun {
  SingularFirst, // I
  SingularSecond, // You (singular)
  SingularThird, // He/She/It
  PluralFirst, // We
  PluralSecond, // You (plural)
  PluralThird, // They
}

I think this one is pretty self-explanatory.

enum Case {
  Absolute,
  Accusative, // -i
  Ablative, // -den
  Locative, // -de
  Instrumental, // -le
  Dative, // -e
}

Turkish noun case names.

enum Compound {
  Compounder, // tamlayan
  Compoundee, // tamlanan
}

Turkish compound types

export interface AffixiWordState {
  word: string;
  isCompound: boolean;
  isProperNoun: boolean;
}