proskomma-core 0.9.18 → 0.9.19

package/src/graph/lib/tribos_ohm_UNUSED.cjs

@@ -1,37 +0,0 @@
-/*
-predicateExpression {
-  Exp
-    = booleanExpression
-
-  booleanExpression =
-    "true" |
-    "false" |
-    booleanNonPrimitive
-
-  booleanNonPrimitive =
-    equalsOperator |
-    notEqualOperator |
-    andOperator |
-    orOperator
-
-  equalsOperator = "==" "(" expressions ")"
-  notEqualOperator = "!=" "(" expressions ")"
-  andOperator = "and" "(" booleanExpressions ")"
-  orOperator = "or" "(" booleanExpressions ")"
-
-  expressions = expression ("," " "* expressions)*
-  booleanExpressions = booleanExpression ("," " "* booleanExpressions)*
-  stringExpressions = stringExpression ("," " "* stringExpressions)*
-
-  expression = booleanExpression | stringExpression
-
-  stringExpression = stringLiteral | stringNonPrimitive
-
-  stringNonPrimitive = concatOperator
-
-  concatOperator =  "concat" "(" stringExpressions ")"
-
-  stringLiteral = "'" letter* "'"
-
-}
-*/

package/src/graph/lib/tribos_step.cjs

@@ -1,434 +0,0 @@
-const xre = require('xregexp');
-
-const predicateRegex = '(\\[(([^\\]\']|\'([^\']|\\\\\')*\')+)\\])*';
-
-// Nodes with one of the listed ids
-const doAbsoluteIdStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
-  const values = matches[1].split(',').map(v => v.trim());
-  return { data: Array.from(values).map(nid => allNodes[nodeLookup.get(nid)]) };
-};
-
-// The root Node
-const doAbsoluteRootStep = (docSet, allNodes) => ({ data: [allNodes[0]] });
-
-// All the nodes
-const doAbsoluteNodesStep = (docSet, allNodes) => ({ data: allNodes });
-
-// Children of the nodes
-const doChildrenStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
-  const childNo = matches[2];
-  const childNodeIds = new Set([]);
-
-  for (const parentNode of result.data) {
-    const children = docSet.unsuccinctifyScopes(parentNode.is)
-      .map(s => s[2].split('/'))
-      .filter(s => s[0] === 'tTreeChild')
-      .filter(s => !childNo || s[1] === childNo)
-      .map(s => s[2]);
-
-    for (const child of children) {
-      childNodeIds.add(child);
-    }
-  }
-  return { data: Array.from(childNodeIds).map(nid => allNodes[nodeLookup.get(nid)]) };
-};
-
-// The parent of each node
-const doParentStep = (docSet, allNodes, nodeLookup, result) => {
-  const parentNodeIds = new Set([]);
-
-  for (const childNode of result.data) {
-    const parentId = docSet.unsuccinctifyScopes(childNode.is)
-      .filter(s => s[2].startsWith('tTreeParent'))
-      .map(s => s[2].split('/')[1])[0];
-    parentNodeIds.add(parentId);
-  }
-  return { data: Array.from(parentNodeIds).map(nid => allNodes[nodeLookup.get(nid)]) };
-};
-
-// The nth ancestor of each node (where 1 === parent)
-const doAncestorStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
-  let ancestorNo = parseInt(matches[2]);
-
-  if (ancestorNo < 1) {
-    return { errors: `Expected a positive integer argument for ancestor, found ${queryStep}` };
-  }
-
-  let nodes = result.data;
-
-  while (ancestorNo > 0) {
-    const parentNodeIds = new Set([]);
-
-    for (const childNode of nodes) {
-      const parentId = docSet.unsuccinctifyScopes(childNode.is)
-        .filter(s => s[2].startsWith('tTreeParent'))
-        .map(s => s[2].split('/')[1])[0];
-      parentNodeIds.add(parentId);
-    }
-    nodes = Array.from(parentNodeIds).map(nid => allNodes[nodeLookup.get(nid)]);
-    ancestorNo--;
-  }
-  return { data: nodes };
-};
-
-// The nth-generation descendants of each node (where 1 === child)
-const doDescendantsStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
-  const descendantIds = new Set([]);
-
-  const getDescendants = (node, depth) => {
-    const childIds = docSet.unsuccinctifyScopes(node.is)
-      .filter(s => s[2].startsWith('tTreeChild'))
-      .map(s => s[2].split('/')[2]);
-
-    if (depth <= 1 || depth === null) {
-      childIds.forEach(n => descendantIds.add(n));
-    }
-
-    if (depth === null || depth > 1) {
-      childIds.map(nid => allNodes[nodeLookup.get(nid)]).forEach(n => getDescendants(n, depth - 1));
-    }
-  };
-
-  let descendantGen = null;
-
-  if (matches[3]) {
-    descendantGen = parseInt(matches[3]);
-  }
-
-  let descendantNo = -1;
-
-  if (matches[5]) {
-    descendantNo = parseInt(matches[5]);
-  }
-
-  for (const node of result.data) {
-    getDescendants(node, descendantGen);
-  }
-  return {
-    data: [...Array.from(descendantIds).entries()]
-      .filter(n => descendantNo < 0 || n[0] === descendantNo)
-      .map(n => n[1])
-      .map(nid => allNodes[nodeLookup.get(nid)]),
-  };
-};
-
-// The leaves of each node
-const doLeavesStep = (docSet, allNodes, nodeLookup, result) => {
-  const leafIds = new Set([]);
-
-  const getLeaves = node => {
-    const childIds = docSet.unsuccinctifyScopes(node.is)
-      .filter(s => s[2].startsWith('tTreeChild'))
-      .map(s => s[2].split('/')[2]);
-
-    if (childIds.length === 0) {
-      leafIds.add(docSet.unsuccinctifyScopes(node.bs)[0][2].split('/')[1]);
-    } else {
-      childIds.map(nid => allNodes[nodeLookup.get(nid)]).forEach(n => getLeaves(n));
-    }
-  };
-
-  for (const node of result.data) {
-    getLeaves(node);
-  }
-  return { data: Array.from(leafIds).map(nid => allNodes[nodeLookup.get(nid)]) };
-};
-
-// The children of the parent of each node
-// - get parent of starting node
-// - get children of parent node
-const doSiblingsStep = (docSet, allNodes, nodeLookup, result) => {
-  const parentNodeIds = new Set([]);
-
-  for (const childNode of result.data) {
-    const parentId = docSet.unsuccinctifyScopes(childNode.is)
-      .filter(s => s[2].startsWith('tTreeParent'))
-      .map(s => s[2].split('/')[1])[0];
-    parentNodeIds.add(parentId);
-  }
-
-  const parentNodes = allNodes.filter(n => parentNodeIds.has(docSet.unsuccinctifyScopes(n.bs)[0][2].split('/')[1]));
-  const childNodeIds = new Set([]);
-
-  for (const parentNode of parentNodes) {
-    const children = docSet.unsuccinctifyScopes(parentNode.is)
-      .filter(s => s[2].startsWith('tTreeChild'))
-      .map(s => s[2].split('/')[2]);
-
-    for (const child of children) {
-      childNodeIds.add(child);
-    }
-  }
-  // return { data: allNodes.filter(n => childNodeIds.has(docSet.unsuccinctifyScopes(n.bs)[0][2].split('/')[1])) };
-  return { data: Array.from(childNodeIds).map(nid => allNodes[nodeLookup.get(nid)]) };
-};
-
-const nodeDetails = (docSet, node, allNodes, nodeLookup, fields, isBranch) => {
-  const record = {};
-
-  if (fields.size === 0 || fields.has('id')) {
-    record.id = docSet.unsuccinctifyScopes(node.bs)[0][2].split('/')[1];
-  }
-
-  if (fields.size === 0 || fields.has('parentId')) {
-    record.parentId = docSet.unsuccinctifyScopes(node.is)
-      .filter(s => s[2].startsWith('tTreeParent'))
-      .map(s => s[2].split('/')[1])[0];
-  }
-
-  const content = {};
-
-  for (const [scopeLabels, items] of docSet.sequenceItemsByScopes([node], ['tTreeContent/'], false)) {
-    const key = scopeLabels.filter(s => s.startsWith('tTreeContent'))[0].split('/')[1];
-
-    if (fields.size === 0 || fields.has('content') || fields.has(`@${key}`)) {
-      content[key] = items.filter(i => i[0] === 'token').map(t => t[2]).join('');
-    }
-  }
-
-  if (Object.keys(content).length > 0) {
-    record.content = content;
-  }
-
-  const children = [];
-
-  if (fields.has('children')) {
-    for (const childScope of docSet.unsuccinctifyScopes(node.is)
-      .filter(s => s[2].startsWith('tTreeChild'))
-      .map(s => s[2].split('/')[2])) {
-      children.push(childScope);
-    }
-  }
-
-  if (children.length > 0) {
-    if (isBranch) {
-      record.children = children
-        .map(nid => allNodes[nodeLookup.get(nid)])
-        .map(n => nodeDetails(docSet, n, allNodes, nodeLookup, fields, true));
-    } else {
-      record.children = children;
-    }
-  }
-  return record;
-};
-
-
-// The node details included children
-// optional fields are id, parentId, content, @<contentName>, children
-const doBranchStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
-  const ret = [];
-  let fields = new Set([]);
-
-  if (matches[2]) {
-    fields = new Set(
-      matches[2]
-        .split(',')
-        .map(f => f.trim()),
-    );
-  }
-
-  for (const node of result.data) {
-    ret.push(nodeDetails(docSet, node, allNodes, nodeLookup, fields, true));
-  }
-  return { data: ret };
-};
-
-// All values across nodes for the specified content fields
-const doValuesStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
-  const nodeFields = [];
-  let fields = new Set([]);
-
-  if (matches[2]) {
-    fields = new Set(
-      matches[2]
-        .split(',')
-        .map(f => f.trim())
-        .filter(f => f.startsWith('@')),
-    );
-  }
-
-  for (const node of result.data) {
-    nodeFields.push(nodeDetails(docSet, node, allNodes, nodeLookup, fields, true));
-  }
-
-  const values = {};
-
-  for (const field of Array.from(fields).map(f => f.substring(1))) {
-    values[field] = Array.from(
-      new Set(
-        nodeFields
-          .filter(nd => nd.content)
-          .map(nd => nd.content)
-          .filter(nd => field in nd)
-          .map(nd => nd[field])
-          .sort(),
-      ),
-    );
-  }
-  return { data: values };
-};
-
-// The node details
-// optional fields are id, parentId, content, @<contentName>, children
-const doNodeStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
-  const ret = [];
-  let fields = new Set([]);
-
-  if (matches[2]) {
-    fields = new Set(matches[2].split(',').map(f => f.trim()));
-  }
-
-  for (const node of result.data) {
-    ret.push(nodeDetails(docSet, node, allNodes, nodeLookup, fields, false));
-  }
-  return { data: ret };
-};
-
-const stepActions = [
-  {
-    regex: xre(`^#\\{([^}]+)\\}${predicateRegex}$`),
-    doc: {
-      title: 'Nodes by Id',
-      syntax: '#(id, id, ...)',
-      description: 'Returns nodes whose id is listed',
-    },
-    predicateCapture: 3,
-    inputType: null,
-    outputType: 'nodes',
-    function: doAbsoluteIdStep,
-  },
-  {
-    regex: xre(`^root${predicateRegex}$`),
-    doc: {
-      title: 'Root Node',
-      syntax: 'root',
-      description: 'Returns the root node',
-    },
-    predicateCapture: 2,
-    inputType: null,
-    outputType: 'nodes',
-    function: doAbsoluteRootStep,
-  },
-  {
-    regex: xre(`^nodes${predicateRegex}$`),
-    doc: {
-      title: 'Nodes',
-      syntax: 'nodes',
-      description: 'Returns all the nodes',
-    },
-    predicateCapture: 2,
-    function: doAbsoluteNodesStep,
-    inputType: null,
-    outputType: 'nodes',
-  },
-  {
-    regex: xre(`^children(\\((\\d+)\\))?${predicateRegex}$`),
-    doc: {
-      title: 'Children',
-      syntax: 'children; children(pos)',
-      description: 'Returns the children of the current node(s), optionally filtered by position within the parent node',
-    },
-    predicateCapture: 4,
-    inputType: 'nodes',
-    outputType: 'nodes',
-    function: doChildrenStep,
-  },
-  {
-    regex: xre(`^descendants((\\((\\d+)(,\\s*(\\d+))?\\))?)${predicateRegex}$`),
-    doc: {
-      title: 'Descendants',
-      syntax: 'descendants; descendants(depth); descendants(depth, pos)',
-      description: 'Returns the descendants of the current node(s), optionally at the specified level, optionally filtered by position',
-    },
-    predicateCapture: 7,
-    inputType: 'nodes',
-    outputType: 'nodes',
-    function: doDescendantsStep,
-  },
-  {
-    regex: xre(`^leaves${predicateRegex}$`),
-    doc: {
-      title: 'Leaves',
-      syntax: 'leaves',
-      description: 'Returns the leaves (ie the nodes with no children) below the current node',
-    },
-    predicateCapture: 2,
-    inputType: 'nodes',
-    outputType: 'nodes',
-    function: doLeavesStep,
-  },
-  {
-    regex: xre(`^parent${predicateRegex}$`),
-    doc: {
-      title: 'Parent',
-      syntax: 'parent',
-      description: 'Returns the parent of the current node',
-    },
-    predicateCapture: 2,
-    inputType: 'nodes',
-    outputType: 'nodes',
-    function: doParentStep,
-  },
-  {
-    regex: xre(`^ancestor(\\((\\d+)\\))${predicateRegex}$`),
-    doc: {
-      title: 'Ancestor',
-      syntax: 'ancestor(depth)',
-      description: 'Returns the nth ancestor of the node',
-    },
-    predicateCapture: 5,
-    inputType: 'nodes',
-    outputType: 'nodes',
-    function: doAncestorStep,
-  },
-  {
-    regex: xre(`^siblings${predicateRegex}$`),
-    doc: {
-      title: 'Siblings',
-      syntax: 'siblings',
-      description: 'Returns the children of the parent of the current node',
-    },
-    predicateCapture: 2,
-    inputType: 'nodes',
-    outputType: 'nodes',
-    function: doSiblingsStep,
-  },
-  {
-    regex: xre(`^node(\\{([^}]+)\\})?${predicateRegex}$`),
-    doc: {
-      title: 'Node Details',
-      syntax: 'node; node{ id, parentId, content, children, @foo }',
-      description: 'Returns an object containing the specified content',
-    },
-    predicateCapture: 4,
-    inputType: 'nodes',
-    outputType: 'node',
-    function: doNodeStep,
-  },
-  {
-    regex: xre(`^branch(\\{([^}]+)\\})?${predicateRegex}$`),
-    doc: {
-      title: 'Branch',
-      syntax: 'branch; branch{ id, parentId, content, children, @foo }',
-      description: 'Returns nested objects containing the specified content',
-    },
-    predicateCapture: 4,
-    inputType: 'nodes',
-    outputType: 'node',
-    function: doBranchStep,
-  },
-  {
-    regex: xre(`^values(\\{([^}]+)\\})?${predicateRegex}$`),
-    doc: {
-      title: 'Values',
-      syntax: 'values{ @foo ... }',
-      description: 'Returns all values across nodes for the specified fields',
-    },
-    predicateCapture: 4,
-    inputType: 'nodes',
-    outputType: 'values',
-    function: doValuesStep,
-  },
-];
-
-module.exports = { stepActions };

package/src/graph/mutations/add.cjs

@@ -1,91 +0,0 @@
-const utils = require('../../util/index.cjs');
-const { remakeBlocks } = require('../lib/remake_blocks.cjs');
-
-const addMutationsSchemaString = `
-  """Adds a document which will be assigned to an existing or new docSet on the basis of the specified selectors"""
-  addDocument(
-    """The selectors for this document, the keys of which must match those of the Proskomma instance"""
-    selectors: [InputKeyValue!]!
-    """The format of the content (probably usfm or usx)"""
-    contentType: String!
-    """The document content as a string"""
-    content: String!
-    """A list of tags to be added"""
-    tags: [String!]
-  ): Boolean!
-  """Creates a new, empty sequence"""
-  newSequence(
-    """The id of the document to which the sequence will be added"""
-    documentId: String!
-    """The type of the new sequence (main, heading...)"""
-    type: String!
-    """The JSON describing blocks, if any, for the new sequence"""
-    blocksSpec: [inputBlockSpec!]
-    """If true, graft to the first block of the main sequence"""
-    graftToMain: Boolean
-    """'A list of tags to be added"""
-    tags: [String!]
-  ): String!
-  """Adds a new block to a sequence"""
-  newBlock(
-    """The id of the document containing the sequence to which the block will be added"""
-    documentId: String!
-    """The id of the sequence to which the block will be added"""
-    sequenceId: String!
-    """The zero-indexed position at which to add the block"""
-    blockN: Int!
-    """The scope to be applied to the block, eg blockScope/p"""
-    blockScope: String!
-  ): Boolean!
-`;
-
-const addMutationsResolvers = {
-  addDocument: (root, args) => {
-    const selectorsObject = {};
-
-    args.selectors.forEach(
-      s => {
-        selectorsObject[s.key] = s.value;
-      },
-    );
-    return !!root.importDocument(selectorsObject, args.contentType, args.content, null, null, null, args.tags || []);
-  },
-  newSequence: (root, args) => {
-    const document = root.documents[args.documentId];
-    const docSet = document.processor.docSets[document.docSetId];
-
-    if (!document) {
-      throw new Error(`Document '${args.documentId}' not found`);
-    }
-
-    const newSeqId = document.newSequence(args.type, args.tags);
-
-    if (args.blocksSpec) {
-      remakeBlocks(docSet, document, document.sequences[newSeqId], args.blocksSpec);
-      document.buildChapterVerseIndex();
-    }
-
-    if (args.graftToMain) {
-      docSet.maybeBuildPreEnums();
-      const mainSequenceBG = document.sequences[document.mainId].blocks[0].bg;
-      const graftTypeEnumIndex = docSet.enumForCategoryValue('graftTypes', args.type, true);
-      const seqEnumIndex = docSet.enumForCategoryValue('ids', newSeqId, true);
-      utils.succinct.pushSuccinctGraftBytes(mainSequenceBG, graftTypeEnumIndex, seqEnumIndex);
-    }
-    return newSeqId;
-  },
-  newBlock: (root, args) => {
-    const document = root.documents[args.documentId];
-
-    if (!document) {
-      throw new Error(`Document '${args.documentId}' not found`);
-    }
-
-    return document.newBlock(args.sequenceId, args.blockN, args.blockScope);
-  },
-};
-
-module.exports = {
-  addMutationsSchemaString,
-  addMutationsResolvers,
-};

package/src/graph/mutations/delete.cjs

@@ -1,61 +0,0 @@
-const deleteMutationsSchemaString = `
-  """Deletes a docSet"""
-  deleteDocSet(
-    """The id of the docSet containing the document to be deleted"""
-    docSetId: String!
-  ): Boolean
-  """Deletes a document"""
-  deleteDocument(
-    """The id of the docSet containing the document to be deleted"""
-    docSetId: String!
-    """The id of the document to be deleted"""
-    documentId: String!
-  ): Boolean
-  """Deletes a sequence from a document"""
-  deleteSequence(
-    """The id of the document containing the sequence to be deleted"""
-    documentId: String!
-    """The id of the sequence to be deleted"""
-    sequenceId: String!
-  ): Boolean
-  """Deletes a block from a sequence"""
-  deleteBlock(
-    """The id of the document containing the sequence from which the block will be deleted"""
-    documentId: String!
-    """The id of the sequence from which the block will be deleted"""
-    sequenceId: String!
-    """The zero-indexed number of the block to be deleted"""
-    blockN: Int!
-  ): Boolean
-`;
-
-const deleteMutationsResolvers = {
-  deleteDocSet: (root, args) =>
-    root.deleteDocSet(args.docSetId),
-  deleteDocument: (root, args) =>
-    root.deleteDocument(args.docSetId, args.documentId),
-  deleteSequence: (root, args) => {
-    const document = root.documents[args.documentId];
-
-    if (!document) {
-      throw new Error(`Document '${args.documentId}' not found`);
-    }
-
-    return document.deleteSequence(args.sequenceId);
-  },
-  deleteBlock: (root, args) => {
-    const document = root.documents[args.documentId];
-
-    if (!document) {
-      throw new Error(`Document '${args.documentId}' not found`);
-    }
-
-    return document.deleteBlock(args.sequenceId, args.blockN);
-  },
-};
-
-
-module.exports = {
-  deleteMutationsSchemaString,
-  deleteMutationsResolvers,
-};

package/src/graph/mutations/index.cjs

@@ -1,54 +0,0 @@
-const {
-  addMutationsSchemaString,
-  addMutationsResolvers,
-} = require('./add.cjs');
-
-const {
-  deleteMutationsSchemaString,
-  deleteMutationsResolvers,
-} = require('./delete.cjs');
-
-const {
-  rehashMutationsSchemaString,
-  rehashMutationsResolvers,
-} = require('./rehash.cjs');
-
-const {
-  tagMutationsSchemaString,
-  tagMutationsResolvers,
-} = require('./tags.cjs');
-
-const {
-  updateMutationsSchemaString,
-  updateMutationsResolvers,
-} = require('./update.cjs');
-
-const {
-  versificationMutationsSchemaString,
-  versificationMutationsResolvers,
-} = require('./versification.cjs');
-
-const mutationsSchemaString = `
-type Mutation {
-${addMutationsSchemaString}
-${deleteMutationsSchemaString}
-${rehashMutationsSchemaString}
-${tagMutationsSchemaString}
-${updateMutationsSchemaString}
-${versificationMutationsSchemaString}
-}`;
-
-const mutationsResolvers = {
-  ...addMutationsResolvers,
-  ...deleteMutationsResolvers,
-  ...rehashMutationsResolvers,
-  ...tagMutationsResolvers,
-  ...updateMutationsResolvers,
-  ...versificationMutationsResolvers,
-};
-
-
-module.exports = {
-  mutationsSchemaString,
-  mutationsResolvers,
-};

package/src/graph/mutations/rehash.cjs

@@ -1,17 +0,0 @@
-const rehashMutationsSchemaString = `
-  """Explicitly rebuild the text lookup tables for a docSet. (You probably don't need to do this)"""
-  rehashDocSet(
-    """The id of the docSet"""
-    docSetId: String!
-  ): Boolean!
-`;
-
-const rehashMutationsResolvers = {
-  rehashDocSet: (root, args) =>
-    root.rehashDocSet(args.docSetId),
-};
-
-module.exports = {
-  rehashMutationsSchemaString,
-  rehashMutationsResolvers,
-};