lingdocs
/
pashto-inflector
mirror of https://github.com/lingdocs/pashto-inflector.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: lingdocs:c5a238ab05c06eb448878ed87235254760aa6737
Branches Tags
lingdocs:master
lingdocs:adueck-patch-1
lingdocs:parser
..
compare: lingdocs:e40b3832760aa8228c4a73ce853616934c28a1b4
Branches Tags
lingdocs:master
lingdocs:adueck-patch-1
lingdocs:parser

No commits in common. "c5a238ab05c06eb448878ed87235254760aa6737" and "e40b3832760aa8228c4a73ce853616934c28a1b4" have entirely different histories.
c5a238ab05 ... e40b383276

30 changed files with 906 additions and 1464 deletions
Show Stats Expand all files Collapse all files

1
.github/workflows/publish.yml vendored
View File

@ -30,7 +30,6 @@ jobs:
yarn install-r yarn install-r
yarn build-library yarn build-library
yarn test --silent yarn test --silent
yarn check-all-inflections
cp .npmrc src/lib cp .npmrc src/lib
cp .npmrc src/components cp .npmrc src/components
cd src/lib cd src/lib

2
package.json
View File

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

4
src/components/package-lock.json generated
View File

@ -1,12 +1,12 @@
{ {
"name": "@lingdocs/ps-react", "name": "@lingdocs/ps-react",
"version": "7.5.1", "version": "7.4.1",
"lockfileVersion": 2, "lockfileVersion": 2,
"requires": true, "requires": true,
"packages": { "packages": {
"": { "": {
"name": "@lingdocs/ps-react", "name": "@lingdocs/ps-react",
"version": "7.5.1", "version": "7.4.1",
"license": "MIT", "license": "MIT",
"dependencies": { "dependencies": {
"@formkit/auto-animate": "^1.0.0-beta.3", "@formkit/auto-animate": "^1.0.0-beta.3",

2
src/components/package.json
View File

@ -1,6 +1,6 @@
{ {
"name": "@lingdocs/ps-react", "name": "@lingdocs/ps-react",
"version": "7.5.1", "version": "7.4.1",
"description": "Pashto inflector library module with React components", "description": "Pashto inflector library module with React components",
"main": "dist/components/library.js", "main": "dist/components/library.js",
"module": "dist/components/library.js", "module": "dist/components/library.js",

227
src/components/src/ComplementPicker.tsx
View File

@ -3,150 +3,105 @@ import * as T from "../../types";
import AdjectivePicker from "./np-picker/AdjectivePicker"; import AdjectivePicker from "./np-picker/AdjectivePicker";
import LocativeAdverbPicker from "./ep-explorer/eq-comp-picker/LocativeAdverbPicker"; import LocativeAdverbPicker from "./ep-explorer/eq-comp-picker/LocativeAdverbPicker";
import SandwichPicker from "./np-picker/SandwichPicker"; import SandwichPicker from "./np-picker/SandwichPicker";
const compTypes: T.ComplementType[] = [ const compTypes: T.ComplementType[] = ["adjective", "loc. adv.", "sandwich", "comp. noun"];
"adjective",
"loc. adv.",
"sandwich",
"comp. noun",
];
function selectionTypeToCompType( function selectionTypeToCompType(s: Exclude<T.ComplementType, "comp. noun"> | "noun"): T.ComplementType {
s: Exclude<T.ComplementType, "comp. noun"> | "noun" if (s === "noun") return "comp. noun";
): T.ComplementType { return s;
if (s === "noun") return "comp. noun";
return s;
} }
function ComplementPicker(props: { function ComplementPicker(props: {
phraseIsComplete: boolean; phraseIsComplete: boolean,
onChange: (comp: T.ComplementSelection | undefined) => void; onChange: (comp: T.ComplementSelection | undefined) => void,
comp: T.ComplementSelection | undefined; comp: T.ComplementSelection | undefined,
opts: T.TextOptions; opts: T.TextOptions,
cantClear?: boolean; cantClear?: boolean,
heading?: JSX.Element | string; heading?: JSX.Element | string,
entryFeeder: T.EntryFeeder; entryFeeder: T.EntryFeeder,
negative: boolean;
}) { }) {
const [compType, setCompType] = useState<T.ComplementType | undefined>( const [compType, setCompType] = useState<T.ComplementType | undefined>(props.comp
props.comp ? selectionTypeToCompType(props.comp.selection.type) : undefined
);
useEffect(() => {
setCompType(
props.comp
? selectionTypeToCompType(props.comp.selection.type) ? selectionTypeToCompType(props.comp.selection.type)
: undefined : undefined);
); useEffect(() => {
}, [props.comp]); setCompType(props.comp
function handleClear() { ? selectionTypeToCompType(props.comp.selection.type)
setCompType(undefined); : undefined);
props.onChange(undefined); }, [props.comp]);
} function handleClear() {
function handleCompTypeChange(ctp: T.ComplementType) { setCompType(undefined);
props.onChange(undefined); props.onChange(undefined);
setCompType(ctp); }
} function handleCompTypeChange(ctp: T.ComplementType) {
function handleSandwichExit() { props.onChange(undefined);
setCompType(undefined); setCompType(ctp);
props.onChange(undefined); }
} function handleSandwichExit() {
const clearButton = setCompType(undefined);
compType && !props.cantClear ? ( props.onChange(undefined);
<button className="btn btn-sm btn-light mb-2" onClick={handleClear}> }
X const clearButton = (compType && !props.cantClear)
</button> ? <button className="btn btn-sm btn-light mb-2" onClick={handleClear}>X</button>
) : ( : <div></div>;
<div></div> return <>
); <div className="d-flex flex-row justify-content-between">
return ( <div></div>
<> <div>
<div className="d-flex flex-row justify-content-between"> {typeof props.heading === "string"
<div></div> ? <div className="h5 text-center">{props.heading}</div>
<div> : props.heading}
{typeof props.heading === "string" ? ( </div>
<div className="h5 text-center">{props.heading}</div> <div>
) : ( {clearButton}
props.heading
)}
</div>
<div>{clearButton}</div>
</div>
{!compType && (
<div className="text-center">
<div className="h6 mr-3">Choose Complement</div>
{compTypes.map((cpt) => (
<div key={cpt} className="mb-2">
<button
key={cpt}
type="button"
className="mr-2 btn btn-sm btn-outline-secondary"
onClick={() => handleCompTypeChange(cpt)}
>
{cpt}
</button>
</div> </div>
))}
</div> </div>
)} {!compType && <div className="text-center">
<div style={{ minWidth: "9rem" }}> <div className="h6 mr-3">
{compType === "adjective" ? ( Choose Complement
<AdjectivePicker </div>
entryFeeder={props.entryFeeder} {compTypes.map((cpt) => <div key={cpt} className="mb-2">
adjective={ <button
props.comp?.selection.type === "adjective" key={cpt}
? props.comp.selection type="button"
: undefined className="mr-2 btn btn-sm btn-outline-secondary"
} onClick={() => handleCompTypeChange(cpt)}
opts={props.opts} >
onChange={(a) => {cpt}
props.onChange( </button>
a ? { type: "complement", selection: a } : undefined </div>)}
) </div>}
} <div style={{ minWidth: "9rem" }}>
phraseIsComplete={props.phraseIsComplete} {compType === "adjective" ?
negative={props.negative} <AdjectivePicker
/> entryFeeder={props.entryFeeder}
) : compType === "loc. adv." ? ( adjective={props.comp?.selection.type === "adjective" ? props.comp.selection : undefined}
<LocativeAdverbPicker opts={props.opts}
entryFeeder={props.entryFeeder.locativeAdverbs} onChange={(a) => props.onChange(a ? { type: "complement", selection: a } : undefined)}
adjective={ phraseIsComplete={props.phraseIsComplete}
props.comp?.selection.type === "loc. adv." />
? props.comp.selection : compType === "loc. adv."
: undefined ? <LocativeAdverbPicker
} entryFeeder={props.entryFeeder.locativeAdverbs}
opts={props.opts} adjective={props.comp?.selection.type === "loc. adv." ? props.comp.selection : undefined}
onChange={(a) => opts={props.opts}
props.onChange( onChange={(a) => props.onChange(a ? { type: "complement", selection: a } : undefined)}
a ? { type: "complement", selection: a } : undefined />
) : compType === "sandwich"
} ? <SandwichPicker
/> onChange={(a) => props.onChange(a ? { type: "complement", selection: a } : undefined)}
) : compType === "sandwich" ? ( opts={props.opts}
<SandwichPicker sandwich={props.comp?.selection.type === "sandwich" ? props.comp.selection : undefined}
onChange={(a) => entryFeeder={props.entryFeeder}
props.onChange( onExit={handleSandwichExit}
a ? { type: "complement", selection: a } : undefined // TODO: get phraseIsComplete working here
) phraseIsComplete={props.phraseIsComplete}
} />
opts={props.opts} : compType === "comp. noun"
sandwich={ ? <div style={{ maxWidth: "9rem" }}>
props.comp?.selection.type === "sandwich" Sorry, can't choose complement nouns yet 🚧
? props.comp.selection </div>
: undefined : null}
} </div>
entryFeeder={props.entryFeeder} </>;
onExit={handleSandwichExit}
// TODO: get phraseIsComplete working here
phraseIsComplete={props.phraseIsComplete}
negative={props.negative}
/>
) : compType === "comp. noun" ? (
<div style={{ maxWidth: "9rem" }}>
Sorry, can't choose complement nouns yet 🚧
</div>
) : null}
</div>
</>
);
} }
export default ComplementPicker; export default ComplementPicker;

396
src/components/src/EntrySelect.tsx
View File

@ -3,259 +3,183 @@ import { StyleHTMLAttributes } from "react";
import Select, { StylesConfig } from "react-select"; import Select, { StylesConfig } from "react-select";
import AsyncSelect from "react-select/async"; import AsyncSelect from "react-select/async";
import { import {
makeSelectOption, makeSelectOption,
makeVerbSelectOption, makeVerbSelectOption,
} from "./np-picker/picker-tools"; } from "./np-picker/picker-tools";
export const customStyles: StylesConfig = { export const customStyles: StylesConfig = {
menuPortal: (base: any) => ({ menuPortal: (base: any) => ({
...base, ...base,
zIndex: 99999, zIndex: 99999,
}), }),
menu: (base: any) => ({ menu: (base: any) => ({
...base, ...base,
zIndex: 999999, zIndex: 999999,
}), }),
option: (provided: any, state: any) => ({ option: (provided: any, state: any) => ({
...provided, ...provided,
padding: "10px 5px", padding: "10px 5px",
color: "#121418", color: "#121418",
}), }),
input: (base: any) => ({ input: (base: any) => ({
...base, ...base,
padding: 0, padding: 0,
}), }),
};
function EntrySelect<E extends T.DictionaryEntry | T.VerbEntry>(props: {
entryFeeder: T.EntryFeederSingleType<E>;
value: E | undefined;
onChange: (value: E | undefined) => void;
name: string | undefined;
isVerbSelect?: boolean;
opts: T.TextOptions;
style?: StyleHTMLAttributes<HTMLDivElement>;
placeholder?: string;
}) {
const divStyle = props.style || { width: "13rem" };
const placeholder =
"placeholder" in props
? props.placeholder
: "search" in props.entryFeeder
? "Search Pashto"
: "Search…";
function makeOption(e: E | T.DictionaryEntry) {
if ("entry" in e) {
return (props.isVerbSelect ? makeVerbSelectOption : makeSelectOption)(
e,
props.opts
);
}
return makeSelectOption(e, props.opts);
}
const value = props.value ? makeOption(props.value) : undefined;
if ("search" in props.entryFeeder) {
const search = props.entryFeeder.search;
const getByTs = props.entryFeeder.getByTs;
const options = (searchString: string) =>
new Promise<{ value: string; label: string | JSX.Element }[]>(
(resolve) => {
resolve(search(searchString).map(makeOption));
}
);
const onChange = (
v: { label: string | JSX.Element; value: string } | null
) => {
if (!v) {
props.onChange(undefined);
return;
}
const s = getByTs(parseInt(v.value));
if (!s) return;
props.onChange(s);
};
return (
<div style={divStyle}>
<AsyncSelect
styles={customStyles}
isSearchable={true}
className="mb-2"
value={value}
// @ts-ignore
onChange={onChange}
defaultOptions={[]}
loadOptions={options}
placeholder={placeholder}
/>
</div>
);
}
const entries = props.entryFeeder;
const options = entries
.sort((a, b) => {
if ("entry" in a) {
return a.entry.p.localeCompare("p" in b ? b.p : b.entry.p, "af-PS");
}
return a.p.localeCompare("p" in b ? b.p : b.entry.p, "af-PS");
})
.map(makeOption);
const onChange = (
v: { label: string | JSX.Element; value: string } | null
) => {
if (!v) {
props.onChange(undefined);
return;
}
const s = entries.find((e) =>
"entry" in e
? e.entry.ts.toString() === v.value
: e.ts.toString() === v.value
);
if (!s) return;
props.onChange(s);
};
return (
<div style={divStyle}>
<Select
styles={customStyles}
isSearchable={true}
value={value || null}
// @ts-ignore - sadly gets messed up when using customStyles
onChange={onChange}
className="mb-2"
options={options}
placeholder={placeholder}
/>
</div>
);
} }
export function DeterminerSelect(props: { function EntrySelect<E extends T.DictionaryEntry | T.VerbEntry>(props: {
determiners: Readonly<T.Determiner[]>; entryFeeder: T.EntryFeederSingleType<E>,
value: T.Determiner[]; value: E | undefined,
onChange: (value: T.Determiner[] | undefined) => void; onChange: (value: E | undefined) => void,
name: string | undefined; name: string | undefined,
opts: T.TextOptions; isVerbSelect?: boolean,
opts: T.TextOptions,
style?: StyleHTMLAttributes<HTMLDivElement>,
placeholder?: string,
}) { }) {
const placeholder = "Select determiner…"; const divStyle = props.style || { width: "13rem" };
const value = props.value ? props.value.map(makeDeterminerOption) : undefined; const placeholder = "placeholder" in props
const options = props.determiners.map(makeDeterminerOption); ? props.placeholder
const onChange = ( : "search" in props.entryFeeder
v: { label: string | JSX.Element; value: string }[] | null ? "Search Pashto"
) => { : "Search…";
if (!v) { function makeOption(e: E | T.DictionaryEntry) {
props.onChange(undefined); if ("entry" in e) {
return; return (props.isVerbSelect ? makeVerbSelectOption : makeSelectOption)(e, props.opts);
}
return makeSelectOption(e, props.opts);
} }
const dets: T.Determiner[] = v.map( const value = props.value ? makeOption(props.value) : undefined;
({ value }) => JSON.parse(value) as T.Determiner if ("search" in props.entryFeeder) {
); const search = props.entryFeeder.search;
props.onChange(dets); const getByTs = props.entryFeeder.getByTs;
}; const options = (searchString: string) =>
return ( new Promise<{ value: string, label: string | JSX.Element }[]>(resolve => {
<Select resolve(search(searchString).map(makeOption));
name={props.name} });
styles={customStyles} const onChange = (v: { label: string | JSX.Element, value: string } | null) => {
isSearchable={true} if (!v) {
value={value} props.onChange(undefined);
isMulti return;
// @ts-ignore - gets messed up when using customStyles }
onChange={onChange} const s = getByTs(parseInt(v.value));
className="mb-2" if (!s) return;
options={options} props.onChange(s);
placeholder={placeholder} }
/> return <div style={divStyle}>
); <AsyncSelect
styles={customStyles}
isSearchable={true}
className="mb-2"
value={value}
// @ts-ignore
onChange={onChange}
defaultOptions={[]}
loadOptions={options}
placeholder={placeholder}
/>
</div>;
}
const entries = props.entryFeeder;
const options = entries
.sort((a, b) => {
if ("entry" in a) {
return a.entry.p.localeCompare("p" in b ? b.p : b.entry.p, "af-PS")
}
return a.p.localeCompare("p" in b ? b.p : b.entry.p, "af-PS");
})
.map(makeOption);
const onChange = (v: { label: string | JSX.Element, value: string } | null) => {
if (!v) {
props.onChange(undefined);
return;
}
const s = entries.find(e => (
("entry" in e)
? e.entry.ts.toString() === v.value
: e.ts.toString() === v.value
));
if (!s) return;
props.onChange(s);
}
return <div style={divStyle}>
<Select
styles={customStyles}
isSearchable={true}
value={value || null}
// @ts-ignore - gets messed up when using customStyles
onChange={onChange}
className="mb-2"
options={options}
placeholder={placeholder}
/>
</div>
} }
export function SandwichSelect<E extends T.Sandwich>(props: { export function SandwichSelect<E extends T.Sandwich>(props: {
sandwiches: E[]; sandwiches: E[],
value: E | undefined; value: E | undefined,
onChange: (value: E | undefined) => void; onChange: (value: E | undefined) => void,
name: string | undefined; name: string | undefined,
opts: T.TextOptions; opts: T.TextOptions,
style?: StyleHTMLAttributes<HTMLDivElement>; style?: StyleHTMLAttributes<HTMLDivElement>,
}) { }) {
const divStyle = props.style || { width: "13rem" }; const divStyle = props.style || { width: "13rem" };
const placeholder = "Select Sandwich…"; const placeholder = "Select Sandwich…";
const value = props.value ? makeSandwichOption(props.value) : undefined; const value = props.value ? makeSandwichOption(props.value) : undefined;
const options = props.sandwiches const options = props.sandwiches
// .sort((a, b) => { // .sort((a, b) => {
// if ("entry" in a) { // if ("entry" in a) {
// return a.before.p.localeCompare("p" in b ? b.p : b.entry.p, "af-PS") // return a.before.p.localeCompare("p" in b ? b.p : b.entry.p, "af-PS")
// } // }
// return a.p.localeCompare("p" in b ? b.p : b.entry.p, "af-PS"); // return a.p.localeCompare("p" in b ? b.p : b.entry.p, "af-PS");
// }) // })
.map(makeSandwichOption); .map(makeSandwichOption);
const onChange = ( const onChange = (v: { label: string | JSX.Element, value: string } | null) => {
v: { label: string | JSX.Element; value: string } | null if (!v) {
) => { props.onChange(undefined);
if (!v) { return;
props.onChange(undefined); }
return; const s = props.sandwiches.find(e => {
const sValue = JSON.parse(v.value) as T.Sandwich;
if (sValue.type !== "sandwich") throw new Error("error converting selected sandwich value to a sandwich");
return sandwichSideEq(e.before, sValue.before)
&& sandwichSideEq(e.after, sValue.after)
&& (e.e === sValue.e);
});
if (!s) return;
props.onChange(s);
} }
const s = props.sandwiches.find((e) => { return <div style={divStyle}>
const sValue = JSON.parse(v.value) as T.Sandwich; <div>Sandwich Base</div>
if (sValue.type !== "sandwich") <Select
throw new Error( styles={customStyles}
"error converting selected sandwich value to a sandwich" isSearchable={true}
); value={value}
return ( // @ts-ignore - gets messed up when using customStyles
sandwichSideEq(e.before, sValue.before) && onChange={onChange}
sandwichSideEq(e.after, sValue.after) && className="mb-2"
e.e === sValue.e options={options}
); placeholder={placeholder}
}); />
if (!s) return;
props.onChange(s);
};
return (
<div style={divStyle}>
<div>Sandwich Base</div>
<Select
styles={customStyles}
isSearchable={true}
value={value}
// @ts-ignore - gets messed up when using customStyles
onChange={onChange}
className="mb-2"
options={options}
placeholder={placeholder}
/>
</div> </div>
);
} }
function sandwichSideEq( function sandwichSideEq(s1: T.PsString | undefined, s2: T.PsString | undefined): boolean {
s1: T.PsString | undefined, if (s1 === undefined && s2 === undefined) {
s2: T.PsString | undefined return true
): boolean { }
if (s1 === undefined && s2 === undefined) { if (typeof s1 === "object" && typeof s2 === "object" && s1.p === s2.p) {
return true; return true;
} }
if (typeof s1 === "object" && typeof s2 === "object" && s1.p === s2.p) { return false;
return true;
}
return false;
} }
function makeDeterminerOption(d: T.Determiner): { function makeSandwichOption(s: T.Sandwich): { label: string, value: string } {
label: string; return {
value: string; label: `${s.before ? s.before.p : ""} ... ${s.after ? s.after.p : ""} (${s.e})`,
} { value: JSON.stringify(s),
return { };
label: `${d.p} - ${d.f}`,
value: JSON.stringify(d),
};
}
function makeSandwichOption(s: T.Sandwich): { label: string; value: string } {
return {
label: `${s.before ? s.before.p : ""} ... ${s.after ? s.after.p : ""} (${
s.e
})`,
value: JSON.stringify(s),
};
} }
export default EntrySelect; export default EntrySelect;

181
src/components/src/ap-picker/APPicker.tsx
View File

@ -6,112 +6,89 @@ type APType = "adverb" | "sandwich";
const types: APType[] = ["adverb", "sandwich"]; const types: APType[] = ["adverb", "sandwich"];
function APPicker(props: { function APPicker(props: {
phraseIsComplete: boolean; phraseIsComplete: boolean,
onChange: (comp: T.APSelection | undefined) => void; onChange: (comp: T.APSelection | undefined) => void,
AP: T.APSelection | undefined; AP: T.APSelection | undefined,
opts: T.TextOptions; opts: T.TextOptions,
cantClear?: boolean; cantClear?: boolean,
heading?: JSX.Element | string; heading?: JSX.Element | string,
entryFeeder: T.EntryFeeder; entryFeeder: T.EntryFeeder,
onRemove: () => void; onRemove: () => void,
negative: boolean;
}) { }) {
const [type, setType] = useState<APType | undefined>( const [type, setType] = useState<APType | undefined>(props.AP
props.AP ? props.AP.selection.type : undefined ? props.AP.selection.type
); : undefined);
useEffect(() => { useEffect(() => {
setType(props.AP ? props.AP.selection.type : undefined); setType(props.AP
}, [props.AP]); ? props.AP.selection.type
function handleClear() { : undefined);
setType(undefined); }, [props.AP]);
props.onChange(undefined); function handleClear() {
} setType(undefined);
function handleCompTypeChange(ctp: APType) { props.onChange(undefined);
props.onChange(undefined); }
setType(ctp); function handleCompTypeChange(ctp: APType) {
} props.onChange(undefined);
function handleSandwichExit() { setType(ctp);
setType(undefined); }
props.onChange(undefined); function handleSandwichExit() {
} setType(undefined);
const clearButton = props.onChange(undefined);
type && !props.cantClear ? ( }
<button className="btn btn-sm btn-light mb-2" onClick={handleClear}> const clearButton = (type && !props.cantClear)
X ? <button className="btn btn-sm btn-light mb-2" onClick={handleClear}>X</button>
</button> : (!props.cantClear)
) : !props.cantClear ? ( ? <div>
<div> <div className="clickable" onClick={props.onRemove}><i className="fas fa-trash" /></div>
<div className="clickable" onClick={props.onRemove}>
<i className="fas fa-trash" />
</div> </div>
</div> : <div></div>;
) : ( return <>
<div></div> <div className="d-flex flex-row justify-content-between">
); <div></div>
return ( <div>
<> {typeof props.heading === "string"
<div className="d-flex flex-row justify-content-between"> ? <div className="h5 text-center">{props.heading}</div>
<div></div> : props.heading}
<div> </div>
{typeof props.heading === "string" ? ( <div>
<div className="h5 text-center">{props.heading}</div> {clearButton}
) : (
props.heading
)}
</div>
<div>{clearButton}</div>
</div>
{!type && (
<div className="text-center">
<div className="h6 mr-3">Choose AP</div>
{types.map((apt) => (
<div key={apt} className="mb-2">
<button
key={apt}
type="button"
className="mr-2 btn btn-sm btn-outline-secondary"
onClick={() => handleCompTypeChange(apt)}
>
{apt}
</button>
</div> </div>
))}
</div> </div>
)} {!type && <div className="text-center">
<div style={{ minWidth: "9rem" }}> <div className="h6 mr-3">
{type === "adverb" ? ( Choose AP
<AdverbPicker </div>
entryFeeder={props.entryFeeder.adverbs} {types.map((apt) => <div key={apt} className="mb-2">
adjective={ <button
props.AP?.selection.type === "adverb" key={apt}
? props.AP.selection type="button"
: undefined className="mr-2 btn btn-sm btn-outline-secondary"
} onClick={() => handleCompTypeChange(apt)}
opts={props.opts} >
onChange={(a) => {apt}
props.onChange(a ? { type: "AP", selection: a } : undefined) </button>
} </div>)}
/> </div>}
) : type === "sandwich" ? ( <div style={{ minWidth: "9rem" }}>
<SandwichPicker {type === "adverb" ?
onChange={(a) => <AdverbPicker
props.onChange(a ? { type: "AP", selection: a } : undefined) entryFeeder={props.entryFeeder.adverbs}
} adjective={props.AP?.selection.type === "adverb" ? props.AP.selection : undefined}
opts={props.opts} opts={props.opts}
sandwich={ onChange={(a) => props.onChange(a ? { type: "AP", selection: a } : undefined)}
props.AP?.selection.type === "sandwich" />
? props.AP.selection : type === "sandwich" ?
: undefined <SandwichPicker
} onChange={(a) => props.onChange(a ? { type: "AP", selection: a } : undefined)}
entryFeeder={props.entryFeeder} opts={props.opts}
phraseIsComplete={props.phraseIsComplete} sandwich={props.AP?.selection.type === "sandwich" ? props.AP.selection : undefined}
onExit={handleSandwichExit} entryFeeder={props.entryFeeder}
negative={props.negative} phraseIsComplete={props.phraseIsComplete}
/> onExit={handleSandwichExit}
) : null} />
</div> : null}
</> </div>
); </>;
} }
export default APPicker; export default APPicker;

32
src/components/src/blocks/Block.tsx
View File

@ -600,29 +600,23 @@ function Sandwich({
); );
} }
function Determiners({ function Demonstrative({
opts, opts,
script, script,
children, children,
}: { }: {
opts: T.TextOptions; opts: T.TextOptions;
script: "p" | "f"; script: "p" | "f";
children: T.Rendered<T.DeterminersSelection> | undefined; children: T.Rendered<T.DemonstrativeSelection> | undefined;
}) { }) {
if (!children || children.determiners.length === 0) { if (!children) {
return null; return null;
} }
return ( return (
<div className="text-center"> <div className="text-center">
<div className={`d-flex flex-row${script === "p" ? "-reverse" : ""}`}> <Border padding={"1rem"}>{children.ps[script]}</Border>
{children.determiners.map((d) => ( <div>DEM</div>
<div className="mx-1"> <SubText>{children.e}</SubText>
<Border padding={"1rem"}>{d.ps[0][script]}</Border>
<div>{"demonstrative" in d.determiner ? "DEM" : "DET"}</div>
<SubText>{d.e}</SubText>
</div>
))}
</div>
</div> </div>
); );
} }
@ -669,8 +663,8 @@ export function NPBlock({
np.selection.possesor && np.selection.possesor &&
!np.selection.possesor.shrunken !np.selection.possesor.shrunken
); );
const detsWithoutNoun = const demWithoutNoun =
np.selection.determiners && !np.selection.determiners.withNoun; np.selection.demonstrative && !np.selection.demonstrative.withNoun;
const elements = [ const elements = [
...(!inside ...(!inside
? [ ? [
@ -681,12 +675,12 @@ export function NPBlock({
</Possesors>, </Possesors>,
] ]
: []), : []),
<Determiners opts={opts} script={script}> <Demonstrative opts={opts} script={script}>
{np.selection.determiners} {np.selection.demonstrative ? np.selection.demonstrative : undefined}
</Determiners>, </Demonstrative>,
<div <div
style={{ style={{
opacity: detsWithoutNoun ? 0.5 : 1, opacity: demWithoutNoun ? 0.5 : 1,
}} }}
> >
<Adjectives opts={opts} script={script}> <Adjectives opts={opts} script={script}>
@ -695,7 +689,7 @@ export function NPBlock({
</div>, </div>,
<div <div
style={{ style={{
opacity: detsWithoutNoun ? 0.5 : 1, opacity: demWithoutNoun ? 0.5 : 1,
}} }}
className={np.selection.adjectives?.length ? "mx-1" : ""} className={np.selection.adjectives?.length ? "mx-1" : ""}
> >

248
src/components/src/ep-explorer/EPPicker.tsx
View File

@ -3,169 +3,109 @@ import NPPicker from "../np-picker/NPPicker";
import EquativePicker from "./EquativePicker"; import EquativePicker from "./EquativePicker";
import ButtonSelect from "../ButtonSelect"; import ButtonSelect from "../ButtonSelect";
import ComplementPicker from "../ComplementPicker"; import ComplementPicker from "../ComplementPicker";
import epsReducer, { import epsReducer, { EpsReducerAction } from "../../../lib/src/phrase-building/eps-reducer";
EpsReducerAction, import {
} from "../../../lib/src/phrase-building/eps-reducer"; useEffect,
import { useEffect, useRef } from "react"; useRef,
} from "react";
import { completeEPSelection } from "../../../lib/src/phrase-building/render-ep"; import { completeEPSelection } from "../../../lib/src/phrase-building/render-ep";
import APPicker from "../../src/ap-picker/APPicker"; import APPicker from "../../src/ap-picker/APPicker";
import autoAnimate from "@formkit/auto-animate"; import autoAnimate from "@formkit/auto-animate";
function EPPicker({ function EPPicker({ opts, eps, onChange, entryFeeder }: {
opts, opts: T.TextOptions,
eps, eps: T.EPSelectionState,
onChange, onChange: (eps: T.EPSelectionState) => void,
entryFeeder, entryFeeder: T.EntryFeeder,
}: {
opts: T.TextOptions;
eps: T.EPSelectionState;
onChange: (eps: T.EPSelectionState) => void;
entryFeeder: T.EntryFeeder;
}) { }) {
const parent = useRef<HTMLDivElement>(null); const parent = useRef<HTMLDivElement>(null);
useEffect(() => { useEffect(() => {
parent.current && autoAnimate(parent.current); parent.current && autoAnimate(parent.current);
}, [parent]); }, [parent]);
function adjustEps(action: EpsReducerAction) { function adjustEps(action: EpsReducerAction) {
onChange(epsReducer(eps, action)); onChange(epsReducer(eps, action));
} }
const phraseIsComplete = !!completeEPSelection(eps); const phraseIsComplete = !!completeEPSelection(eps);
return ( return <div>
<div> <div className="clickable h5" onClick={() => adjustEps({ type: "insert new AP" })}>+ AP</div>
<div <div ref={parent} className="d-flex flex-row justify-content-around flex-wrap" style={{ marginLeft: "-0.5rem", marginRight: "-0.5rem" }}>
className="clickable h5" {eps.blocks.map(({ block, key }, i) => (
onClick={() => adjustEps({ type: "insert new AP" })} <div className="my-2 card block-card p-1 mx-1" key={key}>
> <div className="d-flex flex-row justify-content-between mb-1" style={{ height: "1rem" }}>
+ AP {i > 0 ? <div
</div> className="small clickable ml-1"
<div onClick={() => adjustEps({ type: "shift block", payload: { index: i, direction: "back" }})}
ref={parent} >
className="d-flex flex-row justify-content-around flex-wrap" <i className="fas fa-chevron-left" />
style={{ marginLeft: "-0.5rem", marginRight: "-0.5rem" }} </div> : <div/>}
> {i < eps.blocks.length - 1 ? <div
{eps.blocks.map(({ block, key }, i) => ( className="small clickable mr-1"
<div className="my-2 card block-card p-1 mx-1" key={key}> onClick={() => adjustEps({ type: "shift block", payload: { index: i, direction: "forward" }})}
<div >
className="d-flex flex-row justify-content-between mb-1" <i className="fas fa-chevron-right" />
style={{ height: "1rem" }} </div> : <div/>}
> </div>
{i > 0 ? ( {block && block.type === "subjectSelection"
<div ? <NPPicker
className="small clickable ml-1" phraseIsComplete={phraseIsComplete}
onClick={() => heading={<div className="h5 text-center">Subject</div>}
adjustEps({ entryFeeder={entryFeeder}
type: "shift block", np={block.selection}
payload: { index: i, direction: "back" }, counterPart={undefined}
}) role="subject"
} onChange={payload => adjustEps({ type: "set subject", payload })}
> opts={opts}
<i className="fas fa-chevron-left" /> />
: <APPicker
phraseIsComplete={phraseIsComplete}
heading="AP"
entryFeeder={entryFeeder}
AP={block}
opts={opts}
onChange={AP => adjustEps({ type: "set AP", payload: { index: i, AP } })}
onRemove={() => adjustEps({ type: "remove AP", payload: i })}
/>}
</div> </div>
) : ( ))}
<div /> <div className="my-2 card block-card p-1">
)} <div className="h5 text-center">Predicate</div>
{i < eps.blocks.length - 1 ? ( <div className="mb-2 text-center">
<div <ButtonSelect
className="small clickable mr-1" small
onClick={() => options={[
adjustEps({ { value: "NP", label: "NP" },
type: "shift block", { value: "Complement", label: "Complement" },
payload: { index: i, direction: "forward" }, ]}
}) value={eps.predicate.type}
} handleChange={payload => adjustEps({ type: "set predicate type", payload })}
> />
<i className="fas fa-chevron-right" />
</div> </div>
) : ( {eps.predicate.type === "NP" ? <NPPicker
<div /> phraseIsComplete={phraseIsComplete}
)} entryFeeder={entryFeeder}
np={eps.predicate.type === "NP" ? eps.predicate.NP : undefined}
counterPart={undefined}
role="subject"
onChange={payload => adjustEps({ type: "set predicate NP", payload })}
opts={opts}
/> : <ComplementPicker
phraseIsComplete={phraseIsComplete}
comp={eps.predicate.type === "Complement" ? eps.predicate.Complement : undefined}
onChange={payload => adjustEps({ type: "set predicate complement", payload })}
opts={opts}
entryFeeder={entryFeeder}
/>}
</div>
<div className="my-2">
<div className="h5 text-center clickable">Equative</div>
<EquativePicker
equative={eps.equative}
onChange={payload => adjustEps({ type: "set equative", payload })}
hideNegative={false}
/>
</div> </div>
{block && block.type === "subjectSelection" ? (
<NPPicker
phraseIsComplete={phraseIsComplete}
heading={<div className="h5 text-center">Subject</div>}
entryFeeder={entryFeeder}
np={block.selection}
counterPart={undefined}
role="subject"
onChange={(payload) =>
adjustEps({ type: "set subject", payload })
}
opts={opts}
negative={eps.equative.negative}
/>
) : (
<APPicker
negative={eps.equative.negative}
phraseIsComplete={phraseIsComplete}
heading="AP"
entryFeeder={entryFeeder}
AP={block}
opts={opts}
onChange={(AP) =>
adjustEps({ type: "set AP", payload: { index: i, AP } })
}
onRemove={() => adjustEps({ type: "remove AP", payload: i })}
/>
)}
</div>
))}
<div className="my-2 card block-card p-1">
<div className="h5 text-center">Predicate</div>
<div className="mb-2 text-center">
<ButtonSelect
small
options={[
{ value: "NP", label: "NP" },
{ value: "Complement", label: "Complement" },
]}
value={eps.predicate.type}
handleChange={(payload) =>
adjustEps({ type: "set predicate type", payload })
}
/>
</div>
{eps.predicate.type === "NP" ? (
<NPPicker
phraseIsComplete={phraseIsComplete}
entryFeeder={entryFeeder}
np={eps.predicate.type === "NP" ? eps.predicate.NP : undefined}
counterPart={undefined}
role="subject"
onChange={(payload) =>
adjustEps({ type: "set predicate NP", payload })
}
opts={opts}
negative={eps.equative.negative}
/>
) : (
<ComplementPicker
phraseIsComplete={phraseIsComplete}
comp={
eps.predicate.type === "Complement"
? eps.predicate.Complement
: undefined
}
onChange={(payload) =>
adjustEps({ type: "set predicate complement", payload })
}
opts={opts}
entryFeeder={entryFeeder}
negative={eps.equative.negative}
/>
)}
</div> </div>
<div className="my-2"> </div>;
<div className="h5 text-center clickable">Equative</div>
<EquativePicker
equative={eps.equative}
onChange={(payload) => adjustEps({ type: "set equative", payload })}
hideNegative={false}
/>
</div>
</div>
</div>
);
} }
export default EPPicker; export default EPPicker;

3
src/components/src/np-picker/AdjectiveManager.tsx
View File

@ -8,7 +8,6 @@ function AdjectiveManager(props: {
opts: T.TextOptions; opts: T.TextOptions;
onChange: (adjs: T.AdjectiveSelection[]) => void; onChange: (adjs: T.AdjectiveSelection[]) => void;
phraseIsComplete: boolean; phraseIsComplete: boolean;
negative: boolean;
}) { }) {
const [adding, setAdding] = useState<boolean>(false); const [adding, setAdding] = useState<boolean>(false);
function handleChange(i: number) { function handleChange(i: number) {
@ -49,7 +48,6 @@ function AdjectiveManager(props: {
entryFeeder={props.entryFeeder} entryFeeder={props.entryFeeder}
opts={props.opts} opts={props.opts}
onChange={handleAddNew} onChange={handleAddNew}
negative={props.negative}
/> />
</div> </div>
)} )}
@ -72,7 +70,6 @@ function AdjectiveManager(props: {
</div> </div>
</div> </div>
<AdjectivePicker <AdjectivePicker
negative={props.negative}
phraseIsComplete={props.phraseIsComplete} phraseIsComplete={props.phraseIsComplete}
noTitle noTitle
key={`adj${i}`} key={`adj${i}`}

116
src/components/src/np-picker/AdjectivePicker.tsx
View File

@ -5,74 +5,64 @@ import EntrySelect from "../EntrySelect";
import SandwichPicker from "./SandwichPicker"; import SandwichPicker from "./SandwichPicker";
function AdjectivePicker(props: { function AdjectivePicker(props: {
entryFeeder: T.EntryFeeder; entryFeeder: T.EntryFeeder,
adjective: T.AdjectiveSelection | undefined; adjective: T.AdjectiveSelection | undefined,
onChange: (p: T.AdjectiveSelection | undefined) => void; onChange: (p: T.AdjectiveSelection | undefined) => void,
opts: T.TextOptions; opts: T.TextOptions,
noTitle?: boolean; noTitle?: boolean,
phraseIsComplete: boolean; phraseIsComplete: boolean,
negative: boolean;
}) { }) {
const [addingSandwich, setAddingSandwich] = useState<boolean>(false); const [addingSandwich, setAddingSandwich] = useState<boolean>(false);
function onEntrySelect(entry: T.AdjectiveEntry | undefined) { function onEntrySelect(entry: T.AdjectiveEntry | undefined) {
if (!entry) { if (!entry) {
return props.onChange(undefined); return props.onChange(undefined);
}
props.onChange(makeAdjectiveSelection(entry));
} }
props.onChange(makeAdjectiveSelection(entry)); function handleSandwichChange(s: T.SandwichSelection<T.Sandwich> | undefined) {
} if (!props.adjective) return;
function handleSandwichChange( props.onChange({
s: T.SandwichSelection<T.Sandwich> | undefined ...props.adjective,
) { sandwich: s,
if (!props.adjective) return; });
props.onChange({ if (!s) {
...props.adjective, setAddingSandwich(false);
sandwich: s, }
});
if (!s) {
setAddingSandwich(false);
} }
} function handleSandwichExit() {
function handleSandwichExit() { setAddingSandwich(false);
setAddingSandwich(false); props.onChange(undefined);
props.onChange(undefined); }
} return <div style={{ maxWidth: "225px", minWidth: "125px" }}>
return ( {(props.adjective?.sandwich || addingSandwich) && <SandwichPicker
<div style={{ maxWidth: "225px", minWidth: "125px" }}> onChange={handleSandwichChange}
{(props.adjective?.sandwich || addingSandwich) && ( opts={props.opts}
<SandwichPicker sandwich={props.adjective?.sandwich}
negative={props.negative} entryFeeder={props.entryFeeder}
onChange={handleSandwichChange} onExit={handleSandwichExit}
opts={props.opts} // TODO: not allowing shrinking any possesisives on sandwiches for now - need to work with the blocks and their special behaviour
sandwich={props.adjective?.sandwich} phraseIsComplete={false}
entryFeeder={props.entryFeeder} />}
onExit={handleSandwichExit} <div className="d-flex flex-row justify-content-between align-items-baseline">
// TODO: not allowing shrinking any possesisives on sandwiches for now - need to work with the blocks and their special behaviour {!props.noTitle && <div>
phraseIsComplete={false} <div className="h6">Adjective</div>
/> </div>}
)} {/* not ready for sandwiches on adjectives */}
<div className="d-flex flex-row justify-content-between align-items-baseline"> {/* {(!addingSandwich && props.adjective && !props.adjective?.sandwich)
{!props.noTitle && (
<div>
<div className="h6">Adjective</div>
</div>
)}
{/* not ready for sandwiches on adjectives */}
{/* {(!addingSandwich && props.adjective && !props.adjective?.sandwich)
? <div className="clickable" onClick={() => setAddingSandwich(true)}>+ Sandwich</div> ? <div className="clickable" onClick={() => setAddingSandwich(true)}>+ Sandwich</div>
: <div></div>} */} : <div></div>} */}
<div /> <div />
</div> </div>
<div className="mt-1"> <div className="mt-1">
<EntrySelect <EntrySelect
value={props.adjective?.entry} value={props.adjective?.entry}
entryFeeder={props.entryFeeder.adjectives} entryFeeder={props.entryFeeder.adjectives}
onChange={onEntrySelect} onChange={onEntrySelect}
name="Adjective" name="Adjective"
opts={props.opts} opts={props.opts}
/> />
</div> </div>
</div> </div>;
);
} }
export default AdjectivePicker; export default AdjectivePicker;

71
src/components/src/np-picker/DeterminersPicker.tsx → src/components/src/np-picker/DemonstrativePicker.tsx
View File

@ -1,52 +1,38 @@
import * as T from "../../../types"; import * as T from "../../../types";
import { DeterminerSelect } from "../EntrySelect"; import classNames from "classnames";
export default function DeterminersPicker({ export default function DemonstrativePicker({
determiners, demonstrative,
onChange, onChange,
opts,
negative,
}: { }: {
determiners: T.NounSelection["determiners"]; demonstrative: T.NounSelection["demonstrative"];
onChange: (dem: T.NounSelection["determiners"]) => void; onChange: (dem: T.NounSelection["demonstrative"]) => void;
opts: T.TextOptions;
negative: boolean;
}) { }) {
const hasDemonstrative = function handleDChange(d: "daa" | "hagha" | "dagha") {
determiners && if (!demonstrative) {
determiners.determiners.some((d) => "demonstrative" in d.determiner); onChange({
function allowed(d: T.Determiner): boolean { type: "demonstrative",
if (d.p === "هیڅ" && !negative) { demonstrative: d,
return false; withNoun: true,
});
} else {
onChange({
...demonstrative,
demonstrative: d,
});
} }
if (hasDemonstrative && "demonstrative" in d) {
return false;
}
return true;
} }
function handleWithNounChange(e: React.ChangeEvent<HTMLInputElement>) { function handleWithNounChange(e: React.ChangeEvent<HTMLInputElement>) {
if (determiners) { if (demonstrative) {
onChange({ onChange({
...determiners, ...demonstrative,
withNoun: e.target.checked, withNoun: e.target.checked,
}); });
} }
} }
function handleDeterminerChange(value: T.Determiner[] | undefined) {
onChange({
type: "determiners",
withNoun: determiners ? determiners.withNoun : true,
determiners: value
? value.map((d) => ({
type: "determiner",
determiner: d,
}))
: [],
});
}
return ( return (
<div> <div>
{/* <div className="d-flex flex-row justify-content-around py-1"> <div className="d-flex flex-row justify-content-around py-1">
<div> <div>
<button <button
className={classNames("btn", "btn-outline-secondary", { className={classNames("btn", "btn-outline-secondary", {
@ -77,29 +63,20 @@ export default function DeterminersPicker({
هغه هغه
</button> </button>
</div> </div>
</div> */} </div>
<DeterminerSelect
determiners={T.determiners.filter(allowed)}
value={
determiners ? determiners.determiners.map((x) => x.determiner) : []
}
onChange={handleDeterminerChange}
name="determiner"
opts={opts}
/>
<div <div
className="form-check" className="form-check"
style={{ style={{
opacity: determiners ? 1 : 0.5, opacity: demonstrative ? 1 : 0.5,
}} }}
> >
<input <input
className="form-check-input" className="form-check-input"
type="checkbox" type="checkbox"
checked={determiners?.withNoun} checked={demonstrative?.withNoun}
onChange={handleWithNounChange} onChange={handleWithNounChange}
id="withNoun" id="withNoun"
disabled={!hasDemonstrative} disabled={!demonstrative}
/> />
<label className="form-check-label text-muted" htmlFor="withNoun"> <label className="form-check-label text-muted" htmlFor="withNoun">
with noun with noun

35
src/components/src/np-picker/NPNounPicker.tsx
View File

@ -7,7 +7,7 @@ import InlinePs from "../InlinePs";
import EntrySelect from "../EntrySelect"; import EntrySelect from "../EntrySelect";
import AdjectiveManager from "./AdjectiveManager"; import AdjectiveManager from "./AdjectiveManager";
import { useState } from "react"; import { useState } from "react";
import DeterminersPicker from "./DeterminersPicker"; import DemonstrativePicker from "./DemonstrativePicker";
// const filterOptions = [ // const filterOptions = [
// { // {
@ -62,9 +62,9 @@ function NPNounPicker(props: {
onChange: (p: T.NounSelection | undefined) => void; onChange: (p: T.NounSelection | undefined) => void;
opts: T.TextOptions; opts: T.TextOptions;
phraseIsComplete: boolean; phraseIsComplete: boolean;
negative: boolean;
}) { }) {
const [addingDeterminers, setAddingDeterminers] = useState<boolean>(false); const [addingDemonstrative, setAddingDemonstrative] =
useState<boolean>(false);
// const [patternFilter, setPatternFilter] = useState<FilterPattern | undefined>(undefined); // const [patternFilter, setPatternFilter] = useState<FilterPattern | undefined>(undefined);
// const [showFilter, setShowFilter] = useState<boolean>(false) // const [showFilter, setShowFilter] = useState<boolean>(false)
// const nounsFiltered = props.nouns // const nounsFiltered = props.nouns
@ -88,13 +88,13 @@ function NPNounPicker(props: {
}); });
} }
} }
function handleDeterminersChange( function handleDemonstrativeChange(
determiners: undefined | T.NounSelection["determiners"] demonstrative: undefined | T.NounSelection["demonstrative"]
) { ) {
if (props.noun) { if (props.noun) {
props.onChange({ props.onChange({
...props.noun, ...props.noun,
determiners, demonstrative,
}); });
} }
} }
@ -105,34 +105,32 @@ function NPNounPicker(props: {
minWidth: "125px", minWidth: "125px",
}} }}
> >
{!addingDeterminers && !props.noun?.determiners ? ( {!addingDemonstrative && !props.noun?.demonstrative ? (
<div> <div>
<span <span
className="clickable text-muted" className="clickable text-muted"
onClick={() => setAddingDeterminers(true)} onClick={() => setAddingDemonstrative(true)}
> >
+ Determiners + Demonstrative
</span> </span>
</div> </div>
) : ( ) : (
<div> <div>
<div className="d-flex flex-row justify-content-between mb-1"> <div className="d-flex flex-row justify-content-between mb-1">
<div>{!props.noun?.determiners ? "Add" : ""} Determiners</div> <div>{!props.noun?.demonstrative ? "Add" : ""} Demonstrative</div>
<div <div
className="clickable" className="clickable"
onClick={() => { onClick={() => {
handleDeterminersChange(undefined); handleDemonstrativeChange(undefined);
setAddingDeterminers(false); setAddingDemonstrative(false);
}} }}
> >
<i className="fas fa-trash" /> <i className="fas fa-trash" />
</div> </div>
</div> </div>
<DeterminersPicker <DemonstrativePicker
determiners={props.noun?.determiners} demonstrative={props.noun?.demonstrative}
onChange={handleDeterminersChange} onChange={handleDemonstrativeChange}
opts={props.opts}
negative={props.negative}
/> />
</div> </div>
)} )}
@ -153,14 +151,13 @@ function NPNounPicker(props: {
<div <div
style={{ style={{
opacity: opacity:
props.noun?.determiners && !props.noun.determiners.withNoun props.noun?.demonstrative && !props.noun.demonstrative.withNoun
? 0.5 ? 0.5
: 1, : 1,
}} }}
> >
{props.noun && ( {props.noun && (
<AdjectiveManager <AdjectiveManager
negative={props.negative}
phraseIsComplete={props.phraseIsComplete} phraseIsComplete={props.phraseIsComplete}
adjectives={props.noun?.adjectives} adjectives={props.noun?.adjectives}
entryFeeder={props.entryFeeder} entryFeeder={props.entryFeeder}

3
src/components/src/np-picker/NPPicker.tsx
View File

@ -25,7 +25,6 @@ function NPPicker(props: {
phraseIsComplete: boolean; phraseIsComplete: boolean;
isShrunk?: boolean; isShrunk?: boolean;
isRemoved?: boolean; isRemoved?: boolean;
negative: boolean;
}) { }) {
if ( if (
props.is2ndPersonPicker && props.is2ndPersonPicker &&
@ -224,7 +223,6 @@ function NPPicker(props: {
role="possesor" role="possesor"
opts={props.opts} opts={props.opts}
entryFeeder={props.entryFeeder} entryFeeder={props.entryFeeder}
negative={props.negative}
/> />
</div> </div>
)} )}
@ -252,7 +250,6 @@ function NPPicker(props: {
<NounPicker <NounPicker
phraseIsComplete={props.phraseIsComplete} phraseIsComplete={props.phraseIsComplete}
entryFeeder={props.entryFeeder} entryFeeder={props.entryFeeder}
negative={props.negative}
noun={ noun={
props.np && props.np.selection.type === "noun" props.np && props.np.selection.type === "noun"
? props.np.selection ? props.np.selection

128
src/components/src/np-picker/SandwichPicker.tsx
View File

@ -5,82 +5,74 @@ import { useEffect, useState } from "react";
import NPPicker from "./NPPicker"; import NPPicker from "./NPPicker";
function SandwichPicker(props: { function SandwichPicker(props: {
opts: T.TextOptions; opts: T.TextOptions,
onChange: (s: T.SandwichSelection<T.Sandwich> | undefined) => void; onChange: (s: T.SandwichSelection<T.Sandwich> | undefined) => void,
sandwich: T.SandwichSelection<T.Sandwich> | undefined; sandwich: T.SandwichSelection<T.Sandwich> | undefined;
entryFeeder: T.EntryFeeder; entryFeeder: T.EntryFeeder,
phraseIsComplete: boolean; phraseIsComplete: boolean,
onExit: () => void; onExit: () => void,
negative: boolean;
}) { }) {
const [sandwichBase, setSandwichBase] = useState<T.Sandwich | undefined>( const [sandwichBase, setSandwichBase] = useState<T.Sandwich | undefined>(props.sandwich);
props.sandwich useEffect(() => {
); setSandwichBase(props.sandwich);
useEffect(() => { }, [props.sandwich]);
setSandwichBase(props.sandwich); function handleNounChange(n: T.NPSelection | undefined) {
}, [props.sandwich]); if (!n) {
function handleNounChange(n: T.NPSelection | undefined) { props.onChange(undefined);
if (!n) { return;
props.onChange(undefined); }
return; if (!sandwichBase) return;
props.onChange({
...sandwichBase,
inside: n,
});
} }
if (!sandwichBase) return; function handleSandwichChange(s: T.Sandwich | undefined) {
props.onChange({ if (!s) {
...sandwichBase, setSandwichBase(undefined);
inside: n, props.onChange(undefined);
}); return;
} }
function handleSandwichChange(s: T.Sandwich | undefined) { setSandwichBase(s);
if (!s) { if (!props.sandwich) return;
setSandwichBase(undefined); props.onChange({
props.onChange(undefined); ...props.sandwich,
return; ...s,
});
} }
setSandwichBase(s); function handleExit() {
if (!props.sandwich) return; props.onExit();
props.onChange({ }
...props.sandwich, return <div>
...s, <div className="d-flex flex-row justify-content-between">
}); <div></div>
} <div className="text-center">🥪 Sandwich</div>
function handleExit() { <div className="clickable" onClick={handleExit}>
props.onExit(); <i className="fas fa-trash" />
} </div>
return (
<div>
<div className="d-flex flex-row justify-content-between">
<div></div>
<div className="text-center">🥪 Sandwich</div>
<div className="clickable" onClick={handleExit}>
<i className="fas fa-trash" />
</div> </div>
</div> <div style={{ border: "1px #6C757D solid", padding: "3px" }}>
<div style={{ border: "1px #6C757D solid", padding: "3px" }}> {sandwichBase && <div className="mb-2" style={{ margin: "0 auto" }}>
{sandwichBase && (
<div className="mb-2" style={{ margin: "0 auto" }}>
<NPPicker <NPPicker
onChange={handleNounChange} onChange={handleNounChange}
np={props.sandwich ? props.sandwich.inside : undefined} np={props.sandwich ? props.sandwich.inside : undefined}
counterPart={undefined} counterPart={undefined}
opts={props.opts} opts={props.opts}
role="object" role="object"
cantClear={true} cantClear={true}
entryFeeder={props.entryFeeder} entryFeeder={props.entryFeeder}
phraseIsComplete={props.phraseIsComplete} phraseIsComplete={props.phraseIsComplete}
negative={props.negative}
/> />
</div> </div>}
)}
<SandwichSelect <SandwichSelect
name="sandwich" name="sandwich"
opts={props.opts} opts={props.opts}
sandwiches={sandwiches} sandwiches={sandwiches}
value={sandwichBase} value={sandwichBase}
onChange={handleSandwichChange} onChange={handleSandwichChange}
/> />
</div> </div>
</div> </div>;
);
} }
export default SandwichPicker; export default SandwichPicker;

2
src/components/src/vp-explorer/VPExplorer.tsx
View File

@ -44,7 +44,7 @@ function VPExplorer(props: {
props.loaded props.loaded
? props.loaded ? props.loaded
: (savedVps) => makeVPSelectionState(props.verb, savedVps), : (savedVps) => makeVPSelectionState(props.verb, savedVps),
"vpsState17", "vpsState16",
flashMessage flashMessage
); );
const [mode, setMode] = useStickyState<"charts" | "phrases" | "quiz">( const [mode, setMode] = useStickyState<"charts" | "phrases" | "quiz">(

4
src/components/src/vp-explorer/VPPicker.tsx
View File

@ -163,7 +163,6 @@ function VPPicker({
</div> </div>
{!block || block.type === "AP" ? ( {!block || block.type === "AP" ? (
<APPicker <APPicker
negative={vps.verb.negative}
phraseIsComplete={phraseIsComplete} phraseIsComplete={phraseIsComplete}
heading="AP" heading="AP"
entryFeeder={entryFeeder} entryFeeder={entryFeeder}
@ -239,7 +238,6 @@ function VPPicker({
opts={opts} opts={opts}
isShrunk={servantIsShrunk && roles.servant === "subject"} isShrunk={servantIsShrunk && roles.servant === "subject"}
isRemoved={roles.king === "subject" && VPS?.form.removeKing} isRemoved={roles.king === "subject" && VPS?.form.removeKing}
negative={VPS?.verb.negative || false}
/> />
) : vps.verb && ) : vps.verb &&
block?.type === "objectSelection" && block?.type === "objectSelection" &&
@ -352,7 +350,6 @@ function VPPicker({
isRemoved={ isRemoved={
roles.king === "object" && VPS?.form.removeKing roles.king === "object" && VPS?.form.removeKing
} }
negative={VPS?.verb.negative || false}
/> />
)} )}
</div> </div>
@ -375,7 +372,6 @@ function VPPicker({
} }
opts={opts} opts={opts}
entryFeeder={entryFeeder} entryFeeder={entryFeeder}
negative={vps.verb.negative}
/> />
</div> </div>
)} )}

2
src/lib/package.json
View File

@ -1,6 +1,6 @@
{ {
"name": "@lingdocs/inflect", "name": "@lingdocs/inflect",
"version": "7.5.1", "version": "7.4.1",
"description": "Pashto inflector library", "description": "Pashto inflector library",
"main": "dist/index.js", "main": "dist/index.js",
"types": "dist/lib/library.d.ts", "types": "dist/lib/library.d.ts",

2
src/lib/src/inflections-and-vocative.ts
View File

@ -48,7 +48,7 @@ type Plurals =
// const endingInHayOrAynRegex = /[^ا][هع]$/; // const endingInHayOrAynRegex = /[^ا][هع]$/;
export function getInfsAndVocative( export function getInfsAndVocative(
entryR: T.DictionaryEntryNoFVars | T.Determiner, entryR: T.DictionaryEntryNoFVars,
plurals: Plurals plurals: Plurals
): ):
| { | {

3
src/lib/src/new-verb-engine/render-verb.ts
View File

@ -5,7 +5,6 @@ import {
personNumber, personNumber,
personToGenNum, personToGenNum,
} from "../misc-helpers"; } from "../misc-helpers";
import { monoidPsString } from "../fp-ps";
import { applySingleOrLengthOpts, fmapSingleOrLengthOpts } from "../fp-ps"; import { applySingleOrLengthOpts, fmapSingleOrLengthOpts } from "../fp-ps";
import { import {
concatPsString, concatPsString,
@ -449,7 +448,7 @@ function ensure3rdPast(
} }
const abruptEnder = ["د", "ت", "ړ"].includes(rs[0].p.slice(-1)); const abruptEnder = ["د", "ت", "ړ"].includes(rs[0].p.slice(-1));
// short endings like ورسېد // short endings like ورسېد
const ends = abruptEnder ? [monoidPsString.empty, ...ending] : ending; const ends = abruptEnder ? [{ p: "", f: "" }, ...ending] : ending;
return verbEndingConcat(rs, ends); return verbEndingConcat(rs, ends);
} }

2
src/lib/src/pashto-inflector.ts
View File

@ -23,7 +23,7 @@ export function inflectWord(word: T.DictionaryEntry): T.InflectorOutput {
// If it's a noun/adj, inflect accordingly // If it's a noun/adj, inflect accordingly
// TODO: What about n. f. / adj. that end in ي ?? // TODO: What about n. f. / adj. that end in ي ??
const w = removeFVarients(word); const w = removeFVarients(word);
if (word.c?.includes("doub.")) { if (w.c?.includes("doub.")) {
const words = splitDoubleWord(w); const words = splitDoubleWord(w);
// TODO: Make this work for non-unisex double words // TODO: Make this work for non-unisex double words
// Right now this an extremely bad and complex way to do this // Right now this an extremely bad and complex way to do this

120
src/lib/src/phrase-building/blocks-utils.ts
View File

@ -420,123 +420,3 @@ function arrayMove<X>(ar: X[], old_index: number, new_index: number): X[] {
arr.splice(new_i, 0, arr.splice(old_index, 1)[0]); arr.splice(new_i, 0, arr.splice(old_index, 1)[0]);
return arr; return arr;
} }
// TODO: This takes 8 helper functions to recursively go down and check all determiners
// - is this what LENSES would help with?
export function removeHeetsDet<B extends T.VPSBlock[] | T.EPSBlock[]>(
blocks: B
): B {
return blocks.map<T.VPSBlock | T.EPSBlock>((x) => ({
key: x.key,
block: removeHeetsDetFromBlock(x.block),
})) as B;
}
// TODO: Could use lenses for this
function removeHeetsDetFromBlock<
B extends T.VPSBlock["block"] | T.EPSBlock["block"]
>(block: B): B {
if (!block) {
return block;
}
if (block.type === "AP") {
return removeHeetsDetFromAP(block) as B;
}
if (block.type === "complement") {
return removeHeetsFromComp(block) as B;
}
return {
...block,
selection:
typeof block.selection === "object"
? removeHeetsFromNP(block.selection)
: block.selection,
};
}
function removeHeetsDetFromAP(ap: T.APSelection): T.APSelection {
if (ap.selection.type === "adverb") {
return ap;
}
return {
...ap,
selection: removeHeetsFromSandwich(ap.selection),
};
}
function removeHeetsFromSandwich(
sand: T.SandwichSelection<T.Sandwich>
): T.SandwichSelection<T.Sandwich> {
return {
...sand,
inside: removeHeetsFromNP(sand.inside),
};
}
function removeHeetsFromAdjective(
adj: T.AdjectiveSelection
): T.AdjectiveSelection {
return {
...adj,
sandwich: adj.sandwich ? removeHeetsFromSandwich(adj.sandwich) : undefined,
};
}
function removeHeetsFromComp(
comp: T.ComplementSelection
): T.ComplementSelection {
if (comp.selection.type === "adjective") {
return {
...comp,
selection: removeHeetsFromAdjective(comp.selection),
};
}
if (comp.selection.type === "noun") {
return {
...comp,
selection: removeHeetsFromNoun(comp.selection),
};
}
if (comp.selection.type === "sandwich") {
return {
...comp,
selection: removeHeetsFromSandwich(comp.selection),
};
}
// should be only a loc. adv. left
return comp;
}
function removeHeetsFromNoun(n: T.NounSelection): T.NounSelection {
return {
...n,
adjectives: n.adjectives.map(removeHeetsFromAdjective),
...(n.determiners
? {
determiners: removeHeetsFromDets(n.determiners),
}
: {}),
};
}
function removeHeetsFromNP(np: T.NPSelection): T.NPSelection {
if (np.selection.type === "noun") {
return {
...np,
selection: removeHeetsFromNoun(np.selection),
};
}
return np;
}
function removeHeetsFromDets(
dets: T.DeterminersSelection | undefined
): T.DeterminersSelection | undefined {
if (!dets) {
return dets;
}
return {
...dets,
determiners: dets.determiners.filter((d) => d.determiner.p !== "هیڅ"),
};
}

6
src/lib/src/phrase-building/compile.ts
View File

@ -22,7 +22,7 @@ import {
specifyEquativeLength, specifyEquativeLength,
} from "./blocks-utils"; } from "./blocks-utils";
import { blank, kidsBlank } from "../misc-helpers"; import { blank, kidsBlank } from "../misc-helpers";
import { monoidPsString, monoidPsStringWVars } from "../fp-ps"; import { monoidPsStringWVars } from "../fp-ps";
import { concatAll } from "fp-ts/lib/Monoid"; import { concatAll } from "fp-ts/lib/Monoid";
type BlankoutOptions = { type BlankoutOptions = {
@ -275,7 +275,7 @@ function applyBlankOut(
return kidsBlank; return kidsBlank;
} }
if (blankOut?.negative && "block" in x && x.block.type === "negative") { if (blankOut?.negative && "block" in x && x.block.type === "negative") {
return monoidPsString.empty; return { p: "", f: "" };
} }
return x; return x;
}); });
@ -314,7 +314,7 @@ function getPsFromPiece(
} }
if (piece.block.type === "objectSelection") { if (piece.block.type === "objectSelection") {
if (typeof piece.block.selection !== "object") { if (typeof piece.block.selection !== "object") {
return [monoidPsString.empty]; return [{ p: "", f: "" }];
} }
return getPashtoFromRendered(piece.block.selection, subjectPerson); return getPashtoFromRendered(piece.block.selection, subjectPerson);
} }

447
src/lib/src/phrase-building/eps-reducer.ts
View File

@ -1,257 +1,216 @@
import * as T from "../../../types"; import * as T from "../../../types";
import { personGender, personNumber } from "../misc-helpers"; import {
personGender,
personNumber,
} from "../misc-helpers";
import { isUnisexNounEntry } from "../type-predicates"; import { isUnisexNounEntry } from "../type-predicates";
import { checkForMiniPronounsError } from "./compile"; import { checkForMiniPronounsError } from "./compile";
import { import { adjustSubjectSelection, getSubjectSelection, insertNewAP, removeAP, setAP, shiftBlock } from "./blocks-utils";
adjustSubjectSelection,
getSubjectSelection,
insertNewAP,
removeAP,
removeHeetsDet,
setAP,
shiftBlock,
} from "./blocks-utils";
export type EpsReducerAction = export type EpsReducerAction = {
| { type: "set predicate type",
type: "set predicate type"; payload: "NP" | "Complement",
payload: "NP" | "Complement"; } | {
} type: "set subject",
| { payload: T.NPSelection | undefined,
type: "set subject"; } | {
payload: T.NPSelection | undefined; type: "set predicate NP",
} payload: T.NPSelection | undefined,
| { } | {
type: "set predicate NP"; type: "set predicate complement",
payload: T.NPSelection | undefined; payload: T.ComplementSelection | undefined,
} } | {
| { type: "set omitSubject",
type: "set predicate complement"; payload: "true" | "false",
payload: T.ComplementSelection | undefined; } | {
} type: "set equative",
| { payload: T.EquativeSelection,
type: "set omitSubject"; } | {
payload: "true" | "false"; type: "insert new AP",
} } | {
| { type: "set AP",
type: "set equative"; payload: {
payload: T.EquativeSelection; index: number,
} AP: T.APSelection | undefined,
| { },
type: "insert new AP"; } | {
} type: "remove AP",
| { payload: number,
type: "set AP"; } | {
payload: { type: "shift block",
index: number; payload: {
AP: T.APSelection | undefined; index: number,
}; direction: "back" | "forward",
} },
| { } | {
type: "remove AP"; type: "load EPS",
payload: number; payload: T.EPSelectionState,
}
| {
type: "shift block";
payload: {
index: number;
direction: "back" | "forward";
};
}
| {
type: "load EPS";
payload: T.EPSelectionState;
};
export default function epsReducer(
eps: T.EPSelectionState,
action: EpsReducerAction,
sendAlert?: (msg: string) => void
): T.EPSelectionState {
if (action.type === "set predicate type") {
return {
...eps,
predicate: {
...eps.predicate,
type: action.payload,
},
};
}
if (action.type === "set subject") {
const subject = action.payload;
if (!subject) {
return {
...eps,
blocks: adjustSubjectSelection(eps.blocks, subject),
};
}
if (
subject.selection.type === "pronoun" &&
eps.predicate.type === "NP" &&
eps.predicate.NP?.selection.type === "noun" &&
isUnisexNounEntry(eps.predicate.NP.selection.entry)
) {
const predicate = eps.predicate.NP.selection;
const adjusted = {
...predicate,
...(predicate.numberCanChange
? {
number: personNumber(subject.selection.person),
}
: {}),
...(predicate.genderCanChange
? {
gender: personGender(subject.selection.person),
}
: {}),
};
return {
...eps,
blocks: adjustSubjectSelection(eps.blocks, subject),
predicate: {
...eps.predicate,
NP: {
type: "NP",
selection: adjusted,
},
},
};
}
const n: T.EPSelectionState = {
...eps,
blocks: adjustSubjectSelection(eps.blocks, subject),
};
return subject ? ensureMiniPronounsOk(eps, n, sendAlert) : n;
}
if (action.type === "set predicate NP") {
const selection = action.payload;
if (!selection) {
return {
...eps,
predicate: {
...eps.predicate,
NP: selection,
},
};
}
const subject = getSubjectSelection(eps.blocks).selection;
if (
subject?.selection.type === "pronoun" &&
selection.selection.type === "noun" &&
isUnisexNounEntry(selection.selection.entry)
) {
const { gender, number } = selection.selection;
const pronoun = subject.selection.person;
const newPronoun = movePersonNumber(
movePersonGender(pronoun, gender),
number
);
return {
...eps,
blocks: adjustSubjectSelection(eps.blocks, {
type: "NP",
selection: {
...subject.selection,
person: newPronoun,
},
}),
predicate: {
...eps.predicate,
NP: selection,
},
};
}
const n: T.EPSelectionState = {
...eps,
predicate: {
...eps.predicate,
NP: selection,
},
};
return selection ? ensureMiniPronounsOk(eps, n, sendAlert) : n;
}
if (action.type === "set predicate complement") {
return {
...eps,
predicate: {
...eps.predicate,
Complement: action.payload,
},
};
}
if (action.type === "set omitSubject") {
const n: T.EPSelectionState = {
...eps,
omitSubject: action.payload === "true",
};
return ensureMiniPronounsOk(eps, n, sendAlert);
}
if (action.type === "set equative") {
return {
...eps,
blocks: !action.payload.negative
? removeHeetsDet(eps.blocks)
: eps.blocks,
equative: action.payload,
};
}
if (action.type === "insert new AP") {
return {
...eps,
blocks: insertNewAP(eps.blocks),
};
}
if (action.type === "set AP") {
const { index, AP } = action.payload;
return {
...eps,
blocks: setAP(eps.blocks, index, AP),
};
}
if (action.type === "remove AP") {
return {
...eps,
blocks: removeAP(eps.blocks, action.payload),
};
}
if (action.type === "shift block") {
const { index, direction } = action.payload;
return {
...eps,
blocks: shiftBlock(eps.blocks, index, direction),
};
}
if (action.type === "load EPS") {
return action.payload;
}
throw new Error("unknown epsReducer action");
} }
function ensureMiniPronounsOk( export default function epsReducer(eps: T.EPSelectionState, action: EpsReducerAction, sendAlert?: (msg: string) => void): T.EPSelectionState {
old: T.EPSelectionState, if (action.type === "set predicate type") {
eps: T.EPSelectionState, return {
sendAlert?: (msg: string) => void ...eps,
): T.EPSelectionState { predicate: {
const error = checkForMiniPronounsError(eps); ...eps.predicate,
if (error) { type: action.payload,
if (sendAlert) sendAlert(error); },
return old; };
} }
return eps; if (action.type === "set subject") {
const subject = action.payload;
if (!subject) {
return {
...eps,
blocks: adjustSubjectSelection(eps.blocks, subject),
};
}
if (subject.selection.type === "pronoun" && eps.predicate.type === "NP" && eps.predicate.NP?.selection.type === "noun" && isUnisexNounEntry(eps.predicate.NP.selection.entry)) {
const predicate = eps.predicate.NP.selection;
const adjusted = {
...predicate,
...predicate.numberCanChange ? {
number: personNumber(subject.selection.person),
} : {},
...predicate.genderCanChange ? {
gender: personGender(subject.selection.person),
} : {},
}
return {
...eps,
blocks: adjustSubjectSelection(eps.blocks, subject),
predicate: {
...eps.predicate,
NP: {
type: "NP",
selection: adjusted,
},
},
};
}
const n: T.EPSelectionState = {
...eps,
blocks: adjustSubjectSelection(eps.blocks, subject),
};
return subject ? ensureMiniPronounsOk(eps, n, sendAlert) : n;
}
if (action.type === "set predicate NP") {
const selection = action.payload;
if (!selection) {
return {
...eps,
predicate: {
...eps.predicate,
NP: selection,
},
};
}
const subject = getSubjectSelection(eps.blocks).selection;
if (subject?.selection.type === "pronoun" && selection.selection.type === "noun" && isUnisexNounEntry(selection.selection.entry)) {
const { gender, number } = selection.selection;
const pronoun = subject.selection.person;
const newPronoun = movePersonNumber(movePersonGender(pronoun, gender), number);
return {
...eps,
blocks: adjustSubjectSelection(eps.blocks, {
type: "NP",
selection: {
...subject.selection,
person: newPronoun,
},
}),
predicate: {
...eps.predicate,
NP: selection,
},
};
}
const n: T.EPSelectionState = {
...eps,
predicate: {
...eps.predicate,
NP: selection,
},
};
return selection ? ensureMiniPronounsOk(eps, n, sendAlert) : n;
}
if (action.type === "set predicate complement") {
return {
...eps,
predicate: {
...eps.predicate,
Complement: action.payload,
},
};
}
if (action.type === "set omitSubject") {
const n: T.EPSelectionState = {
...eps,
omitSubject: action.payload === "true",
};
return ensureMiniPronounsOk(eps, n, sendAlert);
}
if (action.type === "set equative") {
return {
...eps,
equative: action.payload,
}
}
if (action.type === "insert new AP") {
return {
...eps,
blocks: insertNewAP(eps.blocks),
};
}
if (action.type === "set AP") {
const { index, AP } = action.payload;
return {
...eps,
blocks: setAP(eps.blocks, index, AP),
};
}
if (action.type === "remove AP") {
return {
...eps,
blocks: removeAP(eps.blocks, action.payload),
};
}
if (action.type === "shift block") {
const { index, direction } = action.payload;
return {
...eps,
blocks: shiftBlock(eps.blocks, index, direction),
};
}
if (action.type === "load EPS") {
return action.payload;
}
throw new Error("unknown epsReducer action");
}
function ensureMiniPronounsOk(old: T.EPSelectionState, eps: T.EPSelectionState, sendAlert?: (msg: string) => void): T.EPSelectionState {
const error = checkForMiniPronounsError(eps);
if (error) {
if (sendAlert) sendAlert(error);
return old;
}
return eps;
} }
function movePersonGender(p: T.Person, gender: T.Gender): T.Person { function movePersonGender(p: T.Person, gender: T.Gender): T.Person {
const pGender = personGender(p); const pGender = personGender(p);
if (gender === pGender) { if (gender === pGender) {
return p; return p;
} }
return gender === "masc" ? p - 1 : p + 1; return (gender === "masc") ? (p - 1) : (p + 1);
} }
function movePersonNumber(p: T.Person, number: T.NounNumber): T.Person { function movePersonNumber(p: T.Person, number: T.NounNumber): T.Person {
const pNumber = personNumber(p); const pNumber = personNumber(p);
if (pNumber === number) { if (pNumber === number) {
return p; return p;
} }
return number === "plural" ? p + 6 : p - 6; return (number === "plural")
? (p + 6)
: (p - 6);
} }

2
src/lib/src/phrase-building/make-selections.ts
View File

@ -81,6 +81,6 @@ export function makeNounSelection(
possesor: !complementType ? old?.possesor : undefined, possesor: !complementType ? old?.possesor : undefined,
dynamicComplement: complementType === "dynamic", dynamicComplement: complementType === "dynamic",
genStativeComplement: complementType === "generative stative", genStativeComplement: complementType === "generative stative",
determiners: old?.determiners, demonstrative: old?.demonstrative,
}; };
} }

85
src/lib/src/phrase-building/np-tools.ts
View File

@ -2,10 +2,8 @@ import { isFirstPerson, isSecondPerson } from "../misc-helpers";
import * as T from "../../../types"; import * as T from "../../../types";
import { concatPsString } from "../p-text-helpers"; import { concatPsString } from "../p-text-helpers";
import { flattenLengths } from "./compile"; import { flattenLengths } from "./compile";
import { monoidPsStringWVars } from "../fp-ps";
import { concatAll } from "fp-ts/lib/Monoid";
function getBaseWDetsAndAdjs({ function getBaseAndAdjectives({
selection, selection,
}: T.Rendered< }: T.Rendered<
T.NPSelection | T.ComplementSelection | T.APSelection T.NPSelection | T.ComplementSelection | T.APSelection
@ -13,39 +11,45 @@ function getBaseWDetsAndAdjs({
if (selection.type === "sandwich") { if (selection.type === "sandwich") {
return getSandwichPsBaseAndAdjectives(selection); return getSandwichPsBaseAndAdjectives(selection);
} }
const determiners = ( const adjs = "adjectives" in selection && selection.adjectives;
("determiners" in selection && selection.determiners?.determiners) || const demonstrativePs = ("demonstrative" in selection &&
[] selection.demonstrative?.ps) || { p: "", f: "" };
).map((x) => x.ps); if (!adjs) {
const detWOutNoun = // TODO: does this ever get used??
"determiners" in selection && return flattenLengths(selection.ps).map((x) =>
selection.determiners && concatPsString(demonstrativePs, x)
!selection.determiners.withNoun; );
const adjs = (("adjectives" in selection && selection.adjectives) || []).map( }
(x) => x.ps
if (selection.demonstrative && !selection.demonstrative.withNoun) {
return [demonstrativePs];
}
return flattenLengths(selection.ps).map((p) =>
concatPsString(
demonstrativePs,
// demons ? " " : "",
adjs.reduce(
(accum, curr) => {
// TODO: with variations of adjs? {
return concatPsString(
accum,
accum.p === "" && accum.f === "" ? "" : "", //" ",
curr.ps[0]
);
},
{ p: "", f: "" }
),
" ",
p
)
); );
const base = flattenLengths(selection.ps);
return assemblePsWords([
...determiners,
...(detWOutNoun ? [] : [...adjs, base]),
]);
}
// TODO: perhaps use this for more things (a simple compileIntoText ?)
function assemblePsWords(words: T.PsString[][]): T.PsString[] {
return concatAll(monoidPsStringWVars)([
...intersperse(words, [{ p: " ", f: " " }]),
]);
}
function intersperse<T>(arr: T[], sep: T): T[] {
return arr.reduce((a: T[], v: T) => [...a, v, sep], []).slice(0, -1);
} }
function getSandwichPsBaseAndAdjectives( function getSandwichPsBaseAndAdjectives(
s: T.Rendered<T.SandwichSelection<T.Sandwich>> s: T.Rendered<T.SandwichSelection<T.Sandwich>>
): T.PsString[] { ): T.PsString[] {
const insideBase = getBaseWDetsAndAdjs(s.inside); const insideBase = getBaseAndAdjectives(s.inside);
const willContractWithPronoun = const willContractWithPronoun =
s.before && s.before &&
s.before.p === "د" && s.before.p === "د" &&
@ -114,7 +118,7 @@ export function getPashtoFromRendered(
| T.Rendered<T.APSelection>, | T.Rendered<T.APSelection>,
subjectsPerson: false | T.Person subjectsPerson: false | T.Person
): T.PsString[] { ): T.PsString[] {
const base = getBaseWDetsAndAdjs(b); const base = getBaseAndAdjectives(b);
if (b.selection.type === "loc. adv." || b.selection.type === "adverb") { if (b.selection.type === "loc. adv." || b.selection.type === "adverb") {
return base; return base;
} }
@ -168,7 +172,7 @@ function addPossesor(
); );
} }
const wPossesor = existing.flatMap((ps) => const wPossesor = existing.flatMap((ps) =>
getBaseWDetsAndAdjs(owner).map((v) => getBaseAndAdjectives(owner).map((v) =>
owner.selection.type === "pronoun" && owner.selection.type === "pronoun" &&
subjectsPerson !== false && subjectsPerson !== false &&
willBeReflexive(subjectsPerson, owner.selection.person) willBeReflexive(subjectsPerson, owner.selection.person)
@ -200,7 +204,7 @@ function addArticlesAndAdjs(
const adjs = !np.adjectives const adjs = !np.adjectives
? "" ? ""
: np.adjectives.reduce((accum, curr): string => { : np.adjectives.reduce((accum, curr): string => {
if (!curr.e) return "ADJ"; if (!curr.e) throw new Error("no english for adjective");
return accum + curr.e + " "; return accum + curr.e + " ";
}, ""); }, "");
const genderTag = np.genderCanChange const genderTag = np.genderCanChange
@ -208,17 +212,10 @@ function addArticlesAndAdjs(
? " (f.)" ? " (f.)"
: " (m.)" : " (m.)"
: ""; : "";
const moreThanOneDet = (np.determiners?.determiners.length || 0) > 1; const demonstrative = np.demonstrative ? ` ${np.demonstrative.e}` : "";
const determiners = const demWithoutNoun = np.demonstrative && !np.demonstrative.withNoun;
np.determiners && np.determiners.determiners return `${np.demonstrative ? "" : articles}${demonstrative}${
? np.determiners.determiners demWithoutNoun ? ` (${(adjs + word).trim()})` : adjs + word
// @ts-ignore - weird, ts is not recognizing this as rendered
.map((x) => (moreThanOneDet ? `(${x.e})` : x.e))
.join(" ")
: "";
const detsWithoutNoun = np.determiners && !np.determiners.withNoun;
return `${np.determiners ? "" : articles}${determiners}${
detsWithoutNoun ? ` (${(adjs + word).trim()})` : adjs + word
}${genderTag}`; }${genderTag}`;
} catch (e) { } catch (e) {
return undefined; return undefined;

160
src/lib/src/phrase-building/render-np.ts
View File

@ -15,7 +15,6 @@ import { shortVerbEndConsonant } from "../parsing/misc";
import { removeL } from "../new-verb-engine/rs-helpers"; import { removeL } from "../new-verb-engine/rs-helpers";
import { applySingleOrLengthOpts } from "../fp-ps"; import { applySingleOrLengthOpts } from "../fp-ps";
import { accentOnNFromEnd } from "../accent-helpers"; import { accentOnNFromEnd } from "../accent-helpers";
import { getInfsAndVocative } from "../inflections-and-vocative";
// TODO: can have subject and objects in possesors!! // TODO: can have subject and objects in possesors!!
@ -116,20 +115,6 @@ export function renderNounSelection(
return ps.length > 0 ? ps : [psStringFromEntry(n.entry)]; return ps.length > 0 ? ps : [psStringFromEntry(n.entry)];
})(); })();
const person = getPersonNumber(n.gender, n.number); const person = getPersonNumber(n.gender, n.number);
const determiners: T.Rendered<T.DeterminersSelection> | undefined =
n.determiners
? {
...n.determiners,
determiners: n.determiners.determiners.map((determiner) =>
renderDeterminer({
determiner,
inflected,
number: n.number,
gender: n.gender,
})
),
}
: undefined;
return { return {
...n, ...n,
adjectives: n.adjectives.map((a) => adjectives: n.adjectives.map((a) =>
@ -146,119 +131,64 @@ export function renderNounSelection(
ps: pashto, ps: pashto,
e: english, e: english,
possesor: renderPossesor(n.possesor, role), possesor: renderPossesor(n.possesor, role),
determiners, demonstrative: renderDemonstrative({
demonstrative: n.demonstrative,
inflected,
plural: n.number === "plural",
gender: n.gender,
}),
}; };
} }
function renderDeterminer({ function renderDemonstrative({
determiner: { determiner }, demonstrative,
inflected, inflected,
number, plural,
gender, gender,
}: { }: {
determiner: T.DeterminerSelection; demonstrative: T.DemonstrativeSelection | undefined;
inflected: boolean; inflected: boolean;
number: T.NounNumber; plural: boolean;
gender: T.Gender; gender: T.Gender;
}): T.Rendered<T.DeterminerSelection> { }): T.Rendered<T.DemonstrativeSelection> | undefined {
if (determiner.p === "دا") { if (!demonstrative) {
const ps = inflected ? { p: "دې", f: "de" } : { p: "دا", f: "daa" }; return undefined;
return {
type: "determiner",
determiner,
inflected,
number,
gender,
ps: [ps],
e: number === "plural" ? "these" : "this",
};
} }
if (determiner.p === "دغه") { const ps =
const ps = inflected demonstrative.demonstrative === "daa"
? number === "plural" ? inflected
? { p: "دغو", f: "dágho" } ? { p: "دې", f: "de" }
: gender === "masc" : { p: "دا", f: "daa" }
? { p: "دغه", f: "dághu" } : demonstrative.demonstrative === "dagha"
: { p: "دغې", f: "dághe" } ? inflected
: { p: "دغه", f: "dágha" }; ? plural
return { ? { p: "دغو", f: "dágho" }
type: "determiner", : gender === "masc"
determiner, ? { p: "دغه", f: "dághu" }
inflected, : { p: "دغې", f: "dághe" }
number, : { p: "دغه", f: "dágha" }
gender, : inflected
ps: [ps], ? plural
e: number === "plural" ? "these" : "this",
};
}
if (determiner.p === "هغه") {
const ps = inflected
? number === "plural"
? { p: "هغو", f: "hágho" } ? { p: "هغو", f: "hágho" }
: gender === "masc" : gender === "masc"
? { p: "هغه", f: "hághu" } ? { p: "هغه", f: "hághu" }
: { p: "هغې", f: "hághe" } : { p: "هغې", f: "hághe" }
: { p: "هغه", f: "hágha" }; : { p: "هغه", f: "hágha" };
return {
type: "determiner",
determiner,
inflected,
number,
gender,
ps: [ps],
e: number === "plural" ? "those" : "that",
};
}
const e = const e =
determiner.f === "Tol" demonstrative.demonstrative === "hagha"
? "all/the whole" ? plural
: determiner.f === "bul" ? "those"
? "other/another" : "that"
: determiner.f === "har" : plural
? "every/each" ? "these"
: determiner.f === "koom" : "this";
? "some/which"
: determiner.f === "heets"
? "no"
: determiner.f === "dáase"
? number === "plural"
? "such/like these"
: "such/like this"
: determiner.f === "daghase"
? `just such/just like ${number === "plural" ? "these" : "this"}`
: determiner.f === "hase"
? `such/like ${number === "plural" ? "those" : "that"}`
: number === "plural"
? "just such/just like these"
: "just such/just like this";
return { return {
type: "determiner", ...demonstrative,
determiner, ps,
inflected,
number,
gender,
ps: inflectDeterminer(determiner, inflected, gender, number),
e, e,
}; };
} }
function inflectDeterminer(
determiner: T.Determiner,
inflected: boolean,
gender: T.Gender,
number: T.NounNumber
): T.PsString[] {
const infs = getInfsAndVocative(determiner, undefined);
if (!infs || !infs.inflections) {
return [{ p: determiner.p, f: determiner.f }];
}
const inf = getBasicInf(infs.inflections, gender, number, inflected);
if (!inf) {
return [{ p: determiner.p, f: determiner.f }];
}
return inf;
}
function renderPronounSelection( function renderPronounSelection(
p: T.PronounSelection, p: T.PronounSelection,
inflected: boolean, inflected: boolean,
@ -339,20 +269,6 @@ function renderPossesor(
}; };
} }
function getBasicInf(
infs: T.Inflections,
gender: T.Gender,
number: T.NounNumber,
inflected: boolean
): T.PsString[] | false {
const inflectionNumber = (inflected ? 1 : 0) + (number === "plural" ? 1 : 0);
if (gender in infs) {
// @ts-ignore
return infs[gender][inflectionNumber];
}
return false;
}
function getInf( function getInf(
infs: T.InflectorOutput, infs: T.InflectorOutput,
t: "plural" | "arabicPlural" | "inflections", t: "plural" | "arabicPlural" | "inflections",

6
src/lib/src/phrase-building/vps-reducer.ts
View File

@ -11,7 +11,6 @@ import {
getSubjectSelection, getSubjectSelection,
insertNewAP, insertNewAP,
removeAP, removeAP,
removeHeetsDet,
setAP, setAP,
shiftBlock, shiftBlock,
} from "./blocks-utils"; } from "./blocks-utils";
@ -20,7 +19,6 @@ import {
changeTransitivity, changeTransitivity,
makeVPSelectionState, makeVPSelectionState,
} from "./verb-selection"; } from "./verb-selection";
import { mapGen } from "../fp-ps";
export type VpsReducerAction = export type VpsReducerAction =
| { | {
@ -205,13 +203,11 @@ export function vpsReducer(
} }
if (action.type === "set negativity") { if (action.type === "set negativity") {
if (!vps.verb) return vps; if (!vps.verb) return vps;
const negative = action.payload === "true";
return { return {
...vps, ...vps,
blocks: !negative ? removeHeetsDet(vps.blocks) : vps.blocks,
verb: { verb: {
...vps.verb, ...vps.verb,
negative, negative: action.payload === "true",
}, },
}; };
} }

11
src/lib/src/type-predicates.ts
View File

@ -62,23 +62,14 @@ export function isNounOrAdjEntry(
} }
export function isInflectableEntry( export function isInflectableEntry(
e: T.Entry | T.DictionaryEntry | T.DictionaryEntryNoFVars | T.Determiner e: T.Entry | T.DictionaryEntry | T.DictionaryEntryNoFVars
): e is T.InflectableEntry { ): e is T.InflectableEntry {
if ("entry" in e) { if ("entry" in e) {
return false; return false;
} }
if (isDeterminer(e)) {
return true;
}
return isNounEntry(e) || isAdjectiveEntry(e) || isNumberEntry(e); return isNounEntry(e) || isAdjectiveEntry(e) || isNumberEntry(e);
} }
export function isDeterminer(
e: T.Entry | T.DictionaryEntry | T.Determiner
): e is T.Determiner {
return "type" in e && e.type === "det";
}
export function isNumberEntry( export function isNumberEntry(
e: T.Entry | T.DictionaryEntry e: T.Entry | T.DictionaryEntry
): e is T.NumberEntry { ): e is T.NumberEntry {

51
src/types.ts
View File

@ -899,35 +899,13 @@ export type NounSelection = {
genStativeComplement?: boolean; genStativeComplement?: boolean;
adjectives: AdjectiveSelection[]; adjectives: AdjectiveSelection[];
possesor: undefined | PossesorSelection; possesor: undefined | PossesorSelection;
determiners?: DeterminersSelection; demonstrative: undefined | DemonstrativeSelection;
}; };
export type DeterminersSelection = { export type DemonstrativeSelection = {
type: "determiners"; type: "demonstrative";
demonstrative: "daa" | "hagha" | "dagha";
withNoun: boolean; withNoun: boolean;
determiners: DeterminerSelection[];
};
export const determiners = [
{ p: "دا", f: "daa", type: "det", demonstrative: true },
{ p: "دغه", f: "dágha", type: "det", demonstrative: true },
{ p: "هغه", f: "hágha", type: "det", demonstrative: true },
{ p: "کوم", f: "koom", type: "det" },
{ p: "داسې", f: "dáase", type: "det" },
{ p: "دغسې", f: "daghase", type: "det" },
{ p: "هسې", f: "hase", type: "det" },
{ p: "هغسې", f: "hagháse", type: "det" },
{ p: "هر", f: "har", type: "det" },
{ p: "ټول", f: "Tol", type: "det" },
{ p: "بل", f: "bul", type: "det" },
{ p: "هیڅ", f: "heets", type: "det", noInf: true },
] as const;
export type Determiner = (typeof determiners)[number];
export type DeterminerSelection = {
type: "determiner";
determiner: Determiner;
}; };
export type AdverbSelection = { export type AdverbSelection = {
@ -992,8 +970,7 @@ export type Rendered<
| AdjectiveSelection | AdjectiveSelection
| SandwichSelection<Sandwich> | SandwichSelection<Sandwich>
| ComplementSelection | ComplementSelection
| DeterminersSelection | DemonstrativeSelection
| DeterminerSelection
| ComplementSelection["selection"] | ComplementSelection["selection"]
| UnselectedComplementSelection | UnselectedComplementSelection
| undefined | undefined
@ -1043,21 +1020,13 @@ export type Rendered<
inflected: boolean; inflected: boolean;
person: Person; person: Person;
} }
: T extends DeterminersSelection : T extends DemonstrativeSelection
? { ? {
type: "determiners"; type: "demonstrative";
demonstrative: DemonstrativeSelection["demonstrative"];
withNoun: boolean; withNoun: boolean;
determiners: Rendered<DeterminerSelection>[]; ps: PsString;
}
: T extends DeterminerSelection
? {
type: "determiner";
determiner: DeterminerSelection["determiner"];
ps: PsString[];
e: string; e: string;
inflected: boolean;
number: NounNumber;
gender: Gender;
} }
: T extends ComplementSelection : T extends ComplementSelection
? { ? {
@ -1109,7 +1078,7 @@ export type Rendered<
shrunken: boolean; shrunken: boolean;
np: Rendered<NPSelection>; np: Rendered<NPSelection>;
}; };
determiners?: Rendered<DeterminersSelection>; demonstrative?: Rendered<DemonstrativeSelection>;
}; };
export type EPSelectionState = { export type EPSelectionState = {