@cmu-eberly-center/eberly-ontopic-visualization
Version:
Writing tasks require countless composing decisions that are typically beyond the conscious grasp of student writers. Much of the skill of being “text-aware” is to understand that texts are composed of highly structured and often highly predictive composi
592 lines (504 loc) • 14.7 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
var _react = _interopRequireDefault(require("react"));
var _pluralize = _interopRequireDefault(require("./utils/pluralize"));
var _Sentence = _interopRequireDefault(require("./utils/Sentence"));
var _HashTable = _interopRequireDefault(require("./utils/HashTable"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
/**
* @returns
*/
var OnTopicDataTools = /*#__PURE__*/function () {
/**
*
*/
function OnTopicDataTools() {
_classCallCheck(this, OnTopicDataTools);
this.pluralizer = new _pluralize["default"]();
}
/**
*
*/
_createClass(OnTopicDataTools, [{
key: "isEmpty",
value: function isEmpty(str) {
return !str || 0 === str.length;
}
/**
*
*/
}, {
key: "isBlank",
value: function isBlank(str) {
return !str || /^\s*$/.test(str);
}
/**
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split
*/
}, {
key: "detect",
value: function detect(word, term) {
//console.log ("detect ()");
var result = [false, "", "", ""];
var pre = "";
var post = "";
var found = false;
var parts = word.split(/([.,\/#!$%\^&\*;:{}=\-_`~()])/);
for (var i = 0; i < parts.length; i++) {
var test = parts[i];
if (term == test) {
found = true;
result[0] = true;
result[2] = term;
} else {
var plural = this.pluralizer.pluralize(term);
if (test == plural) {
found = true;
result[0] = true;
result[2] = plural;
post = post + plural.substring(term.length);
} else {
if (found == false) {
pre = pre + test;
} else {
post = post + test;
}
}
}
}
result[1] = pre;
result[3] = post;
/*
if (result [0]==true) {
console.log (parts);
console.log (pre + "" + post);
}
*/
return result;
}
/**
*
*/
}, {
key: "parseSentence",
value: function parseSentence(text, needle, deep) {
//console.log ("parseSentence ("+needle+")");
if (deep == false) {
return text.split(needle);
}
var result = [];
var parts = text.split(" ");
var builder = "";
var found = false;
var index = 0;
for (var i = 0; i < parts.length; i++) {
var comparator = parts[i];
var detector = this.detect(comparator, needle);
if (detector[0] == true) {
if (index > 0) {
builder = builder + " ";
}
result.push(builder + detector[1]);
builder = detector[3];
found = true;
} else {
if (index > 0) {
builder = builder + " " + comparator;
} else {
builder = builder + comparator;
}
}
index++;
}
if (builder != "") {
result.push(" " + builder);
}
if (found == false) {
result.push(text);
}
return result;
}
/**
*
*/
}, {
key: "buildSentenceModel",
value: function buildSentenceModel(aBlock, aSentence) {
//console.log ("buildSentenceModel ("+aSentence+")");
//console.log (aBlock);
var newSentence = new _Sentence["default"]();
newSentence.full = aSentence;
newSentence.verb = "have";
var NPS = aBlock["NPS"]; //console.log (aBlock ["L_NPS"] + ", " + (aBlock ["L_NPS"]+1) + " => " + NPS.length);
var leftOfVerb = NPS[aBlock["L_NPS"] - 1];
var rightOfVerb = NPS[aBlock["L_NPS"]]; //console.log ("... " + leftOfVerb + " <Verb> " + rightOfVerb + " ...");
return newSentence;
}
/**
*
*/
}, {
key: "findSentence",
value: function findSentence(aText, aSentence) {
//console.log ("findSentence ()");
//console.log (aText);
//console.log (aSentence);
var sBoundaries = {
begin: -1,
end: -1
};
if (this.isBlank(aSentence.full) == true) {
return aBoundaries;
}
var parts = aText.split(" ");
var target = aSentence.full.split(" "); // We need this to be able to re-construct the higlight begin and end
var nrSpaces = parts.length - 1;
var beginIndex = 0;
var endIndex = 0;
for (var i = 0; i < parts.length; i++) {
var term = parts[i]; // start the comparison
if (term == target[0]) {
var runningIndex = 0;
endIndex = beginIndex;
for (var j = 0; j < target.length; j++) {
// The target sentence extends beyond the test paragraph and hasn't been matched
if (j > parts.length - 1) {
return sBoundaries;
}
var targetTerm = target[j];
var testTerm = parts[i + j];
if (testTerm != targetTerm) {
break;
}
runningIndex++;
endIndex += testTerm.length + 1; // Probably off by at least 1
}
if (runningIndex == target.length) {
console.log("Bingo!");
sBoundaries.begin = beginIndex;
sBoundaries.end = endIndex;
return sBoundaries;
}
}
beginIndex += term.length + 1; // Probably off by at least 1
}
return sBoundaries;
}
/**
*
*/
}, {
key: "generateTableHeader",
value: function generateTableHeader() {
return [{
Header: 'Parameter',
accessor: 'parameter'
}, {
Header: 'Value',
accessor: 'value'
}];
}
/**
*
*/
}, {
key: "parameterSetValue",
value: function parameterSetValue(aParameters, aParameter, aValue) {
//console.log ("parameterSetValue ("+aValue+")");
//console.log ("Original parameters: " + JSON.stringify (aParameters));
for (var key in aParameters) {
if (aParameters.hasOwnProperty(key)) {
if (key == aParameter) {
aParameters[aParameter].value = aValue;
}
}
} //console.log ("New parameters: " + JSON.stringify (aParameters));
return aParameters;
}
/**
*
*/
}, {
key: "handleParameterChange",
value: function handleParameterChange(param, event) {
//console.log ("handleParameterChange("+param+")");
var data = event.target.value; //console.log (param + " => " + data);
}
/**
* This is a method that generates a shallow, non-editable version of a
* parameter list
*/
}, {
key: "parameterJSONtoArray",
value: function parameterJSONtoArray(anObjectMap) {
//console.log ("parameterJSONtoArray ()");
//console.log ("Parameter object: " + JSON.stringify (anObjectMap));
var newArray = new Array();
for (var key in anObjectMap) {
if (anObjectMap.hasOwnProperty(key)) {
if (key != "dummy") {
//console.log(key + " -> " + JSON.stringify (anObjectMap[key]));
var parameterObject = new Object();
parameterObject.parameter = key;
parameterObject.value = anObjectMap[key];
newArray.push(parameterObject);
}
}
}
return newArray;
}
/**
*
*/
}, {
key: "parameterArrayToJSON",
value: function parameterArrayToJSON(anArray) {
var parameterObject = new Object();
for (var i = 0; i < anArray.length; i++) {
var testObject = anArray[i];
if (testObject.path) {
parameterObject[testObject.parameter] = testObject.path;
} else {
parameterObject[testObject.parameter] = testObject.value;
}
}
return parameterObject;
}
/**
*
*/
}, {
key: "jsonToTable",
value: function jsonToTable(tablejson) {
return this.parameterJSONtoArray(tablejson);
}
/**
*
*/
}, {
key: "uuidv4",
value: function uuidv4() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = Math.random() * 16 | 0,
v = c == 'x' ? r : r & 0x3 | 0x8;
return v.toString(16);
});
}
/**
*
*/
}, {
key: "deleteElement",
value: function deleteElement(anArray, aTarget) {
for (var i = 0; i < anArray.length; i++) {
if (anArray[i] === aTarget) {
//console.log ("Deleting element ...");
anArray.splice(i, 1);
return anArray;
}
}
return anArray;
}
/**
*
*/
}, {
key: "popElement",
value: function popElement(anArray) {
//console.log ("popElement ()");
if (!anArray) {
return anArray;
}
if (anArray.length == 0) {
return anArray;
} //console.log ("Before pop: " + anArray.length);
anArray.splice(anArray.length - 1, 1); //console.log ("After pop: " + anArray.length);
return anArray;
}
/**
* https://www.mattzeunert.com/2016/01/28/javascript-deep-equal.html
*/
}, {
key: "jsonEqual",
value: function jsonEqual(a, b) {
return JSON.stringify(a) === JSON.stringify(b);
}
/**
*
*/
}, {
key: "syntaxHighlight",
value: function syntaxHighlight(json) {
if (typeof json != 'string') {
json = JSON.stringify(json, undefined, 2);
}
json = json.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>');
return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match) {
var cls = 'number';
if (/^"/.test(match)) {
if (/:$/.test(match)) {
cls = 'key';
} else {
cls = 'string';
}
} else if (/true|false/.test(match)) {
cls = 'boolean';
} else if (/null/.test(match)) {
cls = 'null';
}
return '<span class="' + cls + '">' + match + '</span>';
});
}
/**
*
*/
}, {
key: "getDateString",
value: function getDateString() {
var today = new Date();
var date = today.getFullYear() + '-' + (today.getMonth() + 1) + '-' + today.getDate();
var time = today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds();
var dateTime = date + ' ' + time;
return dateTime;
}
/**
*
*/
}, {
key: "isString",
value: function isString(aVar) {
if (typeof aVar === 'string' || aVar instanceof String) return true;
return false;
}
/**
*
*/
}, {
key: "isNumber",
value: function isNumber(n) {
return !isNaN(parseFloat(n)) && !isNaN(n - 0);
}
/**
*
*/
}, {
key: "capitalizeFLetter",
value: function capitalizeFLetter(string) {
return string[0].toUpperCase() + string.slice(1);
}
/**
*
*/
}, {
key: "isEmptyRow",
value: function isEmptyRow(aRow) {
for (var i = 0; i < aRow.length; i++) {
var testObject = aRow[i];
if (testObject[0] != null) {
return false;
}
}
return true;
}
/**
*
*/
}, {
key: "debugStringArray",
value: function debugStringArray(anArray) {
for (var i = 0; i < anArray.length; i++) {
console.log("'" + anArray[i] + "'");
}
}
/**
*
*/
}, {
key: "getInitialData",
value: function getInitialData() {
return {
valueRaw: null,
topics: null,
topic: new _HashTable["default"](),
sentences: null,
sentence: null,
collapsed: null,
expanded: null,
pValue: "",
pTarget: -1
};
}
/**
* We need to switch to using the immutable package. That way we
* avoid really expensive deep copies through bad tricks like the
* one below.
* @param {any} anObject
*/
}, {
key: "deepCopy",
value: function deepCopy(anObject) {
if (anObject == null) {
return null;
}
return JSON.parse(JSON.stringify(anObject));
}
/**
*
*/
}, {
key: "copyTopics",
value: function copyTopics(aTopics) {
//console.log ("copyTopics ()");
if (aTopics == null) {
return null;
}
var length = aTopics.getLength();
var items = aTopics.getItems();
var newItems = this.deepCopy(items);
var topics = new _HashTable["default"]();
topics.setItems(newItems, length);
return topics;
}
/**
textdata: {
valueRaw: null,
plain: "", // replacement of valueRaw, as in actual textual text
topics: new HashTable (),
topic: null,
sentences: null,
sentence: null,
collapsed: null,
expanded: null
}
*/
}, {
key: "copyData",
value: function copyData(textData) {
//console.log ("copyData ()");
if (textData == null) {
return null;
}
var newTopics = this.copyTopics(textData.topics);
var newData = {
valueRaw: this.deepCopy(textData.valueRaw),
plain: this.deepCopy(textData.plan),
topics: newTopics,
topic: this.deepCopy(textData.topic),
sentences: this.deepCopy(textData.sentences),
sentence: this.deepCopy(textData.sentence),
collapsed: this.deepCopy(textData.collapsed),
expanded: this.deepCopy(textData.expanded)
};
return newData;
}
}]);
return OnTopicDataTools;
}();
var _default = OnTopicDataTools;
exports["default"] = _default;