very beta functionality for showing the English transations of sentences in the conjugation viewer. To do this you need to have a verb with the 'ec' field showing the English conjugation info from the dictionary.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingdocs/pashto-inflector",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "author": "lingdocs.com",
   "description": "A Pashto inflection and verb conjugation engine, inculding React components for displaying Pashto text, inflections, and conjugations",
   "homepage": "https://verbs.lingdocs.com",

src/App.tsx

@@ -40,7 +40,7 @@ const transitivities: T.Transitivity[] = [
     "grammatically transitive",
 ];
 
-const allVerbs = verbs.map((v: any) => ({
+const allVerbs = verbs.map((v: { entry: T.DictionaryEntry, complement?: T.DictionaryEntry }) => ({
     verb: v,
     info: getVerbInfo(v.entry, v.complement),
 }));
@@ -311,6 +311,7 @@ function App() {
                 {conjugation && <ConjugationViewer
                     conjugation={conjugation}
                     textOptions={textOptions}
+                    ec={v ? v.verb.entry.ec : undefined}
                 />}
             </div>
         </main>

src/components/ConjugationViewer.tsx

@@ -17,6 +17,7 @@ import {
     personIsAllowed,
     randomPerson,
     incrementPerson,
+    parseEc,
 } from "../lib/misc-helpers";
 import * as T from "../types";
 
@@ -170,9 +171,10 @@ const initialState: State = {
     formsOpened: [],
 };
 
-function ConjugationViewer({ conjugation, textOptions }: {
+function ConjugationViewer({ conjugation, textOptions, ec }: {
     conjugation: T.VerbOutput,
     textOptions: T.TextOptions,
+    ec?: string | undefined,
 }) {
     const [state, dispatch] = useReducer(reducer, initialState);
     useEffect(() => {
@@ -194,6 +196,7 @@ function ConjugationViewer({ conjugation, textOptions }: {
     const verbConj = (verbConj1.singularForm && state.compoundComplementVersionSelected === "sing")
         ? verbConj1.singularForm
         : verbConj1;
+    const englishConjugation = parseEc(ec);
 
     useEffect(() => {
         localStorage.setItem(stateLocalStorageName, JSON.stringify(state));
@@ -209,6 +212,7 @@ function ConjugationViewer({ conjugation, textOptions }: {
         subject: state.subject,
         object: state.object,
         negative: state.negative,
+        englishConjugation,
     });
     return <div className="mb-4">
         {"transitive" in conjugation && <div className="text-center my-2">

src/components/verb-info/VerbInfo.tsx

@@ -29,15 +29,21 @@ const indentR = {
     paddingLeft: "1rem",
 };
 
+const highlight = {
+    background: "yellow",
+};
+
 const title: CSSProperties = {
     fontWeight: "bolder",
     marginBottom: "0.5rem",
     marginTop: "0.5rem",
 };
 
-export function RootsAndStems({ textOptions, info }: {
+export function RootsAndStems({ textOptions, info, hidePastParticiple, highlighted }: {
     textOptions: T.TextOptions,
     info: T.NonComboVerbInfo,
+    hidePastParticiple?: boolean,
+    highlighted?: ("imperfective root" | "perfective root" | "imperfective stem" | "perfective stem" | "past participle")[],
 }) {
     const hasPerfectiveSplit = !!(info.root.perfectiveSplit || info.stem.perfectiveSplit);
     const showPersInf = hasPersInfs(info);
@@ -64,7 +70,7 @@ export function RootsAndStems({ textOptions, info }: {
                 margin: "0 auto",
                 backgroundImage: `url(${fadedTree})`,
                 backgroundRepeat: "no-repeat",
-                backgroundPosition: "50% 35%",
+                backgroundPosition: hidePastParticiple ? "50% 45%" : "50% 35%",
                 backgroundSize: "50%",    
             }}>
                 {/* <div style={{
@@ -103,7 +109,7 @@ export function RootsAndStems({ textOptions, info }: {
                         </div>
                     </div>
                     <div className={rowClass}>
-                        <div className={colClass}>
+                        <div className={colClass} style={highlighted?.includes("imperfective stem") ? highlight : {}}>
                             <div style={title}>
                                 <div>Imperfective Stem</div>
                             </div>
@@ -115,7 +121,7 @@ export function RootsAndStems({ textOptions, info }: {
                                 />
                             </div>
                         </div>
-                        <div className={colClass}>
+                        <div className={colClass} style={highlighted?.includes("perfective stem") ? highlight : {}}>
                             <div style={title}>
                                 <div>Perfective Stem</div>
                             </div>
@@ -129,7 +135,7 @@ export function RootsAndStems({ textOptions, info }: {
                         </div>
                     </div>
                     <div className={rowClass}>
-                        <div className={colClass}>
+                        <div className={colClass} style={highlighted?.includes("imperfective root") ? highlight : {}}>
                             <div style={title}>
                                 <div>Imperfective Root</div>
                             </div>
@@ -140,7 +146,7 @@ export function RootsAndStems({ textOptions, info }: {
                                 />
                             </div>
                         </div>
-                        <div className={colClass}>
+                        <div className={colClass} style={highlighted?.includes("perfective root") ? highlight : {}}>
                             <div>
                                 <div style={title}>
                                     <div>Perfective Root</div>
@@ -154,13 +160,13 @@ export function RootsAndStems({ textOptions, info }: {
                             </div>
                         </div>
                     </div>
-                    <div className="text-center">
+                    {!hidePastParticiple && <div className="text-center" style={highlighted?.includes("imperfective stem") ? highlight : {}}>
                         <div style={title}>Past Participle</div>
                             <VerbInfoItemDisplay
                                 item={pickPersInf(info.participle.past, persInf)}
                                 textOptions={textOptions}
                             />
-                    </div>
+                    </div>}
                 </div>
             </div>
         </div>

src/lib/add-pronouns.ts

@@ -63,7 +63,7 @@ type Pronouns = undefined | {
 
 const nuParticle = { p: "نه", f: "nú" };
 
-export default function addPronouns({ s, subject, object, info, displayForm, intransitive, ergative, matrixKey, negative }: {
+export default function addPronouns({ s, subject, object, info, displayForm, intransitive, ergative, matrixKey, englishConjugation, negative }: {
     s: T.SentenceForm,
     subject: T.Person,
     object: T.Person,
@@ -73,13 +73,14 @@ export default function addPronouns({ s, subject, object, info, displayForm, int
     ergative: boolean,
     matrixKey: T.PersonInflectionsField,
     negative: boolean,
+    englishConjugation?: T.EnglishVerbConjugation,
 }): T.SentenceForm {
     if ("long" in s) {
         return {
-            long: addPronouns({ s: s.long, subject, object, info, displayForm, intransitive, ergative, matrixKey, negative }) as T.ArrayOneOrMore<T.PsString>,
+            long: addPronouns({ s: s.long, subject, object, info, displayForm, intransitive, ergative, matrixKey, englishConjugation, negative }) as T.ArrayOneOrMore<T.PsString>,
-            short: addPronouns({ s: s.short, subject, object, info, displayForm, intransitive, ergative, matrixKey, negative }) as T.ArrayOneOrMore<T.PsString>,
+            short: addPronouns({ s: s.short, subject, object, info, displayForm, intransitive, ergative, matrixKey, englishConjugation, negative }) as T.ArrayOneOrMore<T.PsString>,
             ...s.mini ? {
-                mini: addPronouns({ s: s.mini, subject, object, info, displayForm, intransitive, ergative, matrixKey, negative }) as T.ArrayOneOrMore<T.PsString>,
+                mini: addPronouns({ s: s.mini, subject, object, info, displayForm, intransitive, ergative, matrixKey, englishConjugation, negative }) as T.ArrayOneOrMore<T.PsString>,
             } : {},
         }
     }
@@ -124,6 +125,11 @@ export default function addPronouns({ s, subject, object, info, displayForm, int
             object: nearPronounPossible(object) ? [objectPronoun, nearObjectPronoun] : objectPronoun,
             mini: miniPronoun,
         };
+    const english = (displayForm.englishBuilder && englishConjugation)
+        ? displayForm.englishBuilder(subject, englishConjugation, negative).map(sen => (
+            intransitive ? sen : `${sen} ${engObj(object)}`
+        )).join(" / ")
+        : undefined;
 
     function attachPronounsToVariation(ps: T.PsString, prns: Pronouns): T.ArrayOneOrMore<T.PsString> {
         if (!prns) {
@@ -170,7 +176,7 @@ export default function addPronouns({ s, subject, object, info, displayForm, int
             ...canWorkWithOnlyMini
                 ? makeOnlyMiniForm(ps, splitHead, displayForm, info, negative, prns.mini)
                 : [],
-        ] as T.ArrayOneOrMore<T.PsString>;
+        ].map((ps) => english ? { ...ps, e: english } : ps) as T.ArrayOneOrMore<T.PsString>;
     }
 
     // @ts-ignore
@@ -485,3 +491,21 @@ function getObjComplement(info: T.NonComboVerbInfo): T.PsString | undefined {
         (info.objComplement.plural ? info.objComplement.plural : info.objComplement.entry) :
         undefined;
 }
+
+function engObj(s: T.Person): string {
+    return (s === T.Person.FirstSingMale || s === T.Person.FirstSingFemale)
+        ? "me"
+        : (s === T.Person.FirstPlurMale || s === T.Person.FirstPlurFemale)
+        ? "us"
+        : (s === T.Person.SecondSingMale || s === T.Person.SecondSingFemale)
+        ? "you"
+        : (s === T.Person.SecondPlurMale || s === T.Person.SecondPlurFemale)
+        ? "you (pl.)"
+        : (s === T.Person.ThirdSingMale)
+        ? "him/it"
+        : (s === T.Person.ThirdSingFemale)
+        ? "her/it"
+        : (s === T.Person.ThirdPlurMale)
+        ? "them"
+        : "them (f.)";
+}

src/lib/conjugation-forms.tsx

@@ -6,13 +6,31 @@
  *
  */
 
+// FOR ENGLISH FORMS
+// GIVEN VERB INFO LIKE THIS
+//  ["hit", "hits", "hitting", "hit", "hit"]
+//  ["eat", "eats", "eating", "ate", "eaten"]
+//  ["see", "sees", "seeing", "saw", "seen"]
+ 
+//  Present Perfect
+
+//  Past Perfect
+//  - subj "had" (N && "not") v.4 obj
+ 
+//  Future Perfect
+//  - subj "will have" (N && "not") v.4 obj
+ 
+ 
+
 import {
     getPersonInflectionsKey,
     pickPersInf,
     getPersonFromVerbForm,
+    getBlockRowCol,
 } from "./misc-helpers";
 import addPronouns from "./add-pronouns";
 import * as T from "../types";
+import { englishEquative } from "./grammar-units";
 
 type FilterFunc = (form: any) => boolean;
 type MapFunc = (opts: { 
@@ -21,6 +39,7 @@ type MapFunc = (opts: {
     displayForm: T.DisplayFormForSentence,
     info: T.NonComboVerbInfo,
     negative: boolean,
+    englishConjugation?: T.EnglishVerbConjugation,
 }) => T.DisplayFormItem;
 
 /**
@@ -67,22 +86,22 @@ const formMap = (
     subject: T.Person,
     object: T.Person,
     negative: boolean,
+    englishConjugation?: T.EnglishVerbConjugation,
 ): T.DisplayFormItem[] => {
-    return (
+    return input.map((f) => (
-        input.map((f) => (
         "content" in f
-                ? { ...f, content: formMap(f.content, func, info, subject, object, negative) }
+            ? { ...f, content: formMap(f.content, func, info, subject, object, negative, englishConjugation) }
-                : func({ displayForm: f as T.DisplayFormForSentence, info, subject, object, negative })
+            : func({ displayForm: f as T.DisplayFormForSentence, info, subject, object, negative, englishConjugation })
-        ))
+    ));
-    );
 };
 
-const makeSentence = ({ subject, object, info, displayForm, negative }: {
+const makeSentence = ({ subject, object, info, displayForm, englishConjugation, negative }: {
     subject: T.Person,
     object: T.Person,
     info: T.NonComboVerbInfo,
     displayForm: T.DisplayFormForSentence,
     negative: boolean,
+    englishConjugation?: T.EnglishVerbConjugation,
 }): T.DisplayForm => {
     const intransitive = info.transitivity === "intransitive" || !!displayForm.passive;
     const ergative = !intransitive && !!displayForm.past;
@@ -107,6 +126,7 @@ const makeSentence = ({ subject, object, info, displayForm, negative }: {
         ergative,
         matrixKey,
         negative,
+        englishConjugation,
     });
     return {
         ...displayForm,
@@ -114,21 +134,17 @@ const makeSentence = ({ subject, object, info, displayForm, negative }: {
     };
 }
 
-export const getForms = ({ conj, filterFunc, mode, subject, object, negative } : {
+const formsOfConjugation = (conj: T.VerbConjugation): T.DisplayFormItem[] => [
-    conj: T.VerbConjugation,
-    filterFunc?: FilterFunc | FilterFunc[],
-    mode: "chart" | "sentence",
-    subject: T.Person,
-    object: T.Person,
-    negative: boolean,
-}): T.DisplayFormItem[] => {
-    const forms: T.DisplayFormItem[] = [
     {
         label: "Present",
         aspect: "imperfective",
         form: conj.imperfective.nonImperative,
         formula: "Imperfective Stem + Present Ending",
         sentence: true,
+        englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+            `${engSubj(s)} ${n ? `${engPresC(s, ["don't", "doesn't"])} ` : ""}${n ? v[0] : engPresC(s, v)}`,
+            `${engSubj(s)} ${engEquative("present", s)}${n ? " not" : ""} ${v[2]}`,
+        ]),
         explanation: "Something that is happening, happens generally, or is definitely about to happen. ('I am ____ing', 'I _____')",
     },
     {
@@ -137,6 +153,10 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
         form: conj.perfective.nonImperative,
         formula: "Perfective Stem + Present Ending",
         sentence: true,
+        englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+            `that ${engSubj(s, true)}${n ? " won't" : "'ll"} ${v[0]}`,
+            `should ${engSubj(s, true)}${n ? " not" : ""} ${v[0]}`,
+        ]),
         explanation: "Used for hypothetical statements about the desire, necessity, purpose, or possibility of something happening. Or for saying something should or shouldn't happen. ('Should I ____?', 'so that'll I'll _____')"
     },
     {
@@ -146,6 +166,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
         advanced: true,
         formula: "به - ba + Present",
         sentence: true,
+        englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+            `${engSubj(s)} will${n ? " not" : ""} ${v[0]}`,
+        ]),
         explanation: "Saying something will happen, repeatedly or as an ongoing action",
     },
     {
@@ -155,6 +178,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
         advanced: true,
         formula: "به - ba + Subjunctive",
         sentence: true,
+        englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+            `${engSubj(s)} will${n ? " not" : ""} ${v[0]}`,
+        ]),
         explanation: "Saying something will happen as a one-time event - May also used when there is some doubt",
     },
     {
@@ -163,6 +189,12 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
         form: conj.imperfective.past,
         formula: "Imperfective Root + Past Ending",
         sentence: true,
+        englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+            //  - subj "was" (N && "not") v.2 obj
+            `${engSubj(s)} ${engEquative("past", s)}${n ? " not" : ""} ${v[2]}`,
+            //  - subj "would" (N && "not") v.0 obj
+            `${engSubj(s)} would${n ? " not" : ""} ${v[0]}`,
+        ]),
         explanation: "Saying something was happening, or would happen ('I was ____ing', 'I would ____')",
         past: true,
     },
@@ -172,6 +204,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
         form: conj.perfective.past,
         formula: "Perfective Root + Past Ending",
         sentence: true,
+        englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+            `${engSubj(s)}${n ? " did not" : ""} ${v[3]}`,
+        ]),
         explanation: "Saying something happened ('I ____ed')",
         past: true,
     },
@@ -185,6 +220,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 aspect: "imperfective",
                 form: conj.imperfective.modal.nonImperative,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `${engSubj(s)} can${n ? "'t" : ""} ${v[0]}`,
+                ]),
                 formula: "Imperfective Root + Non-Inflectinig Ey-Tail + Subjunctive کېدل - to become",
                 explanation: "saying that something is possible currently or in general ('I can ____')",
                 reorderWithNegative: true,
@@ -195,6 +233,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 form: conj.perfective.modal.nonImperative,
                 advanced: true,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `that ${engSubj(s, true)} can${n ? "'t" : ""} ${v[0]}`,
+                ]),
                 formula: "Perfective Root + Non-Inflectinig Ey-Tail + Subjunctive کېدل - to become",
                 explanation: "talking about the possibility of something in a subjunctive way ('so that I can ____')",
                 reorderWithNegative: true,
@@ -205,6 +246,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 form: conj.imperfective.modal.future,
                 advanced: true,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `${engSubj(s)} will${n ? " not" : ""} be able to ${v[0]}`,
+                ]),
                 formula: "به - ba + Present Modal",
                 explanation: "saying that something will be possible in general or in an ongoing sense in the future ('I'll be able to ____')",
                 reorderWithNegative: true,
@@ -215,6 +259,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 form: conj.perfective.modal.future,
                 advanced: true,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `${engSubj(s)} will${n ? " not" : ""} be able to ${v[0]}`,
+                ]),
                 formula: "به - ba + Subjunctive Modal",
                 explanation: "saying that something will be possible at a certain point in the future ('I'll be able to ____')",
                 reorderWithNegative: true,
@@ -226,6 +273,10 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 advanced: true,
                 past: true,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `${engSubj(s)} ${engEquative("past", s)} ${n ? " not" : ""} able to ${v[0]}`,
+                    `${engSubj(s)} could${n ? " not" : ""} ${v[0]}`,
+                ]),
                 formula: "Imperfective Root + Non-Inflectinig Ey-Tail + Simple Past کېدل - to become",
                 explanation: "saying that something was possible in general, in an ongoing sense ('I was able to ____', ie. 'I could do ____ any time')",
                 reorderWithNegative: true,
@@ -237,6 +288,10 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 formula: "Perfective Root + Non-Inflectinig Ey-Tail + Simple Past کېدل - to become",
                 explanation: "saying that something was possible at a certain point in time ('I was able to ____, at one particular point in time')",
                 past: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `${engSubj(s)} ${engEquative("past", s)} ${n ? " not" : ""} able to ${v[0]}`,
+                    `${engSubj(s)} could${n ? " not" : ""} ${v[0]}`,
+                ]),
                 sentence: true,
                 advanced: true,
                 reorderWithNegative: true,
@@ -270,6 +325,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
             label: "Imperfective Imperative",
             aspect: "imperfective",
             form: conj.imperfective.imperative,
+            englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                `${v[0]}`,
+            ]),
             formula: "Imperfective Stem + Imperative Ending",
             explanation: "Commanding someone/people to do something repeatedly, or in general",
         } as T.DisplayForm] : [],
@@ -278,6 +336,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
             label: "Perfective Imperative",
             aspect: "perfective",
             form: conj.perfective.imperative,
+            englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                `${v[0]}`,
+            ]),
             formula: "Perfective Stem + Imperative Ending",
             explanation: "Commanding someone/people to do something one time",
         } as T.DisplayForm] : [],
@@ -291,6 +352,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 form: conj.perfect.halfPerfect,
                 past: true,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `${engSubj(s)} ${engHave(s)}${n ? " not" : ""} ${v[4]}`,
+                ]),
                 formula: "Past participle inflected",
                 secondPronounNeeded: true,
                 explanation: "The base of all perfect forms. Used on it's own as a sort of weaker form of the present perfect.",
@@ -300,6 +364,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 form: conj.perfect.past,
                 past: true,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `${engSubj(s)} had${n ? " not" : ""} ${v[4]}`,
+                ]),
                 formula: "Past participle inflected + Past Equative",
                 explanation: "Talking about events that had happened in the past, or had affected a past situation ('I had ____ed')",
                 reorderWithNegative: true,
@@ -309,6 +376,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 form: conj.perfect.present,
                 past: true,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `${engSubj(s)} ${engHave(s)}${n ? " not" : ""} ${v[4]}`,
+                ]),
                 formula: "Past participle inflected + Present Equative",
                 explanation: "Talking about that something happened in the past and it affects the present ('I have _____ed')",
                 reorderWithNegative: true,
@@ -318,6 +388,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 form: conj.perfect.subjunctive,
                 past: true,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `that ${engSubj(s, true)} will have${n ? " not" : ""} ${v[4]}`,
+                ]),
                 formula: "Past participle inflected + Subjunctive/Habitual Equative",
                 explanation: "Talking about something that will have happened habitually, or expressing hope, desire, or judgement about an action having happened",
                 reorderWithNegative: true,
@@ -328,6 +401,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 advanced: true,
                 past: true,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `${engSubj(s)} will${n ? " not" : ""} have ${v[4]}`,
+                ]),
                 formula: "به - ba + Past participle Inflected + Future Equative",
                 explanation: "Talking about something that will have happened in the future, or guessing that the event will have occured presently ('I will have ____ed')",
                 reorderWithNegative: true,
@@ -338,6 +414,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                 advanced: true,
                 past: true,
                 sentence: true,
+                englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                    `${engSubj(s)} will${n ? " not" : ""} have ${v[4]}`,
+                ]),
                 explanation: "Affirming that an event will have taken place ('I will have ____ed')",
                 formula: "به - ba + Past Participle Inflected + Past Equative",
                 reorderWithNegative: true,
@@ -396,6 +475,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                     form: conj.passive.imperfective.nonImperative,
                     sentence: true,
                     passive: true,
+                    englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                        `${engSubj(s)} ${engEquative("present", s)}${n ? " not" : ""} being ${v[4]}`,
+                    ]),
                     formula: "Long Imperfective Root + Present کېدل - to become",
                     explanation: "Saying that something is being done or is done in general, without mentioning the subject/agent. ('I am being ____en')",
                 },
@@ -405,6 +487,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                     form: conj.passive.perfective.nonImperative,
                     sentence: true,
                     passive: true,
+                    englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                        `that ${engSubj(s, true)} will${n ? " not" : ""} be ${v[4]}`,
+                    ]),
                     formula: "Long Perfective Root + Subjunctive کېدل - to become",
                     explanation: "Saying that something should be done, or giving a purpose for something being done etc., without mentioning the subject/agent. ('Should I be ____en?', 'So that I'll be ____en')"
                 },
@@ -414,6 +499,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                     form: conj.passive.imperfective.future,
                     sentence: true,
                     passive: true,
+                    englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                        `${engSubj(s)} will${n ? " not" : ""} be ${v[4]}`,
+                    ]),
                     formula: "به - ba + Passive Present",
                     explanation: "Saying something will be done as a one-time event, without mentioning the subject/agent.",
                 },
@@ -423,6 +511,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                     form: conj.passive.perfective.future,
                     sentence: true,
                     passive: true,
+                    englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                        `${engSubj(s)} will${n ? " not" : ""} be ${v[4]}`,
+                    ]),
                     formula: "به - ba + Passive Subjunctive",
                     explanation: "Saying something will be done in an ongoing or repeated sense, without mentioning the subject/agent."
                 },
@@ -433,6 +524,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                     past: true,
                     sentence: true,
                     passive: true,
+                    englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                        `${engSubj(s)} ${engEquative("past", s)}${n ? " not" : ""} being ${v[4]}`,
+                    ]),
                     formula: "Long Imperfective Root + Continuous Past کېدل - to become",
                     explanation: "Saying that something was being done, or would be done, without mentioning the subject/agent. ('I was being ____en', 'I would be ____en')",    
                 },
@@ -443,6 +537,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                     past: true,
                     sentence: true,
                     passive: true,
+                    englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                        `${engSubj(s)} ${engEquative("past", s)}${n ? " not" : ""} ${v[4]}`,
+                    ]),
                     formula: "Long Perfective Root + Simple Past کېدل - to become",
                     explanation: "Saying that was done as a one-time event, without mentioning the subject/agent. ('I was ____en')"
                 },
@@ -458,6 +555,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                             past: true,
                             sentence: true,
                             passive: true,
+                            englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                                `${engSubj(s)} ${engHave(s)}${n ? " not" : ""} been ${v[4]}`,
+                            ]),
                             formula: "Infinitive + کېدل (to be) past participle inflected",
                             explanation: "The base of all perfect forms. Used on it's own as a sort of weaker form of the present perfect. (Passive voice)",
                         },
@@ -467,6 +567,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                             past: true,
                             sentence: true,
                             passive: true,
+                            englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                                `${engSubj(s)} had${n ? " not" : ""} been ${v[4]}`,
+                            ]),
                             formula: "Infinitive + کېدل (to be) past participle inflected + Past Equative",
                             explanation: "Talking about events that had happened in the past, or had affected a past situation (Passive voice) ('I had been ____ed')",
                         },
@@ -476,6 +579,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                             past: true,
                             sentence: true,
                             passive: true,
+                            englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                                `${engSubj(s)} ${engHave(s)}${n ? " not" : ""} been ${v[4]}`,
+                            ]),
                             formula: "Infinitive + کېدل (to be) past participle inflected + Present Equative",
                             explanation: "Talking about that something happened in the past and it affects the present (Passive voice) ('I have been _____ed')",
                         },
@@ -485,6 +591,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                             past: true,
                             sentence: true,
                             passive: true,
+                            englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                                `that ${engSubj(s, true)} will have been ${v[4]}`,
+                            ]),
                             formula: "Infinitive + کېدل (to be) past participle inflected + Subjunctive/Habitual Equative",
                         },
                         {
@@ -494,6 +603,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                             past: true,
                             sentence: true,
                             passive: true,
+                            englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                                `${engSubj(s)} will have been ${v[4]}`,
+                            ]),
                             formula: "به - ba + Infinitive + کېدل (to be) past participle inflected + Future Equative",
                             explanation: "Talking about something that will have happened in the future, or guessing that the event will have occured presently (Passive voice) ('I will have been ____ed')",
                         },
@@ -504,6 +616,9 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
                             past: true,
                             sentence: true,
                             passive: true,
+                            englishBuilder: (s: T.Person, v: T.EnglishVerbConjugation, n: boolean) => ([
+                                `${engSubj(s)} will have been ${v[4]}`,
+                            ]),
                             explanation: "Affirming that an event will have taken place (Passive voice) ('I will have been ____ed')",
                             formula: "به - ba + Infinitive + کېدل (to be) past participle inflected + Past Equative"
                         },
@@ -522,18 +637,74 @@ export const getForms = ({ conj, filterFunc, mode, subject, object, negative } :
             ]
         } as T.DisplayFormSubgroup]
         : [],
-    ];
+];
-    const initialFilter = filterFunc
+
+export const getForms = ({ conj, filterFunc, mode, subject, object, englishConjugation, negative } : {
+    conj: T.VerbConjugation,
+    englishConjugation?: T.EnglishVerbConjugation
+    filterFunc?: FilterFunc | FilterFunc[],
+    mode: "chart" | "sentence",
+    subject: T.Person,
+    object: T.Person,
+    negative: boolean,
+}): T.DisplayFormItem[] => {
+    const forms = formsOfConjugation(conj);
+    const formsToUse = filterFunc
         ? formFilter(forms, filterFunc)
         : forms;
     return mode === "chart"
-        ? initialFilter
+        ? formsToUse
         : formMap(
-            formFilter(initialFilter, (f) => f.sentence),
+            // TODO: somewhere in one of these the english conjugations are being stripped out for the past tense items
+            formFilter(formsToUse, (f) => f.sentence),
             makeSentence,
             conj.info,
             subject,
             object,
             negative,
+            englishConjugation,
         );
 }
+
+function isThirdPerson(p: T.Person): boolean {
+    return (
+        p === T.Person.ThirdSingMale ||
+        p === T.Person.ThirdSingFemale ||
+        p === T.Person.ThirdPlurMale ||
+        p === T.Person.ThirdPlurFemale
+    );
+}
+
+function engPresC(s: T.Person, ec: T.EnglishVerbConjugation | [string, string]): string {
+    return isThirdPerson(s) ? ec[1] : ec[0];
+}
+
+function engEquative(tense: "past" | "present", s: T.Person): string {
+    const [row, col] = getBlockRowCol(s);
+    return englishEquative[tense][row][col];
+}
+
+function engHave(s: T.Person): string {
+    return isThirdPerson(s) ? "has" : "have";
+}
+
+function engSubj(s: T.Person, lowerCase?: boolean): string {
+    const pronoun = (s === T.Person.FirstSingMale || s === T.Person.FirstSingFemale)
+        ? "I"
+        : (s === T.Person.FirstPlurMale || s === T.Person.FirstPlurFemale)
+        ? "We"
+        : (s === T.Person.SecondSingMale || s === T.Person.SecondSingFemale)
+        ? "You"
+        : (s === T.Person.SecondPlurMale || s === T.Person.SecondPlurFemale)
+        ? "You (pl.)"
+        : (s === T.Person.ThirdSingMale)
+        ? "He/it"
+        : (s === T.Person.ThirdSingFemale)
+        ? "She/it"
+        : (s === T.Person.ThirdPlurMale)
+        ? "They"
+        : "They (f.)";
+    return (lowerCase && pronoun !== "I")
+        ? pronoun.toLowerCase()
+        : pronoun;
+}

src/lib/grammar-units.ts

@@ -149,6 +149,31 @@ export const subjPastEquative: T.PsString = {
     f: "w" + aayTail.f,
 };
 
+export const englishEquative: {
+    past: T.EnglishBlock,
+    present: T.EnglishBlock,
+    // present: T.VerbBlock,
+    // subjunctive: T.VerbBlock,
+    // hypothetical: T.VerbBlock,
+} = {
+    past: [
+        ["was", "were"],
+        ["was", "were"],
+        ["were", "were"],
+        ["were", "were"],
+        ["was", "were"],
+        ["was", "were"],
+    ],
+    present: [
+        ["am", "are"],
+        ["am", "are"],
+        ["are", "are"],
+        ["are", "are"],
+        ["is", "are"],
+        ["is", "are"],
+    ],
+}
+
 export const equativeEndings: {
     past: T.LengthOptions<T.VerbBlock>,
     present: T.VerbBlock,

src/lib/misc-helpers.test.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2021 lingdocs.com
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+ import {
+    parseEc,
+} from "./misc-helpers";
+
+test("parseEc should work", () => {
+    expect(parseEc("walk")).toEqual(["walk", "walks", "walking", "walked", "walked"]);
+    expect(parseEc("scare")).toEqual(["scare", "scares", "scaring", "scared", "scared"]);
+    expect(parseEc("sew,sews,sewing,sewed,sown")).toEqual(["sew", "sews", "sewing", "sewed", "sown"]);
+    expect(parseEc(" sew, sews,sewing ,sewed, sown")).toEqual(["sew", "sews", "sewing", "sewed", "sown"]);
+});

src/lib/misc-helpers.ts

@@ -206,6 +206,30 @@ export function isNounAdjOrVerb(entry: T.DictionaryEntry): "nounAdj" | "verb" |
     return false;
 }
 
+/**
+ * takes the ec field from a dictionary entry and produces an array of an EnglishVerbConjugation
+ * for use with the conjugations display for showing English translation sentences of various verb
+ * forms and conjugations
+ * 
+ * @param ec 
+ * @returns 
+ */
+export function parseEc(ec: string | undefined): T.EnglishVerbConjugation | undefined {
+    function makeRegularConjugations(s: string): T.EnglishVerbConjugation {
+        const b = (s.slice(-1) === "e")
+            ? s.slice(0, -1)
+            : s;
+        return [`${s}`, `${s}s`, `${b}ing`, `${b}ed`, `${b}ed`];
+    }
+    if (!ec) {
+        return undefined;
+    }
+    const items = ec.split(",").map(x => x.trim());
+    return (items.length !== 5)
+        ? makeRegularConjugations(items[0])
+        : [items[0], items[1], items[2], items[3], items[4]];
+}
+
 // not being used
 // export function isImperativeBlock(f: any): boolean {
 //     function isPersonLine(g: any): boolean {

src/types.ts

@@ -106,6 +106,9 @@ export type DictionaryEntry = {
     // PHONETICS - PASHTO - DIACRITICS INFO
     /** Is an exception to the rules of diacritics for Pashto/Phonetics */
     diacExcept?: boolean;
+
+    /** the English conjugations of a verb comma seperated set of 5 ie. "see,sees,seeing,saw,seen" or single word ie. "walk" if regular */
+    ec?: string;
 }
 
 export type DictionaryEntryTextField = "p" | "f" | "e" | "c" | "infap" | "infaf" | "infbp" | "infbf" | "app" | "apf" | "ppp" | "ppf" | "psp" | "psf" | "ssp" | "ssf" | "prp" | "prf" | "pprtp" | "pprtf" | "tppp" | "tppf";
@@ -383,6 +386,9 @@ export type ArrayOneOrMore<T> = {
     0: T
 } & Array<T>
 
+/* i.e. ["eat", "eats", "eating", "ate", "eaten"] */
+export type EnglishVerbConjugation = [string, string, string, string, string];
+
 export type DisplayFormItem = DisplayForm | DisplayFormSubgroup | DisplayFormForSentence;
 
 export type DisplayForm = { 
@@ -390,6 +396,7 @@ export type DisplayForm = {
     aspect?: Aspect,
     form: VerbForm | ImperativeForm | ParticipleForm | SentenceForm,
     advanced?: boolean,
+    englishBuilder?: (subject: Person, ec: EnglishVerbConjugation, neg: boolean) => string[],
     formula: React.ReactNode,
     explanation: React.ReactNode,
     sentence?: boolean,
@@ -402,6 +409,7 @@ export type DisplayFormForSentence = {
     aspect?: Aspect,
     form: VerbForm,
     advanced?: boolean,
+    englishBuilder?: (subject: Person, ec: EnglishVerbConjugation, neg: boolean) => string[],
     formula: React.ReactNode,
     secondPronounNeeded?: boolean,
     explanation: React.ReactNode,