nlptoolkit-annotatedtree 1.0.0

package/source/ParseNodeDrawable.ts

@@ -0,0 +1,257 @@
+import {ParseNode} from "nlptoolkit-parsetree/dist/ParseNode";
+import {LayerInfo} from "./LayerInfo";
+import {Symbol} from "nlptoolkit-parsetree/dist/Symbol";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import {Gazetteer} from "nlptoolkit-namedentityrecognition/dist/Gazetteer";
+
+export class ParseNodeDrawable extends ParseNode{
+
+    protected layers: LayerInfo = null
+    protected depth: number
+    protected inOrderTraversalIndex: number
+
+    constructor(parentOrLeftOrSymbol?: any, lineOrRightOrData?: any, dataOrIsleaf?: any, depth?: number) {
+        super();
+        if (parentOrLeftOrSymbol == null || lineOrRightOrData != undefined){
+            let parent: ParseNodeDrawable = parentOrLeftOrSymbol
+            if (depth != undefined){
+                let line: string = lineOrRightOrData
+                let isLeaf: boolean = dataOrIsleaf
+                let parenthesisCount = 0;
+                let childLine = "";
+                this.depth = depth;
+                this.parent = parent;
+                if (isLeaf){
+                    if (!line.includes("{")){
+                        this.data = new Symbol(line);
+                    } else {
+                        this.layers = new LayerInfo(line);
+                    }
+                } else {
+                    let startPos = line.indexOf(" ");
+                    this.data = new Symbol(line.substring(1, startPos));
+                    if (line.indexOf(")") == line.lastIndexOf(")")){
+                        this.children.push(new ParseNodeDrawable(this, line.substring(startPos + 1, line.indexOf(")")), true, depth + 1));
+                    } else {
+                        for (let i = startPos + 1; i < line.length; i++){
+                            if (line[i] != ' ' || parenthesisCount > 0){
+                                childLine = childLine + line[i];
+                            }
+                            if (line.charAt(i) == '('){
+                                parenthesisCount++;
+                            } else {
+                                if (line.charAt(i) == ')'){
+                                    parenthesisCount--;
+                                }
+                            }
+                            if (parenthesisCount == 0 && childLine != ""){
+                                this.children.push(new ParseNodeDrawable(this, childLine.trim(), false, depth + 1));
+                                childLine = "";
+                            }
+                        }
+                    }
+                }
+            } else {
+                let child: ParseNodeDrawable = lineOrRightOrData
+                let symbol: string = dataOrIsleaf
+                this.depth = child.depth;
+                child.updateDepths(this.depth + 1);
+                this.parent = parent;
+                this.parent.setChild(parent.getChildIndex(child), this);
+                this.children.push(child);
+                child.parent = this;
+                this.data = new Symbol(symbol);
+                this.inOrderTraversalIndex = child.inOrderTraversalIndex;
+            }
+        }
+    }
+
+    getLayerInfo(): LayerInfo{
+        return this.layers
+    }
+
+    getData(): Symbol{
+        if (this.layers == null){
+            return super.getData()
+        } else {
+            return new Symbol(this.getLayerData(ViewLayerType.ENGLISH_WORD));
+        }
+    }
+
+    clearLayers(){
+        this.layers = new LayerInfo()
+    }
+
+    clearLayer(layerType: ViewLayerType){
+        if (this.children.length == 0 && this.layerExists(layerType)){
+            this.layers.removeLayer(layerType)
+        }
+        for (let i = 0; i < this.numberOfChildren(); i++){
+            (<ParseNodeDrawable> this.children[i]).clearLayer(layerType);
+        }
+    }
+
+    clearData(){
+        this.data = null
+    }
+
+    setDataAndClearLayers(data: Symbol){
+        super.setData(data)
+        this.layers = null
+    }
+
+    setData(data: Symbol) {
+        if (this.layers == null){
+            super.setData(data);
+        } else {
+            this.layers.setLayerData(ViewLayerType.ENGLISH_WORD, data.getName());
+        }
+    }
+
+    headWord(viewLayerType: ViewLayerType): string{
+        if (this.children.length > 0){
+            return (<ParseNodeDrawable> this.headChild()).headWord(viewLayerType);
+        } else {
+            return this.getLayerData(viewLayerType);
+        }
+    }
+
+    getLayerData(viewLayer?: ViewLayerType): string{
+        if (viewLayer == undefined){
+            if (this.data != null){
+                return this.data.getName();
+            }
+            return this.layers.getLayerDescription();
+        } else {
+            if (viewLayer == ViewLayerType.WORD || this.layers == null){
+                return this.data.getName();
+            }
+            return this.layers.getLayerData(viewLayer);
+        }
+    }
+
+    getDepth(): number{
+        return this.depth
+    }
+
+    replaceChild(oldChild: ParseNodeDrawable, newChild: ParseNodeDrawable){
+        newChild.updateDepths(this.depth + 1);
+        newChild.parent = this;
+        this.children[this.children.indexOf(oldChild)] = newChild;
+    }
+
+    updateDepths(depth: number){
+        this.depth = depth;
+        for (let aChildren of this.children){
+            let aChild = <ParseNodeDrawable> aChildren;
+            aChild.updateDepths(depth + 1);
+        }
+    }
+
+    maxDepth(): number{
+        let depth = this.depth;
+        for (let aChildren of this.children) {
+            let aChild = <ParseNodeDrawable> aChildren;
+            if (aChild.maxDepth() > depth)
+                depth = aChild.maxDepth();
+        }
+        return depth;
+    }
+
+    layerExists(viewLayerType: ViewLayerType): boolean{
+        if (this.children.length == 0){
+            if (this.getLayerData(viewLayerType) != null){
+                return true;
+            }
+        } else {
+            for (let aChild of this.children) {
+                if ((<ParseNodeDrawable>aChild).layerExists(viewLayerType)){
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    isDummyNode(): boolean {
+        let data = this.getLayerData(ViewLayerType.ENGLISH_WORD);
+        let parentData = (<ParseNodeDrawable> this.parent).getLayerData(ViewLayerType.ENGLISH_WORD);
+        let targetData = this.getLayerData(ViewLayerType.TURKISH_WORD);
+        if (data != null && parentData != null){
+            if (targetData != null && targetData.includes("*")){
+                return true;
+            }
+            return data.includes("*") || (data == "0" && parentData == "-NONE-");
+        } else {
+            return false;
+        }
+    }
+
+    layerAll(viewLayerType: ViewLayerType): boolean{
+        if (this.children.length == 0){
+            if (this.getLayerData(viewLayerType) == null && !this.isDummyNode()){
+                return false;
+            }
+        } else {
+            for (let aChild of this.children) {
+                if (!(<ParseNodeDrawable> aChild).layerAll(viewLayerType)){
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    toTurkishSentence(): string{
+        if (this.children.length == 0){
+            if (this.getLayerData(ViewLayerType.TURKISH_WORD) != null && this.getLayerData(ViewLayerType.TURKISH_WORD) != "*NONE*"){
+                return " " + this.getLayerData(ViewLayerType.TURKISH_WORD)
+                    .replace("-LRB-", "(")
+                    .replace("-RRB-", ")")
+                    .replace("-LSB-", "[")
+                    .replace("-RSB-", "]")
+                    .replace("-LCB-", "{")
+                    .replace("-RCB-", "}")
+                    .replace("-lrb-", "(")
+                    .replace("-rrb-", ")")
+                    .replace("-lsb-", "[")
+                    .replace("-rsb-", "]")
+                    .replace("-lcb-", "{")
+                    .replace("-rcb-", "}");
+            } else {
+                return " ";
+            }
+        } else {
+            let st = "";
+            for (let aChild of this.children) {
+                st = st + (<ParseNodeDrawable> aChild).toTurkishSentence();
+            }
+            return st;
+        }
+    }
+
+    checkGazetteer(gazetteer: Gazetteer, word: string){
+        if (gazetteer.contains(word) && this.getParent().getData().getName() == "NNP"){
+            this.getLayerInfo().setLayerData(ViewLayerType.NER, gazetteer.getName());
+        }
+        if (word.includes("'") && gazetteer.contains(word.substring(0, word.indexOf("'"))) && this.getParent().getData().getName() == "NNP"){
+            this.getLayerInfo().setLayerData(ViewLayerType.NER, gazetteer.getName());
+        }
+    }
+
+    toString(): string{
+        if (this.children.length < 2){
+            if (this.children.length < 1){
+                return this.getLayerData();
+            } else {
+                return "(" + this.data.getName() + " " + this.children[0].toString() + ")";
+            }
+        } else {
+            let st = "(" + this.data.getName();
+            for (let aChild of this.children) {
+                st = st + " " + aChild.toString();
+            }
+            return st + ") ";
+        }
+    }
+}

package/source/ParseTreeDrawable.ts

@@ -0,0 +1,205 @@
+import {ParseTree} from "nlptoolkit-parsetree/dist/ParseTree";
+import {FileDescription} from "nlptoolkit-corpus/dist/FileDescription";
+import {ParseNode} from "nlptoolkit-parsetree/dist/ParseNode";
+import * as fs from "fs";
+import {ParseNodeDrawable} from "./ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import {Symbol} from "nlptoolkit-parsetree/dist/Symbol";
+import {NodeDrawableCollector} from "./Processor/NodeDrawableCollector";
+import {IsTurkishLeafNode} from "./Processor/Condition/IsTurkishLeafNode";
+import {AnnotatedSentence} from "nlptoolkit-annotatedsentence/dist/AnnotatedSentence";
+import {IsEnglishLeafNode} from "./Processor/Condition/IsEnglishLeafNode";
+import {AnnotatedWord} from "nlptoolkit-annotatedsentence/dist/AnnotatedWord";
+
+export class ParseTreeDrawable extends ParseTree{
+
+    private fileDescription: FileDescription
+    private name: string
+
+    constructor(fileDescriptionOrPath?: any, fileDescriptionOrFileName?: any, index?: number) {
+        super();
+        if (fileDescriptionOrPath instanceof FileDescription){
+            this.fileDescription = fileDescriptionOrPath
+            this.readFromFile(fileDescriptionOrPath.getPath())
+        } else {
+            if (fileDescriptionOrFileName == undefined){
+                let path: string = fileDescriptionOrPath
+                this.readFromFile(path)
+            } else {
+                if (fileDescriptionOrFileName instanceof FileDescription){
+                    let path: string = fileDescriptionOrPath
+                    let fileDescription: FileDescription = fileDescriptionOrFileName
+                    this.fileDescription = new FileDescription(path, fileDescription.getExtension(), fileDescription.getIndex())
+                    this.readFromFile(this.fileDescription.getPath())
+                } else {
+                    if (index == undefined){
+                        let path: string = fileDescriptionOrPath
+                        let rawFileName: string = fileDescriptionOrFileName
+                        this.fileDescription = new FileDescription(path, rawFileName)
+                        this.readFromFile(this.fileDescription.getPath())
+                    } else {
+                        let path: string = fileDescriptionOrPath
+                        let extension:  string = fileDescriptionOrFileName
+                        this.fileDescription = new FileDescription(path, extension, index)
+                        this.readFromFile(this.fileDescription.getPath())
+                    }
+                }
+            }
+        }
+    }
+
+    setFileDescription(fileDescription: FileDescription){
+        this.fileDescription = fileDescription
+    }
+
+    getFileDescription(){
+        return this.fileDescription
+    }
+
+    reload(){
+        this.readFromFile(this.fileDescription.getPath());
+    }
+
+    setRoot(newRootNode: ParseNode){
+        this.root = newRootNode
+    }
+
+    readFromFile(currentPath: string) {
+        let data = fs.readFileSync(currentPath, 'utf8')
+        let line = data.split("\n")[0]
+        if (line.includes("(") && line.includes(")")) {
+            line = line.substring(line.indexOf("(") + 1, line.lastIndexOf(")")).trim();
+            this.root = new ParseNodeDrawable(null, line, false, 0);
+        }
+    }
+
+    setName(name: string){
+        this.name = name
+    }
+
+    nextTree(count: number){
+        if (this.fileDescription.nextFileExists(count)){
+            this.fileDescription.addToIndex(count);
+            this.reload();
+        }
+    }
+
+    previousTree(count: number){
+        if (this.fileDescription.previousFileExists(count)){
+            this.fileDescription.addToIndex(-count);
+            this.reload();
+        }
+    }
+
+    maxDepth(): number{
+        return (<ParseNodeDrawable> this.root).maxDepth()
+    }
+
+    moveLeft(node: ParseNode){
+        if (this.root != node){
+            this.root.moveLeft(node);
+        }
+    }
+
+    moveRight(node: ParseNode){
+        if (this.root != node){
+            this.root.moveRight(node);
+        }
+    }
+
+    divideIntoWords(parseNode: ParseNodeDrawable) {
+        let layers = parseNode.getLayerInfo().divideIntoWords();
+        parseNode.getParent().removeChild(parseNode);
+        for (let layerInfo of layers) {
+            let symbol
+            if (layerInfo.layerExists(ViewLayerType.INFLECTIONAL_GROUP)) {
+                symbol = new Symbol(layerInfo.getMorphologicalParseAt(0).getTreePos());
+            } else {
+                symbol = new Symbol("-XXX-");
+            }
+            let child = new ParseNodeDrawable(symbol);
+            parseNode.getParent().addChild(child);
+            let grandChild = new ParseNodeDrawable(child, layerInfo.getLayerDescription(), true, parseNode.getDepth() + 1);
+            child.addChild(grandChild);
+            (<ParseNodeDrawable>this.root).updateDepths(0);
+        }
+    }
+
+    moveNode(fromNode: ParseNode, toNode: ParseNode, childIndex?: number){
+        if (this.root != fromNode){
+            let parent = fromNode.getParent();
+            parent.removeChild(fromNode);
+            toNode.addChild(fromNode, childIndex);
+            (<ParseNodeDrawable> this.root).updateDepths(0);
+        }
+    }
+
+    combineWords(parent: ParseNodeDrawable, child: ParseNodeDrawable){
+        while (parent.numberOfChildren() > 0){
+            parent.removeChild(parent.firstChild());
+        }
+        parent.addChild(child);
+        (<ParseNodeDrawable> this.root).updateDepths(0);
+    }
+
+    layerExists(viewLayerType: ViewLayerType): boolean{
+        return (<ParseNodeDrawable>(this.root)).layerExists(viewLayerType);
+    }
+
+    layerAll(viewLayerType: ViewLayerType): boolean{
+        return (<ParseNodeDrawable>(this.root)).layerAll(viewLayerType);
+    }
+
+    clearLayer(layerType: ViewLayerType){
+        if (this.root != null){
+            (<ParseNodeDrawable>this.root).clearLayer(layerType);
+        }
+    }
+
+    nextLeafNode(parseNode: ParseNodeDrawable): ParseNodeDrawable {
+        let nodeDrawableCollector = new NodeDrawableCollector(<ParseNodeDrawable>this.root, new IsTurkishLeafNode());
+        let leafList = nodeDrawableCollector.collect();
+        for (let i = 0; i < leafList.length - 1; i++){
+            if (leafList[i] == parseNode){
+                return leafList[i + 1];
+            }
+        }
+        return null;
+    }
+
+    previousLeafNode(parseNode: ParseNodeDrawable): ParseNodeDrawable {
+        let nodeDrawableCollector = new NodeDrawableCollector(<ParseNodeDrawable>this.root, new IsTurkishLeafNode());
+        let leafList = nodeDrawableCollector.collect();
+        for (let i = 1; i < leafList.length; i++){
+            if (leafList[i] == parseNode){
+                return leafList[i - 1];
+            }
+        }
+        return null;
+    }
+
+    generateAnnotatedSentence(language?: string): AnnotatedSentence{
+        if (language == undefined){
+            let sentence = new AnnotatedSentence();
+            let nodeDrawableCollector = new NodeDrawableCollector(<ParseNodeDrawable>this.root, new IsTurkishLeafNode());
+            let leafList = nodeDrawableCollector.collect();
+            for (let parseNode of leafList){
+                let layers = parseNode.getLayerInfo();
+                for (let i = 0; i < layers.getNumberOfWords(); i++){
+                    sentence.addWord(layers.toAnnotatedWord(i));
+                }
+            }
+            return sentence;
+        } else {
+            let sentence = new AnnotatedSentence();
+            let nodeDrawableCollector = new NodeDrawableCollector(<ParseNodeDrawable>this.root, new IsEnglishLeafNode());
+            let leafList = nodeDrawableCollector.collect();
+            for (let parseNode of leafList){
+                let newWord = new AnnotatedWord("{" + language + "=" + parseNode.getData().getName() + "}{posTag="
+                    + parseNode.getParent().getData().getName() + "}");
+                sentence.addWord(newWord);
+            }
+            return sentence;
+        }
+    }
+}

package/source/Processor/Condition/IsDoubleNode.ts

@@ -0,0 +1,13 @@
+import {NodeDrawableCondition} from "./NodeDrawableCondition";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export class IsDoubleNode implements NodeDrawableCondition{
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        return parseNode.numberOfChildren() == 1
+            && parseNode.getChild(0).numberOfChildren() >= 1
+            && !parseNode.getChild(0).isLeaf()
+            && parseNode.getData() == parseNode.getChild(0).getData();
+    }
+
+}

package/source/Processor/Condition/IsDoubleNodeWithDifferentTags.ts

@@ -0,0 +1,13 @@
+import {NodeDrawableCondition} from "./NodeDrawableCondition";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export class IsDoubleNodeWithDifferentTags implements NodeDrawableCondition{
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        return parseNode.numberOfChildren() == 1
+            && parseNode.getChild(0).numberOfChildren() >= 1
+            && !parseNode.getChild(0).isLeaf()
+            && parseNode.getData() != parseNode.getChild(0).getData();
+    }
+
+}

package/source/Processor/Condition/IsEnglishLeafNode.ts

@@ -0,0 +1,14 @@
+import {IsLeafNode} from "./IsLeafNode";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {IsNullElement} from "./IsNullElement";
+
+export class IsEnglishLeafNode extends IsLeafNode{
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        if (super.satisfies(parseNode)) {
+            return !new IsNullElement().satisfies(parseNode);
+        }
+        return false;
+    }
+
+}

package/source/Processor/Condition/IsLeafNode.ts

@@ -0,0 +1,10 @@
+import {NodeDrawableCondition} from "./NodeDrawableCondition";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export class IsLeafNode implements NodeDrawableCondition{
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        return parseNode.numberOfChildren() == 0;
+    }
+
+}

package/source/Processor/Condition/IsNodeWithPredicate.ts

@@ -0,0 +1,19 @@
+import {IsNodeWithSynSetId} from "./IsNodeWithSynSetId";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class IsNodeWithPredicate extends IsNodeWithSynSetId{
+
+    constructor(id: string) {
+        super(id);
+    }
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        let layerInfo = parseNode.getLayerInfo();
+        return super.satisfies(parseNode)
+            && layerInfo != null
+            && layerInfo.getLayerData(ViewLayerType.PROPBANK) != null
+            && layerInfo.getLayerData(ViewLayerType.PROPBANK) == "PREDICATE";
+    }
+
+}

package/source/Processor/Condition/IsNodeWithSymbol.ts

@@ -0,0 +1,20 @@
+import {NodeDrawableCondition} from "./NodeDrawableCondition";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export class IsNodeWithSymbol implements NodeDrawableCondition{
+
+    private symbol: string
+
+    constructor(symbol: string) {
+        this.symbol = symbol
+    }
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        if (parseNode.numberOfChildren() > 0){
+            return parseNode.getData().toString() == this.symbol;
+        } else {
+            return false;
+        }
+    }
+
+}

package/source/Processor/Condition/IsNodeWithSynSetId.ts

@@ -0,0 +1,26 @@
+import {IsLeafNode} from "./IsLeafNode";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export class IsNodeWithSynSetId extends IsLeafNode{
+
+    private id: string
+
+    constructor(id: string) {
+        super();
+        this.id = id
+    }
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        if (super.satisfies(parseNode)){
+            let layerInfo = parseNode.getLayerInfo();
+            for (let i = 0; i < layerInfo.getNumberOfMeanings(); i++) {
+                let synSetId = layerInfo.getSemanticAt(i);
+                if (synSetId == this.id){
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+}

package/source/Processor/Condition/IsNoneNode.ts

@@ -0,0 +1,22 @@
+import {IsLeafNode} from "./IsLeafNode";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export class IsNoneNode extends IsLeafNode{
+
+    private secondLanguage: ViewLayerType
+
+    constructor(secondLanguage: ViewLayerType) {
+        super();
+        this.secondLanguage = secondLanguage
+    }
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        if (super.satisfies(parseNode)){
+            let data = parseNode.getLayerData(this.secondLanguage);
+            return data != null && data == "*NONE*";
+        }
+        return false;
+    }
+
+}

package/source/Processor/Condition/IsNullElement.ts

@@ -0,0 +1,16 @@
+import {IsLeafNode} from "./IsLeafNode";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class IsNullElement extends IsLeafNode{
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        if (super.satisfies(parseNode)){
+            let data = parseNode.getLayerData(ViewLayerType.ENGLISH_WORD);
+            let parentData = parseNode.getParent().getData().getName();
+            return data.includes("*") || (data == "0" && parentData == "-NONE-");
+        }
+        return false;
+    }
+
+}

package/source/Processor/Condition/IsNumber.ts

@@ -0,0 +1,16 @@
+import {IsLeafNode} from "./IsLeafNode";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class IsNumber extends IsLeafNode{
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        if (super.satisfies(parseNode)){
+            let data = parseNode.getLayerData(ViewLayerType.ENGLISH_WORD);
+            let parentData = parseNode.getParent().getData().getName();
+            return parentData == "CD" && !Number.isNaN(data);
+        }
+        return false;
+    }
+
+}

package/source/Processor/Condition/IsPredicateVerbNode.ts

@@ -0,0 +1,19 @@
+import {IsVerbNode} from "./IsVerbNode";
+import {WordNet} from "nlptoolkit-wordnet/dist/WordNet";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export class IsPredicateVerbNode extends IsVerbNode{
+
+    constructor(wordNet: WordNet) {
+        super(wordNet);
+    }
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        let layerInfo = parseNode.getLayerInfo();
+        return super.satisfies(parseNode)
+            && layerInfo != null
+            && layerInfo.getArgument() != null
+            && layerInfo.getArgument().getArgumentType() == "PREDICATE";
+    }
+
+}

package/source/Processor/Condition/IsProperNoun.ts

@@ -0,0 +1,14 @@
+import {IsLeafNode} from "./IsLeafNode";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export class IsProperNoun extends IsLeafNode{
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        if (super.satisfies(parseNode)){
+            let parentData = parseNode.getParent().getData().getName();
+            return parentData == "NNP" || parentData == "NNPS";
+        }
+        return false;
+    }
+
+}