proskomma-core 0.9.18 → 0.9.19

package/dist/index.js.LICENSE.txt

@@ -1,23 +0,0 @@
-/*!
- * XRegExp 5.1.1
- * <xregexp.com>
- * Steven Levithan (c) 2007-present MIT License
- */
-
-/*!
- * checksum
- * Copyright(c) 2013 Daniel D. Shaw <dshaw@dshaw.com>
- * MIT Licensed
- */
-
-/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
-
-/**
- * @license BitSet.js v5.1.1 2/1/2020
- * http://www.xarg.org/2014/03/javascript-bit-array/
- *
- * Copyright (c) 2020, Robert Eisele (robert@xarg.org)
- * Dual licensed under the MIT or GPL Version 2 licenses.
- **/
-
-/** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */

package/esm/package.json

@@ -1,3 +0,0 @@
-{
-    "type": "module"
-}

package/esm/wrapper.mjs

@@ -1,7 +0,0 @@
-import {
-  Proskomma, lexingRegexes, blocksSpecUtils, resolvers, typeDefs,
-} from '../index.cjs';
-
-export {
-  Proskomma, lexingRegexes, blocksSpecUtils, resolvers, typeDefs,
-};

package/informations/meeting_01_march_2023.md

@@ -1,38 +0,0 @@
-#
-
-## Participants
-
-- Birch
-- Incy
-- Mark Howe
-- Nicolas Condomitti
-
-## Discussions
-
-Birch's suggestions :
-* handle usfm 3 format from unfoldingWord
-* accept that there **will** be multiple format : so the API must handle that
-* uW format IN and uW format OUT
-* let's go quickly to the **first** solution
-* contact Chris and Bruce. They produced a UI.
-
-Mark's suggestions :
-
-
-Bincy's suggestions :
-* an english team are working on aligning the old testament. It would be IMMENSLY helpful to have a working tool to correct broken alignment
-
-
-## My conclusion
-
-Let's go to the first "simple" solution :
-* make a card in https://gateway-translate.netlify.app/
-* to correct the broken alignment on the go when you correct a text
-* **it HAS TO LIKE EXACTLY LIKE TRANSLATION-CORE**
-
-
-## TODO
-
-- [ ] mini editeur : TCore-like
-- [ ] travailler sur côté Epitelete pour communiquer les modifications à Proskomma
-- [ ] essayer de mettre ça en "Card" pour gateway-translate

package/src/graph/index.cjs

@@ -1,201 +0,0 @@
-const {
-  keyValueSchemaString,
-  keyValueResolvers,
-} = require('./queries/key_value.cjs');
-const {
-  cvSchemaString,
-  cvResolvers,
-} = require('./queries/cv.cjs');
-const {
-  idPartsSchemaString,
-  idPartsResolvers,
-} = require('./queries/idParts.cjs');
-const { inputAttSpecSchemaString } = require('./queries/input_att_spec.cjs');
-const { keyMatchesSchemaString } = require('./queries/input_key_matches.cjs');
-const { inputKeyValueSchemaString } = require('./queries/input_key_value.cjs');
-const { keyValuesSchemaString } = require('./queries/input_key_values.cjs');
-const { inputItemObjectSchemaString } = require('./queries/inputItemObject.cjs');
-const {
-  itemSchemaString,
-  itemResolvers,
-} = require('./queries/item.cjs');
-const {
-  itemGroupSchemaString,
-  itemGroupResolvers,
-} = require('./queries/itemGroup.cjs');
-const {
-  kvEntrySchemaString,
-  kvEntryResolvers,
-} = require('./queries/kv_entry.cjs');
-const {
-  regexIndexSchemaString,
-  regexIndexResolvers,
-} = require('./queries/regex_index.cjs');
-const { rowEqualsSpecSchemaString } = require('./queries/row_equals_spec.cjs');
-const { rowMatchSpecSchemaString } = require('./queries/row_match_spec.cjs');
-const { verseRangeSchemaString } = require('./queries/verseRange.cjs');
-const { origSchemaString } = require('./queries/orig.cjs');
-const {
-  verseNumberSchemaString,
-  verseNumberResolvers,
-} = require('./queries/verseNumber.cjs');
-const {
-  cellSchemaString,
-  cellResolvers,
-} = require('./queries/cell.cjs');
-const {
-  cIndexSchemaString,
-  cIndexResolvers,
-} = require('./queries/cIndex.cjs');
-const {
-  cvVerseElementSchemaString,
-  cvVerseElementResolvers,
-} = require('./queries/cvVerseElement.cjs');
-const {
-  cvVersesSchemaString,
-  cvVersesResolvers,
-} = require('./queries/cvVerses.cjs');
-const {
-  cvIndexSchemaString,
-  cvIndexResolvers,
-} = require('./queries/cvIndex.cjs');
-const {
-  cvNavigationSchemaString,
-  cvNavigationResolvers,
-} = require('./queries/cvNavigation.cjs');
-const { inputBlockSpecSchemaString } = require('./queries/inputBlockSpec.cjs');
-const {
-  nodeSchemaString,
-  nodeResolvers,
-} = require('./queries/node.cjs');
-const {
-  kvSequenceSchemaString,
-  kvSequenceResolvers,
-} = require('./queries/kv_sequence.cjs');
-const {
-  tableSequenceSchemaString,
-  tableSequenceResolvers,
-} = require('./queries/table_sequence.cjs');
-const {
-  treeSequenceSchemaString,
-  treeSequenceResolvers,
-} = require('./queries/tree_sequence.cjs');
-const {
-  blockSchemaString,
-  blockResolvers,
-} = require('./queries/block.cjs');
-const {
-  sequenceSchemaString,
-  sequenceResolvers,
-} = require('./queries/sequence.cjs');
-const {
-  documentSchemaString,
-  documentResolvers,
-} = require('./queries/document.cjs');
-const {
-  docSetSchemaString,
-  docSetResolvers,
-} = require('./queries/doc_set.cjs');
-const {
-  querySchemaString,
-  queryResolvers,
-} = require('./queries/index.cjs');
-const {
-  selectorSpecSchemaString,
-  selectorSpecResolvers,
-} = require('./queries/selector_spec.cjs');
-const { inputSelectorSpecSchemaString } = require('./queries/input_selector_spec.cjs');
-const {
-  mutationsSchemaString,
-  mutationsResolvers,
-} = require('./mutations/index.cjs');
-const {
-  versificationSchemaString,
-  versificationResolvers,
-} = require('./queries/versification.cjs');
-const {
-  cvBookSchemaString,
-  cvBookResolvers,
-} = require('./queries/cvBook.cjs');
-const {
-  cvChapterSchemaString,
-  cvChapterResolvers,
-} = require('./queries/cvChapter.cjs');
-
-const typeDefs = `
-      ${querySchemaString}
-      ${mutationsSchemaString}
-      ${keyValueSchemaString}
-      ${cvSchemaString}
-      ${idPartsSchemaString}
-      ${inputAttSpecSchemaString}
-      ${keyMatchesSchemaString}
-      ${inputKeyValueSchemaString}
-      ${keyValuesSchemaString}
-      ${inputItemObjectSchemaString}
-      ${itemSchemaString}
-      ${itemGroupSchemaString}
-      ${kvEntrySchemaString}
-      ${regexIndexSchemaString}
-      ${rowEqualsSpecSchemaString}
-      ${rowMatchSpecSchemaString}
-      ${verseRangeSchemaString}
-      ${origSchemaString}
-      ${verseNumberSchemaString}
-      ${cellSchemaString}
-      ${cIndexSchemaString}
-      ${cvVerseElementSchemaString}
-      ${cvVersesSchemaString}
-      ${cvIndexSchemaString}
-      ${cvNavigationSchemaString}
-      ${inputBlockSpecSchemaString}
-      ${nodeSchemaString}
-      ${kvSequenceSchemaString}
-      ${tableSequenceSchemaString}
-      ${treeSequenceSchemaString}
-      ${blockSchemaString}
-      ${sequenceSchemaString}
-      ${documentSchemaString}
-      ${docSetSchemaString}
-      ${selectorSpecSchemaString}
-      ${inputSelectorSpecSchemaString}
-      ${versificationSchemaString}
-      ${cvBookSchemaString}
-      ${cvChapterSchemaString}
-  `;
-
-const resolvers = {
-  Mutation: mutationsResolvers,
-  Query: queryResolvers,
-  KeyValue: keyValueResolvers,
-  cv: cvResolvers,
-  idParts: idPartsResolvers,
-  Item: itemResolvers,
-  ItemGroup: itemGroupResolvers,
-  kvEntry: kvEntryResolvers,
-  regexIndex: regexIndexResolvers,
-  verseNumber: verseNumberResolvers,
-  cell: cellResolvers,
-  cIndex: cIndexResolvers,
-  cvVerseElement: cvVerseElementResolvers,
-  cvVerses: cvVersesResolvers,
-  cvIndex: cvIndexResolvers,
-  cvNavigation: cvNavigationResolvers,
-  node: nodeResolvers,
-  kvSequence: kvSequenceResolvers,
-  tableSequence: tableSequenceResolvers,
-  treeSequence: treeSequenceResolvers,
-  Block: blockResolvers,
-  Sequence: sequenceResolvers,
-  Document: documentResolvers,
-  DocSet: docSetResolvers,
-  selectorSpec: selectorSpecResolvers,
-  versification: versificationResolvers,
-  cvBook: cvBookResolvers,
-  cvChapter: cvChapterResolvers,
-};
-
-module.exports = {
-  typeDefs,
-  resolvers,
-};

package/src/graph/lib/do_cv.cjs

@@ -1,249 +0,0 @@
-const xre = require('xregexp');
-const utils = require('../../util/index.cjs');
-
-const updatedOpenScopes = (openScopes, items) => {
-  let ret = openScopes;
-
-  for (const item of items) {
-    if (item[0] === 'scope') {
-      if (item[1] === 'start') {
-        const existingScopes = ret.filter(s => s === item[2]);
-
-        if (existingScopes.length === 0) {
-          ret.push(item[2]);
-        }
-      } else {
-        ret = ret.filter(s => s !== item[2]);
-      }
-    }
-  }
-  return ret;
-};
-
-const do_chapter_cv = (root, context, mainSequence, chapterN, includeContext) => {
-  const ci = root.chapterIndex(chapterN);
-
-  if (ci) {
-    const block = mainSequence.blocks[ci.startBlock];
-    return [[
-      updatedOpenScopes(
-        context.docSet.unsuccinctifyScopes(block.os).map(s => s[2]),
-        context.docSet.unsuccinctifyItems(block.c, {}, 0, [])
-          .slice(0, ci.startItem + 1)
-          .filter(i => i[0] === 'scope'),
-      ),
-      context.docSet.itemsByIndex(mainSequence, ci, includeContext || false)
-        .reduce((a, b) => a.concat([['token', 'lineSpace', ' ']].concat(b))),
-    ]];
-  } else {
-    return [];
-  }
-};
-
-const do_chapter_verse_array = (root, context, mainSequence, chapterN, verses, includeContext, doMap, mappedDocSetId) => {
-  let docSet = context.docSet;
-  let book = root.headers.bookCode;
-  let chapterVerses = verses.map(v => [parseInt(chapterN), parseInt(v)]);
-
-  if (doMap) {
-    const mappedDocSet = root.processor.docSets[mappedDocSetId];
-
-    if (mappedDocSet) {
-      docSet = mappedDocSet;
-    }
-
-    if ('forward' in mainSequence.verseMapping && chapterN in mainSequence.verseMapping.forward) {
-      let mappings = [];
-
-      for (const verse of verses) { // May handle multiple verses one day, but, eg, may map to multiple books
-        mappings.push(
-          utils.versification.mapVerse(
-            mainSequence.verseMapping.forward[chapterN],
-            root.headers.bookCode,
-            chapterN,
-            verse,
-          ),
-        );
-      }
-
-      const mapping = mappings[0];
-      book = mapping[0];
-      chapterVerses = mapping[1];
-    }
-
-    const mappedDocument = docSet.documentWithBook(book);
-
-    if (mappedDocument) {
-      const mappedMainSequence = mappedDocument.sequences[mappedDocument.mainId];
-
-      if (mappedMainSequence.verseMapping && 'reversed' in mappedMainSequence.verseMapping) {
-        const doubleMappings = [];
-
-        for (const [origC, origV] of chapterVerses) {
-          if (`${origC}` in mappedMainSequence.verseMapping.reversed) {
-            doubleMappings.push(
-              utils.versification.mapVerse(
-                mappedMainSequence.verseMapping.reversed[`${origC}`],
-                book,
-                origC,
-                origV,
-              ),
-            );
-          } else {
-            doubleMappings.push([book, [[origC, origV]]]);
-          }
-          book = doubleMappings[0][0];
-          chapterVerses = doubleMappings.map(bcv => bcv[1]).reduce((a, b) => a.concat(b));
-        }
-      }
-    }
-  }
-
-  const cvis = {};
-
-  const document = docSet.documentWithBook(book);
-
-  if (!document) {
-    return [];
-  }
-
-  const documentMainSequence = document.sequences[document.mainId];
-
-  for (const chapter of chapterVerses.map(cv => cv[0])) {
-    if (!(chapter in cvis)) {
-      cvis[chapter] = document.chapterVerseIndex(chapter);
-    }
-  }
-
-  const retItemGroups = [];
-
-  for (const [chapter, verse] of chapterVerses) {
-    if (cvis[chapter]) {
-      let retItems = [];
-      let firstStartBlock;
-      let firstStartItem;
-
-      if (cvis[chapter][verse]) {
-        for (const ve of cvis[chapter][verse]) {
-          if (!firstStartBlock) {
-            firstStartBlock = ve.startBlock;
-            firstStartItem = ve.startItem;
-          }
-          retItems = retItems.concat(docSet.itemsByIndex(documentMainSequence, ve, includeContext || null)
-            .reduce((a, b) => a.concat([['token', 'lineSpace', ' ']].concat(b))));
-        }
-
-        const block = documentMainSequence.blocks[firstStartBlock];
-
-        retItemGroups.push([
-          updatedOpenScopes(
-            docSet.unsuccinctifyScopes(block.os).map(s => s[2]),
-            docSet.unsuccinctifyItems(block.c, {}, 0, [])
-              .slice(0, firstStartItem + 1)
-              .filter(i => i[0] === 'scope'),
-          ),
-          retItems,
-        ]);
-      }
-    }
-  }
-  return retItemGroups;
-};
-
-const scopesMatchAChapterSpec = (scopes, chapterSpecs) => {
-  if (chapterSpecs.length === 0) {
-    return false;
-  } else if (
-    scopes.includes(`chapter/${chapterSpecs[0][0]}`) &&
-    (!chapterSpecs[0][1] || scopes.filter(s => s.startsWith('verse/') && parseInt(s.split('/')[1]) >= chapterSpecs[0][1]).length > 0) &&
-    (!chapterSpecs[0][2] || scopes.filter(s => s.startsWith('verse/') && parseInt(s.split('/')[1]) <= chapterSpecs[0][2]).length > 0)
-  ) {
-    return true;
-  } else {
-    return scopesMatchAChapterSpec(scopes, chapterSpecs.slice(1));
-  }
-};
-
-const do_chapterVerses = (root, context, mainSequence, fromCV, toCV, includeContext) => {
-  const [fromCInt, fromVInt] = fromCV.split(':').map(str => parseInt(str));
-  const [toCInt, toVInt] = toCV.split(':').map(str => parseInt(str));
-
-  if (toCInt < fromCInt) {
-    throw new Error(`cv chapterVerses requires fromChapter <= toChapter, not ${fromCInt} to ${toCInt}`);
-  }
-
-  const chapterSpecs = []; // [chN, minVN?, maxVN?]
-  let ch = fromCInt;
-
-  while (ch <= toCInt) {
-    chapterSpecs.push([
-      ch,
-      ch === fromCInt ? fromVInt : null,
-      ch === toCInt ? toVInt : null,
-    ]);
-    ch++;
-  }
-  return context.docSet.sequenceItemsByScopes(mainSequence.blocks, ['chapter/', 'verse/'], includeContext)
-    .filter(ig => scopesMatchAChapterSpec(ig[0], chapterSpecs));
-};
-
-const do_cv_separate_args = (root, args, context, mainSequence, doMap, mappedDocSetId) => {
-  if (args.chapter && !args.verses) { // whole chapter
-    return do_chapter_cv(root, context, mainSequence, args.chapter, args.includeContext);
-  } else if (args.verses) { // c:v, c:v-v one day, may be mapped
-    return do_chapter_verse_array(root, context, mainSequence, args.chapter, args.verses, args.includeContext, doMap, mappedDocSetId);
-  } else {
-    throw new Error('Unexpected args to do_cv_separate_args');
-  }
-};
-
-const do_cv_string_arg = (root, args, context, mainSequence) => {
-  if (xre.test(args.chapterVerses, xre('^[0-9]+:[0-9]+-[0-9]+:[0-9]+$'))) { // c:v-c:v
-    const [fromSpec, toSpec] = args.chapterVerses.split('-');
-    return do_chapterVerses(root, context, mainSequence, fromSpec, toSpec, args.includeContext);
-  } else if (xre.test(args.chapterVerses, xre('^[0-9]+:[0-9]+-[0-9]+$'))) { // c:v-v
-    const [ch, vRange] = args.chapterVerses.split(':');
-    const [fromV, toV] = vRange.split('-');
-    return do_chapterVerses(root, context, mainSequence, `${ch}:${fromV}`, `${ch}:${toV}`, args.includeContext);
-  } else if (xre.test(args.chapterVerses, xre('^[0-9]+:[0-9]+$'))) { // c:v
-    const [ch, v] = args.chapterVerses.split(':');
-    return do_chapterVerses(root, context, mainSequence, `${ch}:${v}`, `${ch}:${v}`, args.includeContext);
-  } else if (xre.test(args.chapterVerses, xre('^[0-9]+$'))) { // c
-    const ch = args.chapterVerses;
-    const cvi = root.chapterVerseIndex(ch);
-
-    if (!cvi) {
-      throw new Error(`No chapter ${ch} found`);
-    }
-
-    const verseNs = cvi.map((c, n) => [n, c]).filter(nc => nc[1].length > 0).map(nc => nc[0]);
-    return do_chapterVerses(root, context, mainSequence, `${ch}:${Math.min(verseNs)}`, `${ch}:${Math.max(verseNs)}`, args.includeContext);
-  } else {
-    throw new Error(`Could not parse chapterVerses string '${args.chapterVerses}'`);
-  }
-};
-
-const do_cv = (root, args, context, doMap, mappedDocSetId) => {
-  context.docSet = root.processor.docSets[root.docSetId];
-  const mainSequence = root.sequences[root.mainId];
-
-  if (!args.chapter && !args.chapterVerses) {
-    throw new Error('Must specify either chapter or chapterVerses for cv');
-  }
-
-  if (args.chapter && args.chapterVerses) {
-    throw new Error('Must not specify both chapter and chapterVerses for cv');
-  }
-
-  if (args.chapterVerses && args.verses) {
-    throw new Error('Must not specify both chapterVerses and verses for cv');
-  }
-
-  if (args.chapter) {
-    return do_cv_separate_args(root, args, context, mainSequence, doMap, mappedDocSetId);
-  } else {
-    return do_cv_string_arg(root, args, context, mainSequence);
-  }
-};
-
-module.exports = { do_cv };

package/src/graph/lib/dump.cjs

@@ -1,40 +0,0 @@
-const dumpItem = i => {
-  let wrapper;
-
-  switch (i[0]) {
-  case 'token':
-    return `|${i[2]}`;
-  case 'scope':
-    wrapper = i[1] === 'start' ? '+' : '-';
-    return `${wrapper}${i[2]}${wrapper}`;
-  case 'graft':
-    return `>${i[1]}<`;
-  }
-};
-
-const dumpItems = il => il.map(bci => dumpItem(bci)).join('');
-
-const dumpItemGroup = ig => {
-  const ret = ['ItemGroup:'];
-  ret.push(`   Open Scopes ${ig[0].join(', ')}`);
-  ret.push(`   ${dumpItems(ig[1])}`);
-  return ret.join('\n');
-};
-
-const dumpBlock = b => {
-  const ret = ['Block:'];
-
-  if (b.bg.length > 0) {
-    b.bg.forEach(bbg => ret.push(`   ${bbg[1]} graft to ${bbg[2]}`));
-  }
-  ret.push(`   Scope ${b.bs[2]}`);
-  ret.push(`   ${dumpItems(b.c)}`);
-  return ret.join('\n');
-};
-
-module.exports = {
-  dumpBlock,
-  dumpItemGroup,
-  dumpItems,
-  dumpItem,
-};

package/src/graph/lib/remake_blocks.cjs

@@ -1,57 +0,0 @@
-const remakeBlocks = (docSet, document, sequence, blocksSpec) => {
-  const nBlocks = sequence.blocks.length;
-
-  for (let blockN = 0; blockN < nBlocks; blockN++) {
-    document.deleteBlock(sequence.id, 0, false);
-  }
-
-  for (let blockN = 0; blockN < blocksSpec.length; blockN++) {
-    const block = blocksSpec[blockN];
-    document.newBlock(sequence.id, blockN, block.bs.payload, null, false);
-    const bgResult = docSet.updateBlockGrafts(
-      document.id,
-      sequence.id,
-      blockN,
-      block.bg,
-    );
-
-    if (!bgResult) {
-      return false;
-    }
-
-    const osResult = docSet.updateOpenScopes(
-      document.id,
-      sequence.id,
-      blockN,
-      block.os,
-    );
-
-    if (!osResult) {
-      return false;
-    }
-
-    const isResult = docSet.updateIncludedScopes(
-      document.id,
-      sequence.id,
-      blockN,
-      block.is,
-    );
-
-    if (!isResult) {
-      return false;
-    }
-
-    const itemsResult = docSet.updateItems(
-      document.id,
-      sequence.id,
-      blockN,
-      block.items,
-    );
-
-    if (!itemsResult) {
-      return false;
-    }
-  }
-};
-
-module.exports = { remakeBlocks };

package/src/graph/lib/sequence_chars.cjs

@@ -1,84 +0,0 @@
-const utils = require('../../util/index.cjs');
-
-const exactSearchTermIndexes = (docSet, chars, allChars) => {
-  let charsIndexesArray = [
-    chars
-      .map(
-        c => [utils.enums.enumStringIndex(docSet.enums.wordLike, c)],
-      ),
-  ];
-
-  if (allChars) {
-    charsIndexesArray = charsIndexesArray[0];
-  } else {
-    charsIndexesArray = charsIndexesArray.map(ci => ci.reduce((a, b) => a.concat(b)));
-  }
-  return charsIndexesArray;
-};
-
-const regexSearchTermIndexes = (docSet, chars, allChars) => {
-  let charsIndexesArray = [
-    chars
-      .map(
-        c =>
-          utils.enums.enumRegexIndexTuples(docSet.enums.wordLike, c)
-            .map(tup => tup[0]),
-      ),
-  ];
-
-  if (allChars) {
-    charsIndexesArray = charsIndexesArray[0];
-  } else {
-    charsIndexesArray = charsIndexesArray.map(ci => ci.reduce((a, b) => a.concat(b)));
-  }
-  return charsIndexesArray;
-};
-
-const sequenceMatchesSearchTerms = (seq, charsIndexesArray, allChars) => {
-  if (allChars && charsIndexesArray.filter(i => i.length === 0).length > 0) {
-    return false;
-  }
-
-  charsIndexesArray = charsIndexesArray.filter(i => i.length > 0);
-
-  if (charsIndexesArray.length === 0) {
-    return false;
-  }
-
-  for (const charsIndexes of charsIndexesArray) {
-    let found = false;
-
-    for (const charsIndex of charsIndexes) {
-      const isPresent = charsIndex >= 0 && seq.tokensPresent.get(charsIndex) > 0;
-
-      if (isPresent) {
-        found = true;
-        break;
-      }
-    }
-
-    if (allChars && !found) {
-      return false;
-    } else if (!allChars && found) {
-      return true;
-    }
-  }
-  return allChars;
-};
-
-const sequenceHasChars = (docSet, seq, chars, allChars) => {
-  let charsIndexesArray = exactSearchTermIndexes(docSet, chars, allChars);
-  return sequenceMatchesSearchTerms(seq, charsIndexesArray, allChars);
-};
-
-const sequenceHasMatchingChars = (docSet, seq, chars, allChars) => {
-  let charsIndexesArray = regexSearchTermIndexes(docSet, chars, allChars);
-  return sequenceMatchesSearchTerms(seq, charsIndexesArray, allChars);
-};
-
-module.exports = {
-  sequenceHasChars,
-  sequenceHasMatchingChars,
-  regexSearchTermIndexes,
-  exactSearchTermIndexes,
-};