proskomma-core 0.9.10 → 0.9.13

package/src/graph/queries/cIndex.cjs

@@ -0,0 +1,87 @@
+const { dumpItems } = require('../lib/dump.cjs');
+
+const cIndexSchemaString = `
+"""A chapter index entry"""
+type cIndex {
+  """The chapter number"""
+  chapter: Int!
+  """The zero-indexed number of the block where the chapter starts"""
+  startBlock: Int
+  """The zero-indexed number of the block where the chapter ends"""
+  endBlock: Int
+  """The zero-indexed position of the item where the chapter starts"""
+  startItem: Int
+  """The zero-indexed position of the item where the chapter ends"""
+  endItem: Int
+  """The value of nextToken at the beginning of the chapter"""
+  nextToken: Int
+  """A list of items for this chapter"""
+  items(
+    """If true, adds scope and nextToken information to each token"""
+    includeContext: Boolean
+  ): [Item]!
+  """The items as a string in a compact eyeballable format"""
+  dumpItems: String
+  """A list of tokens for this chapter"""
+  tokens(
+    """If true, adds scope and nextToken information to each token"""
+    includeContext: Boolean
+    """Return tokens whose payload is an exact match to one of the specified strings"""
+    withChars: [String!]
+    """Return tokens with one of the specified subTypes"""
+    withSubTypes: [String!]
+  ): [Item]!
+  """The text of the chapter as a single string"""
+  text(
+    """If true, converts each whitespace character to a single space"""
+    normalizeSpace: Boolean
+  ): String!
+}
+`;
+
+const cIndexResolvers = {
+  chapter: root => root[0],
+  startBlock: root => root[1].startBlock,
+  endBlock: root => root[1].endBlock,
+  startItem: root => root[1].startItem,
+  endItem: root => root[1].endItem,
+  nextToken: root => root[1].nextToken,
+  items: (root, args, context) =>
+    context.docSet.itemsByIndex(context.doc.sequences[context.doc.mainId], root[1], args.includeContext)
+      .reduce((a, b) => a.concat([['token', 'lineSpace', ' ']].concat(b)), []),
+  dumpItems: (root, args, context) => {
+    const items = context.docSet.itemsByIndex(context.doc.sequences[context.doc.mainId], root[1], false);
+
+    if (items.length > 0) {
+      return dumpItems(items.reduce((a, b) => a.concat([['token', 'lineSpace', ' ', null]].concat(b))));
+    } else {
+      return '';
+    }
+  },
+  tokens: (root, args, context) =>
+    context.docSet.itemsByIndex(context.doc.sequences[context.doc.mainId], root[1], args.includeContext)
+      .reduce((a, b) => a.concat([['token', 'lineSpace', ' ']].concat(b)), [])
+      .filter(
+        i => i[0] === 'token' &&
+          (!args.withChars || args.withChars.includes(i[2])) &&
+          (!args.withSubTypes || args.withSubTypes.includes(i[1])),
+      ),
+  text: (root, args, context) => {
+    let ret = context.docSet.itemsByIndex(context.doc.sequences[context.doc.mainId], root[1])
+      .reduce((a, b) => a.concat([['token', 'lineSpace', ' ']].concat(b)), [])
+      .filter(i => i[0] === 'token')
+      .map(t => t[1] === 'lineSpace' ? ' ' : t[2])
+      .join('')
+      .trim();
+
+    if (args.normalizeSpace) {
+      ret = ret.replace(/[ \t\n\r]+/g, ' ');
+    }
+    return ret;
+  },
+};
+
+module.exports = {
+  cIndexSchemaString,
+  cIndexResolvers,
+};

package/src/graph/queries/cell.cjs

@@ -0,0 +1,42 @@
+const cellSchemaString = `
+"""A table cell"""
+type cell {
+  """The row numbers"""
+  rows: [Int!]!
+  """The column numbers"""
+  columns: [Int!]!
+  """A list of items from the c (content) field of the cell"""
+  items: [Item!]!
+  """A list of tokens from the c (content) field of the cell"""
+  tokens: [Item!]!
+  """The text of the cell as a single string"""
+  text(
+    """If true, converts each whitespace character to a single space"""
+    normalizeSpace: Boolean
+  ): String!
+}
+`;
+
+const cellResolvers = {
+  rows: root => root[0],
+  columns: root => root[1],
+  items: root => root[2],
+  tokens: root => root[2].filter(i => i[0] === 'token'),
+  text: (root, args) => {
+    let ret = root[2]
+      .filter(i => i[0] === 'token')
+      .map(t => t[2])
+      .join('')
+      .trim();
+
+    if (args.normalizeSpace) {
+      ret = ret.replace(/[ \t\n\r]+/g, ' ');
+    }
+    return ret;
+  },
+};
+
+module.exports = {
+  cellSchemaString,
+  cellResolvers,
+};

package/src/graph/queries/cv.cjs

@@ -0,0 +1,19 @@
+const cvSchemaString = `
+"""A chapter-verse reference"""
+type cv {
+  """The chapter number"""
+  chapter: Int
+  """The verse number"""
+  verse: Int
+}
+`;
+
+const cvResolvers = {
+  chapter: root => root[0],
+  verse: root => root[1],
+};
+
+module.exports = {
+  cvSchemaString,
+  cvResolvers,
+};

package/src/graph/queries/cvBook.cjs

@@ -0,0 +1,16 @@
+const cvBookSchemaString = `
+"""Chapter/verse information for a book"""
+type cvBook {
+  """The bookCode"""
+  bookCode: String!
+  """The chapter records"""
+  chapters: [cvChapter!]!
+}
+`;
+
+const cvBookResolvers = {
+  bookCode: root => root[0],
+  chapters: root => Object.entries(root[1]),
+}
+
+module.exports = { cvBookSchemaString, cvBookResolvers };

package/src/graph/queries/cvChapter.cjs

@@ -0,0 +1,16 @@
+const cvChapterSchemaString = `
+"""Information for a chapter"""
+type cvChapter {
+  """The chapter"""
+  chapter: Int!
+  """The maximum verse number"""
+  maxVerse: Int!
+}
+`;
+
+const cvChapterResolvers = {
+  chapter: root => parseInt(root[0]),
+  maxVerse: root => parseInt(root[1]),
+};
+
+module.exports = { cvChapterSchemaString, cvChapterResolvers };

package/src/graph/queries/cvIndex.cjs

@@ -0,0 +1,47 @@
+const cvIndexSchemaString = `
+"""A chapterVerse index entry"""
+type cvIndex {
+  """The chapter number"""
+  chapter: Int!
+  """Information about the verses in the chapter"""
+  verses: [cvVerses]
+  """A list of verse number and range information, organized by verse number"""
+  verseNumbers: [verseNumber!]
+  """A list of verse number and range information, organized by verse range"""
+  verseRanges: [verseRange!]
+}
+`;
+
+const cvIndexResolvers = {
+  chapter: root => root[0],
+  verses: root => root[1],
+  verseNumbers: (root, args, context) => {
+    context.cvIndex = root;
+    return [...root[1].entries()]
+      .filter(v => v[1].length > 0)
+      .map(v => ({
+        number: v[0],
+        range: v[1][v[1].length - 1].verses,
+      }));
+  },
+  verseRanges: root => {
+    const ret = [];
+
+    for (const [vn, vo] of [...root[1].entries()].filter(v => v[1].length > 0)) {
+      if (ret.length === 0 || ret[ret.length - 1].range !== vo[vo.length - 1].verses) {
+        ret.push({
+          range: vo[vo.length - 1].verses,
+          numbers: [vn],
+        });
+      } else {
+        ret[ret.length - 1].numbers.push(vn);
+      }
+    }
+    return ret;
+  },
+};
+
+module.exports = {
+  cvIndexSchemaString,
+  cvIndexResolvers,
+};

package/src/graph/queries/cvNavigation.cjs

@@ -0,0 +1,116 @@
+const nv = (root, newVerseRange) => {
+  const chapterN = parseInt(root[0]);
+  const verseN = parseInt(root[1]);
+
+  if (root[3].length <= verseN || root[3][verseN].length === 0) {
+    return null;
+  }
+
+  let ret = null;
+  let nc = chapterN;
+  let nv = verseN;
+  let index = root[3];
+  let startVerseRange = index[verseN][0].verses;
+  let onNextChapter = false;
+
+  while (!ret) {
+    nv += 1;
+
+    if (nv >= index.length) {
+      if (onNextChapter || !root[4]) {
+        break;
+      }
+      nv = -1;
+      nc += 1;
+      index = root[4];
+      onNextChapter = true;
+    } else if (
+      index[nv].length > 0 &&
+      (!newVerseRange || onNextChapter || index[nv][0].verses !== startVerseRange)
+    ) {
+      ret = [nc, nv];
+    }
+  }
+  return ret;
+};
+
+const pv = (root, newVerseRange) => {
+  const chapterN = parseInt(root[0]);
+  const verseN = parseInt(root[1]);
+
+  if (root[3].length <= verseN || root[3][verseN].length === 0) {
+    return null;
+  }
+
+  let ret = null;
+  let nc = chapterN;
+  let nv = verseN;
+  let index = root[3];
+  let startVerseRange = index[verseN][0].verses;
+  let onPreviousChapter = false;
+
+  while (!ret) {
+    nv -= 1;
+
+    if (nv < 0) {
+      if (onPreviousChapter || !root[2]) {
+        break;
+      }
+      nv = root[2].length;
+      nc -= 1;
+      index = root[2];
+      onPreviousChapter = true;
+    } else if (
+      index[nv].length > 0 &&
+      (!newVerseRange || onPreviousChapter || index[nv][0].verses !== startVerseRange)
+    ) {
+      ret = [nc, nv];
+    }
+  }
+  return ret;
+};
+
+const cvNavigationSchemaString = `
+"""Various answers to 'previous' and 'next' with respect to a verse"""
+type cvNavigation {
+  """The verse number for the next verse"""
+  nextVerse: cv
+  """The verse number for the previous verse"""
+  previousVerse: cv
+  """The verse number for the next verse range"""
+  nextVerseRangeVerse: cv
+  """The verse number for the previous verse range"""
+  previousVerseRangeVerse: cv
+  """The next chapter number (as a string)"""
+  nextChapter: String
+  """The previous chapter number (as a string)"""
+  previousChapter: String
+}
+`;
+
+// root is [ < 0 chapter >, < 1 verse >, < 2 previousChapterIndex >, < 3 thisChapterIndex >, < 4 nextChapterIndex > ]
+const cvNavigationResolvers = {
+  nextVerse: root => nv(root, false),
+  previousVerse: root => pv(root, false),
+  nextVerseRangeVerse: root => nv(root, true),
+  previousVerseRangeVerse: root => pv(root, true),
+  nextChapter: root => {
+    if (root[3].length > 0 && root[4].length > 0) {
+      return (parseInt(root[0]) + 1).toString();
+    } else {
+      return null;
+    }
+  },
+  previousChapter: root => {
+    if (root[2].length > 0 && root[3].length > 0) {
+      return (parseInt(root[0]) - 1).toString();
+    } else {
+      return null;
+    }
+  },
+};
+
+module.exports = {
+  cvNavigationSchemaString,
+  cvNavigationResolvers,
+};

package/src/graph/queries/cvVerseElement.cjs

@@ -0,0 +1,84 @@
+const { dumpItems } = require('../lib/dump.cjs');
+
+const cvVerseElementSchemaString = `
+""""""
+type cvVerseElement {
+  """The zero-indexed number of the block where the verse starts"""
+  startBlock: Int
+  """The zero-indexed number of the block where the verse ends"""
+  endBlock: Int
+  """The zero-indexed position of the item where the verse starts"""
+  startItem: Int
+  """The zero-indexed position of the item where the verse ends"""
+  endItem: Int
+  """The value of nextToken at the beginning of the verse"""
+  nextToken: Int
+  """The verse range for this verse as it would be printed in a Bible"""
+  verseRange: String
+  """A list of items for this verse"""
+  items(
+    """If true, adds scope and nextToken information to each token"""
+    includeContext: Boolean
+  ): [Item]!
+  """The items as a string in a compact eyeballable format"""
+  dumpItems: String
+  """A list of tokens for this verse"""
+  tokens(
+    """If true, adds scope and nextToken information to each token"""
+    includeContext: Boolean
+    """Return tokens whose payload is an exact match to one of the specified strings"""
+    withChars: [String!]
+    """Return tokens with one of the specified subTypes"""
+    withSubTypes: [String!]
+  ): [Item]!
+  """The text of the verse as a single string"""
+  text(
+    """If true, converts each whitespace character to a single space"""
+    normalizeSpace: Boolean
+  ): String!
+}
+`;
+
+const cvVerseElementResolvers = {
+  startBlock: root => root.startBlock,
+  endBlock: root => root.endBlock,
+  startItem: root => root.startItem,
+  endItem: root => root.endItem,
+  nextToken: root => root.nextToken,
+  verseRange: root => root.verses,
+  items: (root, args, context) =>
+    context.docSet.itemsByIndex(context.doc.sequences[context.doc.mainId], root, args.includeContext)
+      .reduce((a, b) => a.concat([['token', 'lineSpace', ' ', null]].concat(b))),
+  dumpItems: (root, args, context) =>
+    dumpItems(
+      context.docSet.itemsByIndex(context.doc.sequences[context.doc.mainId], root, args.includeContext)
+        .reduce((a, b) => a.concat([['token', 'lineSpace', ' ', null]].concat(b))),
+    ),
+  tokens: (root, args, context) =>
+    context.docSet.itemsByIndex(context.doc.sequences[context.doc.mainId], root, args.includeContext)
+      .reduce((a, b) => a.concat([['token', 'lineSpace', ' ', null]].concat(b)))
+      .filter(
+        i =>
+          i[0] === 'token' &&
+          (!args.withChars || args.withChars.includes(i[2])) &&
+          (!args.withSubTypes || args.withSubTypes.includes(i[1])),
+      ),
+  text: (root, args, context) => {
+    let ret = context.docSet.itemsByIndex(context.doc.sequences[context.doc.mainId], root)
+      .reduce((a, b) => a.concat([['token', 'lineSpace', ' ', null]].concat(b)))
+      .filter(i => i[0] === 'token')
+      .map(t => t[1] === 'lineSpace' ? ' ' : t[2])
+      .join('')
+      .trim();
+
+    if (args.normalizeSpace) {
+      ret = ret.replace(/[ \t\n\r]+/g, ' ');
+    }
+    return ret;
+  },
+};
+
+module.exports = {
+  cvVerseElementSchemaString,
+  cvVerseElementResolvers,
+};

package/src/graph/queries/cvVerses.cjs

@@ -0,0 +1,14 @@
+const cvVersesSchemaString = `
+"""Information about a verse in the chapter, which may be split into several pieces"""
+type cvVerses {
+  """The pieces of verse"""
+  verse: [cvVerseElement]
+}
+`;
+
+const cvVersesResolvers = { verse: root => root };
+
+module.exports = {
+  cvVersesSchemaString,
+  cvVersesResolvers,
+};

package/src/graph/queries/doc_set.cjs

@@ -0,0 +1,220 @@
+const utils = require('../../util/index.cjs');
+
+const { bookCodeCompareFunctions } = require('../lib/sort.cjs');
+
+const {
+  sequenceHasChars,
+  sequenceHasMatchingChars,
+} = require('../lib/sequence_chars.cjs');
+
+const docSetSchemaString = `
+"""A collection of documents that share the same set of selector values"""
+type DocSet {
+  """The id of the docSet, which is formed by concatenating the docSet's selector values"""
+  id: String!
+  """The selectors of the docSet"""
+  selectors: [KeyValue!]!
+  """A selector for this docSet"""
+  selector(
+    """The id of the selector"""
+    id: String!
+  ): String!
+  """A list of the tags of this docSet"""
+  tags: [String!]!
+  """A list of the tags of this docSet as key/value tuples"""
+  tagsKv: [KeyValue!]!
+  """Whether or not the docSet has the specified tag"""
+  hasTag(
+    """The tag"""
+    tagName: String!
+  ): Boolean!
+  """The documents in the docSet"""
+  documents(
+    """A whitelist of ids of documents to include"""
+    ids: [String!]
+    """A whitelist of ids of documents to include"""
+    withChars: [String!]
+    """Return documents whose main sequence contains a token whose payload is an exact match to one of the specified strings"""
+    withMatchingChars: [String!]
+    """If true, documents where all search terms match will be included"""
+    allChars: Boolean
+    """Only return documents where the list of scopes is used"""
+    withScopes: [String!]
+    """If true, documents where all scopes are found will be included"""
+    allScopes: Boolean
+    """Only return documents with the specified header key/values"""
+    withHeaderValues: [InputKeyValue!]
+    """Only return documents with all the specified tags"""
+    withTags: [String!]
+    """Only return documents with none of the specified tags"""
+    withoutTags: [String!]
+    """Sort returned documents by the designated method (currently ${Object.keys(bookCodeCompareFunctions).join(', ')})\`"""
+    sortedBy: String
+  ): [Document!]!
+  """The number of documents in the docSet"""
+  nDocuments: Int!
+  """A document in the docSet, if present"""
+  document(
+    """The book code of the required document"""
+    bookCode: String!
+  ): Document
+  """Whether the docSet has versification information loaded"""
+  hasMapping: Boolean!
+  """The internal index number corresponding to a string in a given docSet enum"""
+  enumIndexForString(
+    """The enum to be searched"""
+    enumType: String!
+    """The string to match"""
+    searchString: String!
+  ): Int!
+  """Information about internal indexes matching the case-insensitive regex in a given docSet enum"""
+  enumRegexIndexesForString(
+    """The enum to be searched"""
+    enumType: String!
+    """The regex to match"""
+    searchRegex: String!
+  ): [regexIndex!]!
+  """A list of wordLike token strings in the docSet"""
+  wordLikes(
+    """Whether to coerce the strings (toLower|toUpper|none)"""
+    coerceCase: String
+  ): [String!]!
+  """A list of unique characters in the docSet"""
+  uniqueChars: [String!]!
+  """A string containing the unique characters in the docSet"""
+  uniqueCharsString: String!
+  }
+`;
+
+const docSetResolvers = {
+  selectors: (root) => Object.entries(root.selectors),
+  selector: (root, args) => root.selectors[args.id],
+  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),
+  documents: (root, args, context) => {
+    const headerValuesMatch = (docHeaders, requiredHeaders) => {
+      for (const requiredHeader of requiredHeaders || []) {
+        if (!(requiredHeader.key in docHeaders) || docHeaders[requiredHeader.key] !== requiredHeader.value) {
+          return false;
+        }
+      }
+      return true;
+    };
+
+    if (args.withChars && args.withMatchingChars) {
+      throw new Error('Cannot specify both withChars and withMatchingChars');
+    }
+
+    context.docSet = root;
+    let ret = root.documents();
+
+    if (args.ids) {
+      ret = ret.filter(d => args.ids.includes(d.id));
+    }
+
+    if (args.withChars) {
+      ret = ret.filter(d => sequenceHasChars(root, d.sequences[d.mainId], args.withChars, args.allChars));
+    }
+
+    if (args.withMatchingChars) {
+      ret = ret.filter(d => sequenceHasMatchingChars(root, d.sequences[d.mainId], args.withMatchingChars, args.allChars));
+    }
+
+    if (args.withScopes) {
+      const allSequenceScopes = doc => new Set(
+        doc.sequences[doc.mainId].blocks
+          .map(b => context.docSet.unsuccinctifyBlockScopeLabelsSet(b))
+          .map(s => Array.from(s))
+          .reduce((a, b) => a.concat(b)),
+      );
+
+      ret = ret.filter(
+        d => {
+          const docScopes = allSequenceScopes(d);
+          const minHits = args.allScopes ? args.withScopes.length : 1;
+          return args.withScopes.filter(s => docScopes.has(s)).length >= minHits;
+        },
+      );
+    }
+
+    if (args.withHeaderValues) {
+      ret = ret.filter(d => headerValuesMatch(d.headers, args.withHeaderValues));
+    }
+
+    if (args.withTags) {
+      ret = ret.filter(d => args.withTags.filter(t => d.tags.has(t)).length === args.withTags.length);
+    }
+
+    if (args.withoutTags) {
+      ret = ret.filter(d => args.withoutTags.filter(t => d.tags.has(t)).length === 0);
+    }
+
+    if (args.sortedBy) {
+      if (!(args.sortedBy in bookCodeCompareFunctions)) {
+        throw new Error(`sortedBy value must be one of [${Object.keys(bookCodeCompareFunctions)}], not ${args.sortedBy}`);
+      }
+      ret.sort(bookCodeCompareFunctions[args.sortedBy]);
+    }
+
+    return ret;
+  },
+  nDocuments: (root, args, context) => {
+    context.docSet = root;
+    return root.documents().length;
+  },
+  document: (root, args) => root.documentWithBook(args.bookCode),
+  hasMapping: root => root.tags.has('hasMapping'),
+  enumIndexForString: (root, args) =>
+    utils.enums.enumStringIndex(root.enums[args.enumType], args.searchString),
+  enumRegexIndexesForString: (root, args) =>
+    utils.enums.enumRegexIndexTuples(root.enums[args.enumType], args.searchRegex),
+  wordLikes: (root, args) => {
+    if (args.coerceCase && !['toLower', 'toUpper', 'none'].includes(args.coerceCase)) {
+      throw new Error(`coerceCase, when present, must be 'toLower', 'toUpper' or 'none', not '${args.coerceCase}'`);
+    }
+
+    let tokens = utils.succinct.unpackEnum(root.enums.wordLike);
+
+    if (args.coerceCase === 'toLower') {
+      tokens = tokens.map(t => t.toLowerCase());
+    }
+
+    if (args.coerceCase === 'toUpper') {
+      tokens = tokens.map(t => t.toUpperCase());
+    }
+    return Array.from(new Set(tokens));
+  },
+  uniqueChars: root => {
+    const retSet = new Set([]);
+
+    for (const token of [...utils.succinct.unpackEnum(root.enums.wordLike), ...utils.succinct.unpackEnum(root.enums.notWordLike)]) {
+      for (const char of token.split('')) {
+        retSet.add(char);
+      }
+    }
+    return Array.from(retSet).sort();
+  },
+  uniqueCharsString: root => {
+    const retSet = new Set([]);
+
+    for (const token of [...utils.succinct.unpackEnum(root.enums.wordLike), ...utils.succinct.unpackEnum(root.enums.notWordLike)]) {
+      for (const char of token.split('')) {
+        retSet.add(char);
+      }
+    }
+    return Array.from(retSet).sort().join('');
+  },
+};
+
+module.exports = {
+  docSetSchemaString,
+  docSetResolvers,
+};
+