proskomma-core 0.9.10 → 0.9.13

package/src/graph/queries/row_match_spec.cjs

@@ -0,0 +1,11 @@
+const rowMatchSpecSchemaString = `
+"""Row Match Specification"""
+input rowMatchSpec {
+  """The position of the column in which to search a match"""
+  colN: Int!
+  """The regex to match"""
+  matching: String!
+}
+`;
+
+module.exports = { rowMatchSpecSchemaString };

package/src/graph/queries/selector_spec.cjs

@@ -0,0 +1,29 @@
+const selectorSpecSchemaString = `
+"""Specification of a selector"""
+type selectorSpec {
+  """Name (ie the key)"""
+  name: String!
+  """Data type (string or integer)"""
+  type: String!
+  """Regex for validating string selector"""
+  regex: String
+  """Inclusive minimum value for integer selector"""
+  min: String
+  """Inclusive maximum value for integer selector"""
+  max: String
+  """Enum of permitted string values"""
+  enum: [String!]
+}
+`;
+
+const selectorSpecResolvers = {
+  regex: root => root.regex || null,
+  min: root => root.min || null,
+  max: root => root.max || null,
+  enum: root => root.enum || null,
+};
+
+module.exports = {
+  selectorSpecSchemaString,
+  selectorSpecResolvers,
+};

package/src/graph/queries/sequence.cjs

@@ -0,0 +1,314 @@
+const {
+  sequenceHasChars,
+  sequenceHasMatchingChars,
+  regexSearchTermIndexes,
+  exactSearchTermIndexes,
+} = require('../lib/sequence_chars.cjs');
+
+const options = {
+  tokens: false,
+  scopes: true,
+  grafts: false,
+  requiredScopes: [],
+};
+
+const blockHasAtts = (docSet, block, attSpecsArray, attValuesArray, requireAll) => {
+  let matched = new Set([]);
+
+  for (const item of docSet.unsuccinctifyPrunedItems(block, options, false)) {
+    const [att, attType, element, key, count, value] = item[2].split('/');
+
+    for (const [n, attSpecs] of attSpecsArray.entries()) {
+      for (const attSpec of attSpecs) {
+        if (
+          attType === attSpec.attType &&
+          element === attSpec.tagName &&
+          key === attSpec.attKey &&
+          parseInt(count) === attSpec.valueN &&
+          attValuesArray[n].includes(value)
+        ) {
+          if (!requireAll) {
+            return true;
+          }
+          matched.add(n);
+          break;
+        }
+      }
+
+      if (matched.size === attSpecsArray.length) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+const sequenceSchemaString = `
+"""A contiguous flow of content"""
+type Sequence {
+  """The id of the sequence"""
+  id: String!
+  """The type of the sequence (main, heading...)"""
+  type: String!
+  """The number of blocks in the sequence"""
+  nBlocks: Int!
+  """The blocks in the sequence"""
+  blocks(
+    """Only return blocks where the list of scopes is open"""
+    withScopes: [String!]
+    """Only return blocks whose zero-indexed position is in the list"""
+    positions: [Int!]
+    """Only return blocks with the specified block scope (eg 'blockScope/p'"""
+    withBlockScope: String
+    """Only return blocks that contain items within the specified chapter, verse or chapterVerse range"""
+    withScriptureCV: String
+    """Ordered list of attribute specs whose values must match those in 'attValues'"""
+    attSpecs: [[AttSpec!]!]
+    """Ordered list of attribute values, used in conjunction with \\'attSpecs\\'"""
+    attValues: [[String!]!]
+    """If true, blocks where all attSpecs match will be included"""
+    allAtts: Boolean
+    """Return blocks containing a token whose payload is an exact match to one of the specified strings"""
+    withChars: [String!]
+    """Return blocks containing a token whose payload matches the specified regexes"""
+    withMatchingChars: [String!]
+    """If true, blocks where all regexes match will be included"""
+    allChars: Boolean
+  ): [Block!]!
+  """The items for each block in the sequence"""
+  blocksItems: [[Item!]!]
+  """The tokens for each block in the sequence"""
+  blocksTokens: [[Item!]!]
+  """The text for each block in the sequence"""
+  blocksText(
+    """If true, converts each whitespace character to a single space"""
+    normalizeSpace: Boolean
+  ): [String!]
+  """The text for the sequence"""
+  text(
+    """If true, converts each whitespace character to a single space"""
+    normalizeSpace: Boolean
+  ) : String!
+  """Sequence content grouped by scopes or milestones"""
+  itemGroups(
+    """Produce one itemGroup for every different match of the list of scopes"""
+    byScopes: [String!]
+    """Start a new itemGroup whenever a milestone in the list is encountered"""
+    byMilestones: [String!]
+  ) : [ItemGroup!]!
+  """A list of the tags of this sequence"""
+  tags: [String!]!
+  """A list of the tags of this sequence as key/value tuples"""
+  tagsKv: [KeyValue!]!
+  """Whether or not the sequence has the specified tag"""
+  hasTag(
+    """The specified tag"""
+    tagName: String!
+  ): Boolean!
+  """A list of wordLike token strings in a main sequence"""
+  wordLikes(
+    """Whether to coerce the strings (toLower|toUpper|none)"""
+    coerceCase: String
+  ) : [String!]!
+  """Returns true if a main sequence contains the specified tokens"""
+  hasChars(
+    """Token strings to be matched exactly"""
+    chars: [String!]
+    """If true all tokens must match"""
+    allChars: Boolean
+  ): Boolean!
+  """Returns true if a main sequence contains a match for specified regexes"""
+  hasMatchingChars(
+    """Regexes to be matched"""
+    chars: [String!]
+    """If true all regexes must match"""
+    allChars: Boolean
+  ): Boolean!
+}
+`;
+
+const sequenceResolvers = {
+  nBlocks: root => root.blocks.length,
+  blocks: (root, args, context) => {
+    context.docSet.maybeBuildEnumIndexes();
+
+    if (args.withScopes && args.withScriptureCV) {
+      throw new Error('Cannot specify both withScopes and withScriptureCV');
+    }
+
+    if (args.attSpecs && !args.attValues) {
+      throw new Error('Cannot specify attSpecs without attValues');
+    }
+
+    if (!args.attSpecs && args.attValues) {
+      throw new Error('Cannot specify attValues without attSpecs');
+    }
+
+    if (args.attSpecs && args.attValues && (args.attSpecs.length !== args.attValues.length)) {
+      throw new Error('attSpecs and attValues must be same length');
+    }
+
+    if (args.withChars && args.withMatchingChars) {
+      throw new Error('Cannot specify both withChars and withMatchingChars');
+    }
+
+    let ret = root.blocks;
+
+    if (args.positions) {
+      ret = Array.from(ret.entries()).filter(b => args.positions.includes(b[0])).map(b => b[1]);
+    }
+
+    if (args.withScopes) {
+      ret = ret.filter(b => context.docSet.allScopesInBlock(b, args.withScopes));
+    }
+
+    if (args.withScriptureCV) {
+      ret = context.docSet.blocksWithScriptureCV(ret, args.withScriptureCV);
+    }
+
+    if (args.attSpecs) {
+      ret = ret.filter(b => blockHasAtts(context.docSet, b, args.attSpecs, args.attValues, args.allAtts || false));
+    }
+
+    if (args.withBlockScope) {
+      ret = ret.filter(b => context.docSet.blockHasBlockScope(b, args.withBlockScope));
+    }
+
+    if (args.withChars) {
+      if (
+        root.type === 'main' &&
+        !sequenceHasChars(context.docSet, root, args.withChars, args.allChars)
+      ) {
+        return [];
+      }
+
+      let charsIndexesArray = exactSearchTermIndexes(context.docSet, args.withChars, args.allChars);
+
+      for (const charsIndexes of charsIndexesArray) {
+        ret = ret.filter(b => context.docSet.blockHasChars(b, charsIndexes));
+      }
+    }
+
+    if (args.withMatchingChars) {
+      if (
+        root.type === 'main' &&
+        !sequenceHasMatchingChars(context.docSet, root, args.withMatchingChars, args.allChars)
+      ) {
+        return [];
+      }
+
+      let charsIndexesArray = regexSearchTermIndexes(context.docSet, args.withMatchingChars, args.allChars);
+
+      for (const charsIndexes of charsIndexesArray) {
+        ret = ret.filter(b => context.docSet.blockHasChars(b, charsIndexes));
+      }
+    }
+    return ret;
+  },
+  blocksItems: (root, args, context) =>
+    root.blocks.map(b => context.docSet.unsuccinctifyItems(b.c, {}, null)),
+  blocksTokens: (root, args, context) =>
+    root.blocks.map(b => context.docSet.unsuccinctifyItems(b.c, { tokens: true }, null)),
+  blocksText: (root, args, context) =>
+    root.blocks.map(
+      b => {
+        let ret = context.docSet
+          .unsuccinctifyItems(b.c, { tokens: true }, null)
+          .map(t => t[2])
+          .join('');
+
+        if (args.normalizeSpace) {
+          ret = ret.replace(/[ \t\n\r]+/g, ' ');
+        }
+        return ret;
+      },
+    ),
+  text: (root, args, context) => {
+    let ret = root.blocks.map(b => context.docSet
+      .unsuccinctifyItems(b.c, { tokens: true }, null)
+      .map(t => t[2])
+      .join(''),
+    ).join('\n');
+
+    if (args.normalizeSpace) {
+      ret = ret.replace(/[ \t\n\r]+/g, ' ');
+    }
+    return ret;
+  },
+  itemGroups: (root, args, context) => {
+    if (args.byScopes && args.byMilestones) {
+      throw new Error('Cannot specify both byScopes and byMilestones');
+    }
+
+    if (!args.byScopes && !args.byMilestones) {
+      throw new Error('Must specify either byScopes or byMilestones');
+    }
+
+    if (args.byScopes) {
+      return context.docSet.sequenceItemsByScopes(
+        root.blocks,
+        args.byScopes,
+      );
+    } else {
+      return context.docSet.sequenceItemsByMilestones(root.blocks, args.byMilestones);
+    }
+  },
+  tags: root => Array.from(root.tags),
+  tagsKv: root => Array.from(root.tags).map(t => {
+    if (t.includes(':')) {
+      return [t.substring(0, t.indexOf(':')), t.substring(t.indexOf(':') + 1)];
+    } else {
+      return [t, ''];
+    }
+  }),
+  hasTag: (root, args) => root.tags.has(args.tagName),
+  wordLikes: (root, args, context) => {
+    if (root.type !== 'main') {
+      throw new Error(`Only available for the main sequence, not ${root.type}`);
+    }
+
+    if (args.coerceCase && !['toLower', 'toUpper', 'none'].includes(args.coerceCase)) {
+      throw new Error(`coerceCase, when present, must be 'toLower', 'toUpper' or 'none', not '${args.coerceCase}'`);
+    }
+    context.docSet.maybeBuildEnumIndexes();
+    let tokens = new Set();
+    let n = 0;
+
+    for (const b of root.tokensPresent) {
+      if (b) {
+        const enumOffset = context.docSet.enumIndexes['wordLike'][n];
+        let tokenString = context.docSet.enums['wordLike'].countedString(enumOffset);
+
+        if (args.coerceCase === 'toLower') {
+          tokenString = tokenString.toLowerCase();
+        }
+
+        if (args.coerceCase === 'toUpper') {
+          tokenString = tokenString.toUpperCase();
+        }
+        tokens.add(tokenString);
+      }
+      n++;
+    }
+    return Array.from(tokens).sort();
+  },
+  hasChars: (root, args, context) => {
+    if (root.type !== 'main') {
+      throw new Error(`Only available for the main sequence, not ${root.type}`);
+    }
+
+    return sequenceHasChars(context.docSet, root, args.chars, args.allChars || false);
+  },
+  hasMatchingChars: (root, args, context) => {
+    if (root.type !== 'main') {
+      throw new Error(`Only available for the main sequence, not ${root.type}`);
+    }
+
+    return sequenceHasMatchingChars(context.docSet, root, args.chars, args.allChars);
+  },
+};
+
+module.exports = {
+  sequenceSchemaString,
+  sequenceResolvers,
+};

package/src/graph/queries/table_sequence.cjs

@@ -0,0 +1,192 @@
+const xre = require('xregexp');
+const utils = require('../../util/index.cjs');
+
+const tableSequenceSchemaString = `
+"""A contiguous flow of content for a table"""
+type tableSequence {
+  """The id of the sequence"""
+  id: String!
+  """The number of cells in the table sequence"""
+  nCells: Int!
+  """The number of rows in the table sequence"""
+  nRows: Int!
+  """The number of columns in the table sequence"""
+  nColumns: Int!
+  """The cells in the table sequence"""
+  cells: [cell!]!
+  """The rows in the table sequence"""
+  rows(
+    """Only return rows whose zero-indexed position is in the list"""
+    positions: [Int!]
+    """Only return columns whose zero-indexed position is in the list"""
+    columns: [Int!]
+    """Only return rows whose cells match the specification"""
+    matches: [rowMatchSpec!]
+    """'Only return rows whose cells contain one of the values in the specification"""
+    equals: [rowEqualsSpec!]
+  ): [[cell!]!]!
+  """A list of the tags of this sequence"""
+  tags: [String!]!
+  """A list of the tags of this sequence as key/value tuples"""
+  tagsKv: [KeyValue!]!
+  """Whether or not the sequence has the specified tag"""
+  hasTag(
+    """The tag name"""
+    tagName: String
+  ): Boolean!
+  """A list of column headings for this tableSequence, derived from the sequence tags"""
+  headings: [String!]!
+}
+`;
+
+const tableSequenceResolvers = {
+  nCells: root => root.blocks.length,
+  nRows: (root, args, context) => {
+    const rowNs = new Set([]);
+
+    for (const block of root.blocks) {
+      // eslint-disable-next-line no-unused-vars
+      const [itemLength, itemType, itemSubtype] = utils.succinct.headerBytes(block.bs, 0);
+      const bsPayload = context.docSet.unsuccinctifyScope(block.bs, itemType, itemSubtype, 0)[2];
+      rowNs.add(bsPayload.split('/')[1]);
+    }
+    return rowNs.size;
+  },
+  nColumns: (root, args, context) => {
+    const columnNs = new Set([]);
+
+    for (const block of root.blocks) {
+      for (const scope of context.docSet.unsuccinctifyScopes(block.is).map(s => s[2])) {
+        if (scope.startsWith('tTableCol')) {
+          columnNs.add(scope.split('/')[1]);
+        }
+      }
+    }
+    return columnNs.size;
+  },
+  cells: (root, args, context) => {
+    const ret = [];
+
+    for (const block of root.blocks) {
+      ret.push([
+        context.docSet.unsuccinctifyScopes(block.bs)
+          .map(s => parseInt(s[2].split('/')[1])),
+        Array.from(new Set(
+          context.docSet.unsuccinctifyScopes(block.is)
+            .filter(s => s[2].startsWith('tTableCol'))
+            .map(s => parseInt(s[2].split('/')[1])),
+        )),
+        context.docSet.unsuccinctifyItems(block.c, {}, 0),
+      ]);
+    }
+    return ret;
+  },
+  rows: (root, args, context) => {
+    const rowMatches1 = (row, matchSpec) => {
+      if (row[matchSpec.colN] === undefined) {
+        return false;
+      }
+
+      const matchCellText = row[matchSpec.colN][2]
+        .filter(i => i[0] === 'token')
+        .map(i => i[2])
+        .join('');
+      return xre.test(matchCellText, xre(matchSpec.matching));
+    };
+
+    const rowMatches = (row, matchSpecs) => {
+      if (matchSpecs.length === 0) {
+        return true;
+      }
+
+      if (rowMatches1(row, matchSpecs[0])) {
+        return rowMatches(row, matchSpecs.slice(1));
+      }
+      return false;
+    };
+
+    const rowEquals1 = (row, matchSpec) => {
+      if (row[matchSpec.colN] === undefined) {
+        return false;
+      }
+
+      const matchCellText = row[matchSpec.colN][2]
+        .filter(i => i[0] === 'token')
+        .map(i => i[2])
+        .join('');
+      return matchSpec.values.includes(matchCellText);
+    };
+
+    const rowEquals = (row, matchSpecs) => {
+      if (matchSpecs.length === 0) {
+        return true;
+      }
+
+      if (rowEquals1(row, matchSpecs[0])) {
+        return rowEquals(row, matchSpecs.slice(1));
+      }
+      return false;
+    };
+
+    let ret = [];
+    let row = -1;
+
+    for (const block of root.blocks) {
+      const rows = context.docSet.unsuccinctifyScopes(block.bs)
+        .map(s => parseInt(s[2].split('/')[1]));
+
+      if (args.positions && !args.positions.includes(rows[0])) {
+        continue;
+      }
+
+      if (rows[0] !== row) {
+        ret.push([]);
+        row = rows[0];
+      }
+      ret[ret.length - 1].push([
+        rows,
+        Array.from(new Set(
+          context.docSet.unsuccinctifyScopes(block.is)
+            .filter(s => s[2].startsWith('tTableCol'))
+            .map(s => parseInt(s[2].split('/')[1])),
+        )),
+        context.docSet.unsuccinctifyItems(block.c, {}, 0),
+      ]);
+    }
+
+    if (args.matches) {
+      ret = ret.filter(row => rowMatches(row, args.matches));
+    }
+
+    if (args.equals) {
+      ret = ret.filter(row => rowEquals(row, args.equals));
+    }
+
+    if (args.columns) {
+      ret = ret.map(
+        row =>
+          [...row.entries()]
+            .filter(re => args.columns.includes(re[0]))
+            .map(re => re[1]));
+    }
+    return ret;
+  },
+  tags: root => Array.from(root.tags),
+  tagsKv: root => Array.from(root.tags).map(t => {
+    if (t.includes(':')) {
+      return [t.substring(0, t.indexOf(':')), t.substring(t.indexOf(':') + 1)];
+    } else {
+      return [t, ''];
+    }
+  }),
+  hasTag: (root, args) => root.tags.has(args.tagName),
+  headings: root => Array.from(root.tags)
+    .filter(t => t.startsWith('col'))
+    .sort((a, b) => parseInt(a.split(':')[0].substring(3)) - parseInt(b.split(':')[0].substring(3)))
+    .map(t => t.split(':')[1]),
+};
+
+module.exports = {
+  tableSequenceSchemaString,
+  tableSequenceResolvers,
+};

package/src/graph/queries/tree_sequence.cjs

@@ -0,0 +1,58 @@
+const Tribos = require('../lib/tribos.cjs');
+
+const treeSequenceSchemaString = `
+"""The nodes of a tree"""
+type treeSequence {
+  """The id of the sequence"""
+  id: String!
+  """The number of nodes in the tree sequence"""
+  nNodes: Int!
+  """The nodes in the tree sequence"""
+  nodes: [node!]!
+  """The JSON result for a Tribos query, as a string"""
+  tribos(
+    """The Tribos query string"""
+    query: String!
+  ): String!
+  """The JSON results for the Tribos queries, as an array of strings"""
+  triboi(
+    """The Tribos query strings"""
+    queries: [String!]!
+  ): [String!]!
+  """Tribos documentation"""
+  tribosDoc: String!
+  """A list of the tags of this sequence"""
+  tags: [String!]!
+  """A list of the tags of this sequence as key/value tuples"""
+  tagsKv: [KeyValue!]!
+  """Whether or not the sequence has the specified tag"""
+  hasTag(
+    """The tag name"""
+    tagName: String
+  ): Boolean!
+}
+`;
+
+const treeSequenceResolvers = {
+  nNodes: root => root.blocks.length,
+  nodes: root => root.blocks,
+  tribos: (root, args, context) =>
+    new Tribos().parse(context.docSet, root.blocks, args.query),
+  triboi: (root, args, context) =>
+    args.queries.map(q => new Tribos().parse(context.docSet, root.blocks, q)),
+  tribosDoc: () => new Tribos().doc(),
+  tags: root => Array.from(root.tags),
+  tagsKv: root => Array.from(root.tags).map(t => {
+    if (t.includes(':')) {
+      return [t.substring(0, t.indexOf(':')), t.substring(t.indexOf(':') + 1)];
+    } else {
+      return [t, ''];
+    }
+  }),
+  hasTag: (root, args) => root.tags.has(args.tagName),
+};
+
+module.exports = {
+  treeSequenceSchemaString,
+  treeSequenceResolvers,
+};

package/src/graph/queries/verseNumber.cjs

@@ -0,0 +1,44 @@
+const utils = require('../../util/index.cjs');
+
+const verseNumberSchemaString = `
+"""Information about a verse number (which may be part of a verse range)"""
+type verseNumber {
+  """The verse number"""
+  number: Int!
+  """The verse range to which the verse number belongs"""
+  range: String!
+  """The reference for this verse when mapped to 'original' versification"""
+  orig: orig!
+}
+`;
+
+const verseNumberResolvers = {
+  orig: (root, args, context) => {
+    const localBook = context.doc.headers.bookCode;
+    const localChapter = context.cvIndex[0];
+    const localVerse = root.number;
+    const mainSequence = context.doc.sequences[context.doc.mainId];
+
+    if (
+      mainSequence.verseMapping &&
+      'forward' in mainSequence.verseMapping &&
+      `${localChapter}` in mainSequence.verseMapping.forward
+    ) {
+      const mapping = utils.versification.mapVerse(mainSequence.verseMapping.forward[`${localChapter}`], localBook, localChapter, localVerse);
+      return ({
+        book: mapping[0],
+        cvs: mapping[1],
+      });
+    } else {
+      return ({
+        book: localBook,
+        cvs: [[localChapter, localVerse]],
+      });
+    }
+  },
+};
+
+module.exports = {
+  verseNumberSchemaString,
+  verseNumberResolvers,
+};

package/src/graph/queries/verseRange.cjs

@@ -0,0 +1,11 @@
+const verseRangeSchemaString = `
+"""Information about a verse range (which may only cover one verse)"""
+type verseRange {
+  """The range, as it would be printed in a Bible"""
+  range: String!
+  """A list of verse numbers for this range"""
+  numbers: [Int!]!
+}
+`;
+
+module.exports = { verseRangeSchemaString };

package/src/graph/queries/versification.cjs

@@ -0,0 +1,25 @@
+const versificationSchemaString = `
+"""Information about a standard versification scheme"""
+type versification {
+  """id, derived from the Paratext vrs filename"""
+  id: String!
+  """A string of the original vrs file"""
+  vrs: String!
+  """Chapter/verse information for each book"""
+  cvBooks: [cvBook!]!
+  """Chapter/verse information for one book"""
+  cvBook(
+    """The bookCode"""
+    bookCode: String!
+  ): cvBook!
+}
+`;
+
+const versificationResolvers = {
+  id: root => root[0],
+  vrs: root => root[1].raw,
+  cvBooks: root => Object.entries(root[1].cv),
+  cvBook: (root, args) => Object.entries(root[1].cv).filter(b => b[0] === args.bookCode)[0],
+};
+
+module.exports = { versificationSchemaString, versificationResolvers };