@traqula/rules-sparql-1-1 0.0.21 → 0.0.23

package/dist/cjs/lib/grammar/tripleBlock.js

@@ -0,0 +1,384 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tripleBlock_exports = {};
+__export(tripleBlock_exports, {
+  blankNodePropertyList: () => blankNodePropertyList,
+  blankNodePropertyListPath: () => blankNodePropertyListPath,
+  collection: () => collection,
+  collectionPath: () => collectionPath,
+  graphNode: () => graphNode,
+  graphNodePath: () => graphNodePath,
+  object: () => object,
+  objectList: () => objectList,
+  objectListPath: () => objectListPath,
+  objectPath: () => objectPath,
+  propertyList: () => propertyList,
+  propertyListNotEmpty: () => propertyListNotEmpty,
+  propertyListPath: () => propertyListPath,
+  propertyListPathNotEmpty: () => propertyListPathNotEmpty,
+  triplesBlock: () => triplesBlock,
+  triplesNode: () => triplesNode,
+  triplesNodePath: () => triplesNodePath,
+  triplesSameSubject: () => triplesSameSubject,
+  triplesSameSubjectPath: () => triplesSameSubjectPath,
+  triplesTemplate: () => triplesTemplate,
+  verbPath: () => verbPath,
+  verbSimple: () => verbSimple
+});
+module.exports = __toCommonJS(tripleBlock_exports);
+var import_core = require("@traqula/core");
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_utils = require("../utils.js");
+var import_general = require("./general.js");
+var import_propertyPaths = require("./propertyPaths.js");
+function triplesDotSeperated(triplesSameSubjectSubrule) {
+  return ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => (C) => {
+    const triples = [];
+    let parsedDot = true;
+    let dotToken;
+    AT_LEAST_ONE({
+      GATE: () => parsedDot,
+      DEF: () => {
+        parsedDot = false;
+        const template = SUBRULE(triplesSameSubjectSubrule);
+        ACTION(() => {
+          triples.push(...template);
+        });
+        OPTION(() => {
+          dotToken = CONSUME(l.symbols.dot);
+          parsedDot = true;
+        });
+      }
+    });
+    return ACTION(() => C.astFactory.patternBgp(triples, C.astFactory.sourceLocation(...triples, dotToken)));
+  };
+}
+const triplesBlock = {
+  name: "triplesBlock",
+  impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C),
+  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC, NEW_LINE }) => (ast, { astFactory: F }) => {
+    for (const [index, triple] of ast.triples.entries()) {
+      HANDLE_LOC(triple, () => {
+        const nextTriple = ast.triples.at(index);
+        if (F.isTripleCollection(triple)) {
+          SUBRULE(graphNodePath, triple);
+          F.printFilter(triple, () => {
+            PRINT_WORD(".");
+            NEW_LINE();
+          });
+        } else {
+          SUBRULE(graphNodePath, triple.subject);
+          F.printFilter(triple, () => PRINT_WORD(""));
+          if (F.isTerm(triple.predicate) && F.isTermVariable(triple.predicate)) {
+            SUBRULE(import_general.varOrTerm, triple.predicate);
+          } else {
+            SUBRULE(import_propertyPaths.pathGenerator, triple.predicate, void 0);
+          }
+          F.printFilter(triple, () => PRINT_WORD(""));
+          SUBRULE(graphNodePath, triple.object);
+          if (nextTriple === void 0 || F.isTripleCollection(nextTriple) || !F.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
+            F.printFilter(ast, () => {
+              PRINT_WORD(".");
+              NEW_LINE();
+            });
+          } else if (F.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
+            F.printFilter(ast, () => PRINT_WORD(","));
+          } else {
+            F.printFilter(ast, () => {
+              PRINT_WORD(";");
+              NEW_LINE();
+            });
+          }
+        }
+      });
+    }
+  }
+};
+function triplesSameSubjectImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE, OR }) => (C) => OR([
+      { ALT: () => {
+        const subject = SUBRULE(import_general.varOrTerm);
+        const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.astFactory.dematerialized(subject)));
+        return ACTION(() => {
+          if (res.length > 0) {
+            res[0].subject = subject;
+            res[0].loc = C.astFactory.sourceLocation(subject, res[0]);
+          }
+          return res;
+        });
+      } },
+      { ALT: () => {
+        const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode);
+        const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.astFactory.graphNodeIdentifier(subjectNode)));
+        return ACTION(() => {
+          if (restNode.length === 0) {
+            return [subjectNode];
+          }
+          restNode[0].subject = subjectNode;
+          restNode[0].loc = C.astFactory.sourceLocation(subjectNode, restNode[0]);
+          return restNode;
+        });
+      } }
+    ])
+  };
+}
+const triplesSameSubject = triplesSameSubjectImpl("triplesSameSubject", false);
+const triplesSameSubjectPath = triplesSameSubjectImpl("triplesSameSubjectPath", true);
+const triplesTemplate = {
+  name: "triplesTemplate",
+  impl: triplesDotSeperated(triplesSameSubject)
+};
+function propertyListImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ({ SUBRULE, OPTION }) => (_, subject) => OPTION(() => SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, subject)) ?? []
+  };
+}
+const propertyList = propertyListImpl("propertyList", false);
+const propertyListPath = propertyListImpl("propertyListPath", true);
+function propertyListNotEmptyImplementation(name, allowPaths) {
+  return {
+    name,
+    impl: ({ ACTION, CONSUME, AT_LEAST_ONE, SUBRULE1, MANY2, OR1 }) => (_, subject) => {
+      const result = [];
+      let parsedSemi = true;
+      AT_LEAST_ONE({
+        GATE: () => parsedSemi,
+        DEF: () => {
+          parsedSemi = false;
+          const predicate = allowPaths ? OR1([
+            { ALT: () => SUBRULE1(verbPath) },
+            { ALT: () => SUBRULE1(verbSimple) }
+          ]) : SUBRULE1(import_general.verb);
+          const triples = SUBRULE1(allowPaths ? objectListPath : objectList, subject, predicate);
+          MANY2(() => {
+            CONSUME(l.symbols.semi);
+            parsedSemi = true;
+          });
+          ACTION(() => {
+            result.push(...triples);
+          });
+        }
+      });
+      return result;
+    }
+  };
+}
+const propertyListNotEmpty = propertyListNotEmptyImplementation("propertyListNotEmpty", false);
+const propertyListPathNotEmpty = propertyListNotEmptyImplementation("propertyListPathNotEmpty", true);
+const verbPath = {
+  name: "verbPath",
+  impl: ({ SUBRULE }) => () => SUBRULE(import_propertyPaths.path)
+};
+const verbSimple = {
+  name: "verbSimple",
+  impl: ({ SUBRULE }) => () => SUBRULE(import_general.var_)
+};
+function objectListImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE, AT_LEAST_ONE_SEP }) => (_, subj, pred) => {
+      const objects = [];
+      AT_LEAST_ONE_SEP({
+        SEP: l.symbols.comma,
+        DEF: () => {
+          const objectTriple = SUBRULE(allowPaths ? objectPath : object, subj, pred);
+          ACTION(() => {
+            objects.push(objectTriple);
+          });
+        }
+      });
+      return objects;
+    }
+  };
+}
+const objectList = objectListImpl("objectList", false);
+const objectListPath = objectListImpl("objectListPath", true);
+function objectImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
+      const node = SUBRULE(allowPaths ? graphNodePath : graphNode);
+      return ACTION(() => C.astFactory.triple(subject, predicate, node));
+    }
+  };
+}
+const object = objectImpl("object", false);
+const objectPath = objectImpl("objectPath", true);
+function collectionImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME }) => (C) => {
+      const terms = [];
+      const startToken = CONSUME(l.symbols.LParen);
+      AT_LEAST_ONE(() => {
+        terms.push(SUBRULE(allowPaths ? graphNodePath : graphNode));
+      });
+      const endToken = CONSUME(l.symbols.RParen);
+      return ACTION(() => {
+        const F = C.astFactory;
+        const triples = [];
+        const predFirst = F.termNamed(F.sourceLocationNoMaterialize(), import_utils.CommonIRIs.FIRST, void 0);
+        const predRest = F.termNamed(F.sourceLocationNoMaterialize(), import_utils.CommonIRIs.REST, void 0);
+        const predNil = F.termNamed(F.sourceLocationNoMaterialize(), import_utils.CommonIRIs.NIL, void 0);
+        const listHead = F.termBlank(void 0, F.sourceLocationNoMaterialize());
+        let iterHead = listHead;
+        for (const [index, term] of terms.entries()) {
+          const lastInList = index === terms.length - 1;
+          const headTriple = F.triple(iterHead, predFirst, term);
+          triples.push(headTriple);
+          if (lastInList) {
+            const nilTriple = F.triple(iterHead, predRest, predNil);
+            triples.push(nilTriple);
+          } else {
+            const tail = F.termBlank(void 0, F.sourceLocationNoMaterialize());
+            const linkTriple = F.triple(iterHead, predRest, tail);
+            triples.push(linkTriple);
+            iterHead = tail;
+          }
+        }
+        return F.tripleCollectionList(listHead, triples, F.sourceLocation(startToken, endToken));
+      });
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+      F.printFilter(ast, () => PRINT_WORD("("));
+      for (const [idx, triple] of ast.triples.entries()) {
+        if (idx % 2 === 0) {
+          SUBRULE(allowPaths ? graphNodePath : graphNode, triple.object);
+        }
+      }
+      F.printFilter(ast, () => PRINT_WORD(")"));
+    }
+  };
+}
+const collection = collectionImpl("collection", false);
+const collectionPath = collectionImpl("collectionPath", true);
+function triplesNodeImpl(name, allowPaths) {
+  return {
+    name,
+    impl: ({ SUBRULE, OR }) => () => OR([
+      { ALT: () => SUBRULE(allowPaths ? collectionPath : collection) },
+      { ALT: () => SUBRULE(allowPaths ? blankNodePropertyListPath : blankNodePropertyList) }
+    ]),
+    gImpl: ({ SUBRULE }) => (ast) => ast.subType === "list" ? SUBRULE(allowPaths ? collectionPath : collection, ast) : SUBRULE(allowPaths ? blankNodePropertyListPath : blankNodePropertyList, ast)
+  };
+}
+const triplesNode = triplesNodeImpl("triplesNode", false);
+const triplesNodePath = triplesNodeImpl("triplesNodePath", true);
+function blankNodePropertyListImpl(name, allowPaths) {
+  const propertyPathNotEmptyImpl = allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty;
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+      const startToken = CONSUME(l.symbols.LSquare);
+      const blankNode = ACTION(() => C.astFactory.termBlank(void 0, C.astFactory.sourceLocationNoMaterialize()));
+      const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode);
+      const endToken = CONSUME(l.symbols.RSquare);
+      return ACTION(() => C.astFactory.tripleCollectionBlankNodeProperties(blankNode, propList, C.astFactory.sourceLocation(startToken, endToken)));
+    },
+    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC, PRINT_ON_EMPTY, NEW_LINE }) => (ast, c) => {
+      const { astFactory: F, indentInc } = c;
+      F.printFilter(ast, () => {
+        c[import_core.traqulaIndentation] += indentInc;
+        PRINT("[");
+        NEW_LINE();
+      });
+      for (const triple of ast.triples) {
+        HANDLE_LOC(triple, () => {
+          if (F.isTerm(triple.predicate) && F.isTermVariable(triple.predicate)) {
+            SUBRULE(import_general.varOrTerm, triple.predicate);
+          } else {
+            SUBRULE(import_propertyPaths.pathGenerator, triple.predicate, void 0);
+          }
+          F.printFilter(triple, () => PRINT_WORD(""));
+          SUBRULE(graphNodePath, triple.object);
+          F.printFilter(ast, () => {
+            PRINT_WORD(";");
+            NEW_LINE();
+          });
+        });
+      }
+      F.printFilter(ast, () => {
+        c[import_core.traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("]");
+      });
+    }
+  };
+}
+const blankNodePropertyList = blankNodePropertyListImpl("blankNodePropertyList", false);
+const blankNodePropertyListPath = blankNodePropertyListImpl("blankNodePropertyListPath", true);
+function graphNodeImpl(name, allowPaths) {
+  const triplesNodeRule = allowPaths ? triplesNodePath : triplesNode;
+  return {
+    name,
+    impl: ({ SUBRULE, OR }) => (C) => OR([
+      { ALT: () => SUBRULE(import_general.varOrTerm) },
+      {
+        GATE: () => C.parseMode.has("canCreateBlankNodes"),
+        ALT: () => SUBRULE(triplesNodeRule)
+      }
+    ]),
+    gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+      if (F.isTerm(ast)) {
+        SUBRULE(import_general.varOrTerm, ast);
+      } else {
+        SUBRULE(triplesNodeRule, ast);
+      }
+    }
+  };
+}
+const graphNode = graphNodeImpl("graphNode", false);
+const graphNodePath = graphNodeImpl("graphNodePath", true);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blankNodePropertyList,
+  blankNodePropertyListPath,
+  collection,
+  collectionPath,
+  graphNode,
+  graphNodePath,
+  object,
+  objectList,
+  objectListPath,
+  objectPath,
+  propertyList,
+  propertyListNotEmpty,
+  propertyListPath,
+  propertyListPathNotEmpty,
+  triplesBlock,
+  triplesNode,
+  triplesNodePath,
+  triplesSameSubject,
+  triplesSameSubjectPath,
+  triplesTemplate,
+  verbPath,
+  verbSimple
+});