speech-rule-engine
Version:
A standalone speech rule engine for XML structures, based on the original engine from ChromeVox.
287 lines • 11.1 kB
JavaScript
import { Span } from '../audio/span.js';
import * as DomUtil from '../common/dom_util.js';
import { Engine } from '../common/engine.js';
import * as XpathUtil from '../common/xpath_util.js';
import { LOCALE } from '../l10n/locale.js';
import { vulgarFractionSmall } from '../l10n/transformers.js';
import { Grammar } from '../rule_engine/grammar.js';
import * as StoreUtil from '../rule_engine/store_util.js';
import { register } from '../semantic_tree/semantic_annotations.js';
import { SemanticAnnotator } from '../semantic_tree/semantic_annotator.js';
import { isMatchingFence } from '../semantic_tree/semantic_attr.js';
import { SemanticRole, SemanticType } from '../semantic_tree/semantic_meaning.js';
export function nodeCounter(nodes, context) {
const split = context.split('-');
const func = StoreUtil.nodeCounter(nodes, split[0] || '');
const sep = split[1] || '';
const init = split[2] || '';
let first = true;
return function () {
const result = func();
if (first) {
first = false;
return init + result + sep;
}
else {
return result + sep;
}
};
}
function isSimpleExpression(node) {
return (isSimpleNumber_(node) ||
isSimpleLetters_(node) ||
isSimpleDegree_(node) ||
isSimpleNegative_(node) ||
isSimpleFunction_(node));
}
function isSimpleFunction_(node) {
return (node.type === SemanticType.APPL &&
(node.childNodes[0].role === SemanticRole.PREFIXFUNC ||
node.childNodes[0].role === SemanticRole.SIMPLEFUNC) &&
(isSimple_(node.childNodes[1]) ||
(node.childNodes[1].type === SemanticType.FENCED &&
isSimple_(node.childNodes[1].childNodes[0]))));
}
function isSimpleNegative_(node) {
return (node.type === SemanticType.PREFIXOP &&
node.role === SemanticRole.NEGATIVE &&
isSimple_(node.childNodes[0]) &&
node.childNodes[0].type !== SemanticType.PREFIXOP &&
node.childNodes[0].type !== SemanticType.APPL &&
node.childNodes[0].type !== SemanticType.PUNCTUATED);
}
function isSimpleDegree_(node) {
return (node.type === SemanticType.PUNCTUATED &&
node.role === SemanticRole.ENDPUNCT &&
node.childNodes.length === 2 &&
node.childNodes[1].role === SemanticRole.DEGREE &&
(isLetter_(node.childNodes[0]) ||
isNumber_(node.childNodes[0]) ||
(node.childNodes[0].type === SemanticType.PREFIXOP &&
node.childNodes[0].role === SemanticRole.NEGATIVE &&
(isLetter_(node.childNodes[0].childNodes[0]) ||
isNumber_(node.childNodes[0].childNodes[0])))));
}
function isSimpleLetters_(node) {
return (isLetter_(node) ||
(node.type === SemanticType.INFIXOP &&
node.role === SemanticRole.IMPLICIT &&
((node.childNodes.length === 2 &&
(isLetter_(node.childNodes[0]) ||
isSimpleNumber_(node.childNodes[0])) &&
isLetter_(node.childNodes[1])) ||
(node.childNodes.length === 3 &&
isSimpleNumber_(node.childNodes[0]) &&
isLetter_(node.childNodes[1]) &&
isLetter_(node.childNodes[2])))));
}
function isSimple_(node) {
return node.hasAnnotation('clearspeak', 'simple');
}
function isLetter_(node) {
return (node.type === SemanticType.IDENTIFIER &&
(node.role === SemanticRole.LATINLETTER ||
node.role === SemanticRole.GREEKLETTER ||
node.role === SemanticRole.OTHERLETTER ||
node.role === SemanticRole.SIMPLEFUNC));
}
function isNumber_(node) {
return (node.type === SemanticType.NUMBER &&
(node.role === SemanticRole.INTEGER || node.role === SemanticRole.FLOAT));
}
function isSimpleNumber_(node) {
return isNumber_(node) || isSimpleFraction_(node);
}
function isSimpleFraction_(node) {
if (hasPreference('Fraction_Over') || hasPreference('Fraction_FracOver')) {
return false;
}
if (node.type !== SemanticType.FRACTION ||
node.role !== SemanticRole.VULGAR) {
return false;
}
if (hasPreference('Fraction_Ordinal')) {
return true;
}
const enumerator = parseInt(node.childNodes[0].textContent, 10);
const denominator = parseInt(node.childNodes[1].textContent, 10);
return (enumerator > 0 && enumerator < 20 && denominator > 0 && denominator < 11);
}
function hasPreference(pref) {
return Engine.getInstance().options.style === pref;
}
register(new SemanticAnnotator('clearspeak', 'simple', function (node) {
return isSimpleExpression(node) ? 'simple' : '';
}));
function simpleNode(node) {
if (!node.hasAttribute('annotation')) {
return false;
}
const annotation = node.getAttribute('annotation');
return !!/clearspeak:simple$|clearspeak:simple;/.exec(annotation);
}
function simpleCell_(node) {
if (simpleNode(node)) {
return true;
}
if (node.tagName !== SemanticType.SUBSCRIPT) {
return false;
}
const children = node.childNodes[0].childNodes;
const index = children[1];
return (children[0].tagName === SemanticType.IDENTIFIER &&
(isInteger_(index) ||
(index.tagName === SemanticType.INFIXOP &&
index.hasAttribute('role') &&
index.getAttribute('role') === SemanticRole.IMPLICIT &&
allIndices_(index))));
}
function isInteger_(node) {
return (node.tagName === SemanticType.NUMBER &&
node.hasAttribute('role') &&
node.getAttribute('role') === SemanticRole.INTEGER);
}
function allIndices_(node) {
const nodes = XpathUtil.evalXPath('children/*', node);
return nodes.every((x) => isInteger_(x) || x.tagName === SemanticType.IDENTIFIER);
}
export function allCellsSimple(node) {
const xpath = node.tagName === SemanticType.MATRIX
? 'children/row/children/cell/children/*'
: 'children/line/children/*';
const nodes = XpathUtil.evalXPath(xpath, node);
const result = nodes.every(simpleCell_);
return result ? [node] : [];
}
export function isSmallVulgarFraction(node) {
return vulgarFractionSmall(node, 20, 11) ? [node] : [];
}
function isUnitExpression(node) {
return ((node.type === SemanticType.TEXT && node.role !== SemanticRole.LABEL) ||
(node.type === SemanticType.PUNCTUATED &&
node.role === SemanticRole.TEXT &&
isNumber_(node.childNodes[0]) &&
allTextLastContent_(node.childNodes.slice(1))) ||
(node.type === SemanticType.IDENTIFIER &&
node.role === SemanticRole.UNIT) ||
(node.type === SemanticType.INFIXOP &&
(node.role === SemanticRole.IMPLICIT || node.role === SemanticRole.UNIT)));
}
function allTextLastContent_(nodes) {
for (let i = 0; i < nodes.length - 1; i++) {
if (!(nodes[i].type === SemanticType.TEXT && nodes[i].textContent === '')) {
return false;
}
}
return nodes[nodes.length - 1].type === SemanticType.TEXT;
}
register(new SemanticAnnotator('clearspeak', 'unit', function (node) {
return isUnitExpression(node) ? 'unit' : '';
}));
export function ordinalExponent(node) {
const num = parseInt(node.textContent, 10);
return [
Span.stringEmpty(isNaN(num)
? node.textContent
: num > 10
? LOCALE.NUMBERS.numericOrdinal(num)
: LOCALE.NUMBERS.wordOrdinal(num))
];
}
let NESTING_DEPTH = null;
export function nestingDepth(node) {
let count = 0;
const fence = node.textContent;
const index = node.getAttribute('role') === 'open' ? 0 : 1;
let parent = node.parentNode;
while (parent) {
if (parent.tagName === SemanticType.FENCED &&
parent.childNodes[0].childNodes[index].textContent === fence) {
count++;
}
parent = parent.parentNode;
}
NESTING_DEPTH = count > 1 ? LOCALE.NUMBERS.wordOrdinal(count) : '';
return [Span.stringEmpty(NESTING_DEPTH)];
}
export function matchingFences(node) {
const sibling = node.previousSibling;
let left, right;
if (sibling) {
left = sibling;
right = node;
}
else {
left = node;
right = node.nextSibling;
}
if (!right) {
return [];
}
return isMatchingFence(left.textContent, right.textContent) ? [node] : [];
}
function insertNesting(text, correction) {
if (!correction || !text) {
return text;
}
const start = text.match(/^(open|close) /);
if (!start) {
return correction + ' ' + text;
}
return start[0] + correction + ' ' + text.substring(start[0].length);
}
Grammar.getInstance().setCorrection('insertNesting', insertNesting);
export function fencedArguments(node) {
const content = DomUtil.toArray(node.parentNode.childNodes);
const children = XpathUtil.evalXPath('../../children/*', node);
const index = content.indexOf(node);
return fencedFactor_(children[index]) || fencedFactor_(children[index + 1])
? [node]
: [];
}
export function simpleArguments(node) {
const content = DomUtil.toArray(node.parentNode.childNodes);
const children = XpathUtil.evalXPath('../../children/*', node);
const index = content.indexOf(node);
return simpleFactor_(children[index]) &&
children[index + 1] &&
(simpleFactor_(children[index + 1]) ||
children[index + 1].tagName === SemanticType.ROOT ||
children[index + 1].tagName === SemanticType.SQRT ||
(children[index + 1].tagName === SemanticType.SUPERSCRIPT &&
children[index + 1].childNodes[0].childNodes[0] &&
(children[index + 1].childNodes[0].childNodes[0]
.tagName === SemanticType.NUMBER ||
children[index + 1].childNodes[0].childNodes[0]
.tagName === SemanticType.IDENTIFIER) &&
(children[index + 1].childNodes[0].childNodes[1].textContent === '2' ||
children[index + 1].childNodes[0].childNodes[1].textContent === '3')))
? [node]
: [];
}
function simpleFactor_(node) {
return (!!node &&
(node.tagName === SemanticType.NUMBER ||
node.tagName === SemanticType.IDENTIFIER ||
node.tagName === SemanticType.FUNCTION ||
node.tagName === SemanticType.APPL ||
node.tagName === SemanticType.FRACTION));
}
function fencedFactor_(node) {
return (node &&
(node.tagName === SemanticType.FENCED ||
(node.hasAttribute('role') &&
node.getAttribute('role') === SemanticRole.LEFTRIGHT) ||
layoutFactor_(node)));
}
function layoutFactor_(node) {
return (!!node &&
(node.tagName === SemanticType.MATRIX ||
node.tagName === SemanticType.VECTOR));
}
export function wordOrdinal(node) {
return [
Span.stringEmpty(LOCALE.NUMBERS.wordOrdinal(parseInt(node.textContent, 10)))
];
}
//# sourceMappingURL=clearspeak_util.js.map