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

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

@@ -0,0 +1,483 @@
+"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 whereClause_exports = {};
+__export(whereClause_exports, {
+  bind: () => bind,
+  constraint: () => constraint,
+  dataBlock: () => dataBlock,
+  dataBlockValue: () => dataBlockValue,
+  filter: () => filter,
+  functionCall: () => functionCall,
+  generatePattern: () => generatePattern,
+  graphGraphPattern: () => graphGraphPattern,
+  graphPatternNotTriples: () => graphPatternNotTriples,
+  groupGraphPattern: () => groupGraphPattern,
+  groupGraphPatternSub: () => groupGraphPatternSub,
+  groupOrUnionGraphPattern: () => groupOrUnionGraphPattern,
+  inlineData: () => inlineData,
+  inlineDataFull: () => inlineDataFull,
+  inlineDataOneVar: () => inlineDataOneVar,
+  minusGraphPattern: () => minusGraphPattern,
+  optionalGraphPattern: () => optionalGraphPattern,
+  serviceGraphPattern: () => serviceGraphPattern,
+  whereClause: () => whereClause
+});
+module.exports = __toCommonJS(whereClause_exports);
+var import_core = require("@traqula/core");
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_validators = require("../validation/validators.js");
+var import_builtIn = require("./builtIn.js");
+var import_expression = require("./expression.js");
+var import_general = require("./general.js");
+var import_literals = require("./literals.js");
+var import_queryUnit = require("./queryUnit.js");
+var import_tripleBlock = require("./tripleBlock.js");
+const whereClause = {
+  name: "whereClause",
+  impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => (C) => {
+    const where = OPTION(() => CONSUME(l.where));
+    const group = SUBRULE(groupGraphPattern);
+    return ACTION(() => C.astFactory.wrap(group, C.astFactory.sourceLocation(where, group)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD("WHERE"));
+    SUBRULE(groupGraphPattern, ast.val);
+  }
+};
+const groupGraphPattern = {
+  name: "groupGraphPattern",
+  impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => {
+    const open = CONSUME(l.symbols.LCurly);
+    const patterns = OR([
+      { ALT: () => [SUBRULE(import_queryUnit.subSelect)] },
+      { ALT: () => SUBRULE(groupGraphPatternSub) }
+    ]);
+    const close = CONSUME(l.symbols.RCurly);
+    return ACTION(() => C.astFactory.patternGroup(patterns, C.astFactory.sourceLocation(open, close)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE, PRINT_ON_OWN_LINE }) => (ast, C) => {
+    const { astFactory: F, indentInc } = C;
+    F.printFilter(ast, () => {
+      C[import_core.traqulaIndentation] += indentInc;
+      PRINT_WORD("{");
+      NEW_LINE();
+    });
+    for (const pattern of ast.patterns) {
+      SUBRULE(generatePattern, pattern);
+    }
+    F.printFilter(ast, () => {
+      C[import_core.traqulaIndentation] -= indentInc;
+      PRINT_ON_OWN_LINE("}");
+    });
+  }
+};
+const generatePattern = {
+  name: "generatePattern",
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+    if (ast.type === "query") {
+      SUBRULE(import_queryUnit.query, F.querySelect({
+        context: [],
+        datasets: F.datasetClauses([], F.sourceLocation()),
+        where: ast.where,
+        variables: ast.variables,
+        solutionModifiers: ast.solutionModifiers,
+        values: ast.values,
+        distinct: ast.distinct,
+        reduced: ast.reduced
+      }, ast.loc));
+    } else if (ast.subType === "group") {
+      SUBRULE(groupGraphPattern, ast);
+    } else if (ast.subType === "bgp") {
+      SUBRULE(import_tripleBlock.triplesBlock, ast);
+    } else {
+      SUBRULE(graphPatternNotTriples, ast);
+    }
+  }
+};
+const groupGraphPatternSub = {
+  name: "groupGraphPatternSub",
+  impl: ({ ACTION, SUBRULE, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OPTION3 }) => () => {
+    const patterns = [];
+    const bgpPattern = OPTION1(() => SUBRULE1(import_tripleBlock.triplesBlock));
+    if (bgpPattern) {
+      patterns.push(bgpPattern);
+    }
+    MANY(() => {
+      const notTriples = SUBRULE(graphPatternNotTriples);
+      patterns.push(notTriples);
+      OPTION2(() => CONSUME(l.symbols.dot));
+      const moreTriples = OPTION3(() => SUBRULE2(import_tripleBlock.triplesBlock));
+      if (moreTriples) {
+        patterns.push(moreTriples);
+      }
+    });
+    ACTION(() => (0, import_validators.checkNote13)(patterns));
+    return patterns;
+  }
+};
+const graphPatternNotTriples = {
+  name: "graphPatternNotTriples",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(groupOrUnionGraphPattern) },
+    { ALT: () => SUBRULE(optionalGraphPattern) },
+    { ALT: () => SUBRULE(minusGraphPattern) },
+    { ALT: () => SUBRULE(graphGraphPattern) },
+    { ALT: () => SUBRULE(serviceGraphPattern) },
+    { ALT: () => SUBRULE(filter) },
+    { ALT: () => SUBRULE(bind) },
+    { ALT: () => SUBRULE(inlineData) }
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    switch (ast.subType) {
+      case "group":
+      case "union":
+        SUBRULE(groupOrUnionGraphPattern, ast);
+        break;
+      case "optional":
+        SUBRULE(optionalGraphPattern, ast);
+        break;
+      case "minus":
+        SUBRULE(minusGraphPattern, ast);
+        break;
+      case "graph":
+        SUBRULE(graphGraphPattern, ast);
+        break;
+      case "service":
+        SUBRULE(serviceGraphPattern, ast);
+        break;
+      case "filter":
+        SUBRULE(filter, ast);
+        break;
+      case "bind":
+        SUBRULE(bind, ast);
+        break;
+      case "values":
+        SUBRULE(inlineData, ast);
+        break;
+    }
+  }
+};
+const optionalGraphPattern = {
+  name: "optionalGraphPattern",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const optional = CONSUME(l.optional);
+    const group = SUBRULE(groupGraphPattern);
+    return ACTION(() => C.astFactory.patternOptional(group.patterns, C.astFactory.sourceLocation(optional, group)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD("OPTIONAL"));
+    SUBRULE(groupGraphPattern, F.patternGroup(ast.patterns, ast.loc));
+  }
+};
+const graphGraphPattern = {
+  name: "graphGraphPattern",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const graph = CONSUME(l.graph.graph);
+    const name = SUBRULE(import_general.varOrIri);
+    const group = SUBRULE(groupGraphPattern);
+    return ACTION(() => C.astFactory.patternGraph(name, group.patterns, C.astFactory.sourceLocation(graph, group)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD("GRAPH"));
+    SUBRULE(import_general.varOrTerm, ast.name);
+    SUBRULE(groupGraphPattern, F.patternGroup(ast.patterns, ast.loc));
+  }
+};
+const serviceGraphPattern = {
+  name: "serviceGraphPattern",
+  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
+    const service = CONSUME(l.service);
+    const silent = OPTION(() => {
+      CONSUME(l.silent);
+      return true;
+    }) ?? false;
+    const name = SUBRULE1(import_general.varOrIri);
+    const group = SUBRULE1(groupGraphPattern);
+    return ACTION(() => C.astFactory.patternService(name, group.patterns, silent, C.astFactory.sourceLocation(service, group)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_WORD("SERVICE");
+      if (ast.silent) {
+        PRINT_WORD("SILENT");
+      }
+    });
+    SUBRULE(import_general.varOrTerm, ast.name);
+    SUBRULE(groupGraphPattern, F.patternGroup(ast.patterns, ast.loc));
+  }
+};
+const bind = {
+  name: "bind",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const bind2 = CONSUME(l.bind);
+    CONSUME(l.symbols.LParen);
+    const expressionVal = SUBRULE(import_expression.expression);
+    CONSUME(l.as);
+    const variable = SUBRULE(import_general.var_);
+    const close = CONSUME(l.symbols.RParen);
+    return ACTION(() => C.astFactory.patternBind(expressionVal, variable, C.astFactory.sourceLocation(bind2, close)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD("BIND", "("));
+    SUBRULE(import_expression.expression, ast.expression);
+    F.printFilter(ast, () => PRINT_WORD("AS"));
+    SUBRULE(import_general.var_, ast.variable);
+    F.printFilter(ast, () => {
+      PRINT_WORD(")");
+      NEW_LINE();
+    });
+  }
+};
+const inlineData = {
+  name: "inlineData",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const values = CONSUME(l.values);
+    const datablock = SUBRULE(dataBlock);
+    return ACTION(() => {
+      datablock.loc = C.astFactory.sourceLocation(values, datablock);
+      return datablock;
+    });
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY, NEW_LINE, PRINT_ON_OWN_LINE }) => (ast, C) => {
+    const { astFactory: F, indentInc } = C;
+    const variables = ast.variables;
+    const singleVar = variables.length === 1;
+    F.printFilter(ast, () => {
+      PRINT_ON_EMPTY("VALUES", singleVar ? "" : "( ");
+    });
+    for (const variable of variables) {
+      F.printFilter(ast, () => PRINT_WORD(""));
+      SUBRULE(import_general.varOrTerm, variable);
+      F.printFilter(ast, () => PRINT_WORD(""));
+    }
+    F.printFilter(ast, () => {
+      C[import_core.traqulaIndentation] += indentInc;
+      PRINT_WORD(singleVar ? "" : ")", "{");
+      NEW_LINE();
+    });
+    for (const mapping of ast.values) {
+      F.printFilter(ast, () => !singleVar && PRINT_WORD("("));
+      for (const variable of variables) {
+        const var_2 = variable.value;
+        if (mapping[var_2] === void 0) {
+          F.printFilter(ast, () => PRINT_WORD("UNDEF"));
+        } else {
+          SUBRULE(import_tripleBlock.graphNodePath, mapping[var_2]);
+        }
+      }
+      F.printFilter(ast, () => {
+        PRINT_WORD(singleVar ? "" : ")");
+        NEW_LINE();
+      });
+    }
+    F.printFilter(ast, () => {
+      C[import_core.traqulaIndentation] -= indentInc;
+      PRINT_ON_OWN_LINE("}");
+    });
+  }
+};
+const dataBlock = {
+  name: "dataBlock",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(inlineDataOneVar) },
+    { ALT: () => SUBRULE(inlineDataFull) }
+  ])
+};
+const inlineDataOneVar = {
+  name: "inlineDataOneVar",
+  impl: ({ ACTION, SUBRULE, CONSUME, MANY }) => (C) => {
+    const res = [];
+    const varVal = SUBRULE(import_general.var_);
+    CONSUME(l.symbols.LCurly);
+    MANY(() => {
+      const value = SUBRULE(dataBlockValue);
+      ACTION(() => {
+        res.push({ [varVal.value]: value });
+      });
+    });
+    const close = CONSUME(l.symbols.RCurly);
+    return ACTION(() => C.astFactory.patternValues([varVal], res, C.astFactory.sourceLocation(varVal, close)));
+  }
+};
+const inlineDataFull = {
+  name: "inlineDataFull",
+  impl: ({ ACTION, OR, MANY1, MANY2, MANY3, MANY4, SUBRULE, CONSUME1, CONSUME2 }) => (C) => {
+    const res = [];
+    const vars = [];
+    return OR([
+      { ALT: () => {
+        const nil = CONSUME1(l.terminals.nil);
+        CONSUME1(l.symbols.LCurly);
+        MANY1(() => {
+          CONSUME2(l.terminals.nil);
+          res.push({});
+        });
+        const close = CONSUME1(l.symbols.RCurly);
+        return ACTION(() => C.astFactory.patternValues(vars, res, C.astFactory.sourceLocation(nil, close)));
+      } },
+      { ALT: () => {
+        const open = CONSUME1(l.symbols.LParen);
+        MANY2(() => {
+          vars.push(SUBRULE(import_general.var_));
+        });
+        CONSUME1(l.symbols.RParen);
+        CONSUME2(l.symbols.LCurly);
+        MANY3(() => {
+          let parsedValues = 0;
+          const currentRow = {};
+          CONSUME2(l.symbols.LParen);
+          MANY4(() => {
+            if (parsedValues >= vars.length) {
+              throw new Error("Number of dataBlockValues does not match number of variables. Too much values.");
+            }
+            const value = SUBRULE(dataBlockValue);
+            ACTION(() => {
+              currentRow[vars[parsedValues].value] = value;
+              parsedValues++;
+            });
+          });
+          CONSUME2(l.symbols.RParen);
+          ACTION(() => {
+            res.push(currentRow);
+            if (vars.length !== parsedValues) {
+              throw new Error("Number of dataBlockValues does not match number of variables. Too few values.");
+            }
+          });
+        });
+        const close = CONSUME2(l.symbols.RCurly);
+        return ACTION(() => C.astFactory.patternValues(vars, res, C.astFactory.sourceLocation(open, close)));
+      } }
+    ]);
+  }
+};
+const dataBlockValue = {
+  name: "dataBlockValue",
+  impl: ({ SUBRULE, CONSUME, OR }) => () => OR([
+    { ALT: () => SUBRULE(import_literals.iri) },
+    { ALT: () => SUBRULE(import_literals.rdfLiteral) },
+    { ALT: () => SUBRULE(import_literals.numericLiteral) },
+    { ALT: () => SUBRULE(import_literals.booleanLiteral) },
+    { ALT: () => {
+      CONSUME(l.undef);
+      return void 0;
+    } }
+  ])
+};
+const minusGraphPattern = {
+  name: "minusGraphPattern",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const minus = CONSUME(l.minus);
+    const group = SUBRULE(groupGraphPattern);
+    return ACTION(() => C.astFactory.patternMinus(group.patterns, C.astFactory.sourceLocation(minus, group)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD("MINUS"));
+    SUBRULE(groupGraphPattern, F.patternGroup(ast.patterns, ast.loc));
+  }
+};
+const groupOrUnionGraphPattern = {
+  name: "groupOrUnionGraphPattern",
+  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => {
+    const groups = [];
+    const group = SUBRULE1(groupGraphPattern);
+    groups.push(group);
+    MANY(() => {
+      CONSUME(l.union);
+      const group2 = SUBRULE2(groupGraphPattern);
+      groups.push(group2);
+    });
+    return ACTION(() => groups.length === 1 ? groups[0] : C.astFactory.patternUnion(groups, C.astFactory.sourceLocation(group, groups.at(-1))));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    if (F.isPatternUnion(ast)) {
+      const [head, ...tail] = ast.patterns;
+      SUBRULE(groupGraphPattern, head);
+      for (const pattern of tail) {
+        F.printFilter(ast, () => PRINT_WORD("UNION"));
+        SUBRULE(groupGraphPattern, pattern);
+      }
+    } else {
+      SUBRULE(groupGraphPattern, ast);
+    }
+  }
+};
+const filter = {
+  name: "filter",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const filterToken = CONSUME(l.filter);
+    const expression2 = SUBRULE(constraint);
+    return ACTION(() => C.astFactory.patternFilter(expression2, C.astFactory.sourceLocation(filterToken, expression2)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD("FILTER ("));
+    SUBRULE(import_expression.expression, ast.expression);
+    F.printFilter(ast, () => {
+      PRINT_WORD(")");
+      NEW_LINE();
+    });
+  }
+};
+const constraint = {
+  name: "constraint",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(import_expression.brackettedExpression) },
+    { ALT: () => SUBRULE(import_builtIn.builtInCall) },
+    { ALT: () => SUBRULE(functionCall) }
+  ])
+};
+const functionCall = {
+  name: "functionCall",
+  impl: ({ ACTION, SUBRULE }) => (C) => {
+    const func = SUBRULE(import_literals.iri);
+    const args = SUBRULE(import_expression.argList);
+    return ACTION(() => C.astFactory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.astFactory.sourceLocation(func, args)));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bind,
+  constraint,
+  dataBlock,
+  dataBlockValue,
+  filter,
+  functionCall,
+  generatePattern,
+  graphGraphPattern,
+  graphPatternNotTriples,
+  groupGraphPattern,
+  groupGraphPatternSub,
+  groupOrUnionGraphPattern,
+  inlineData,
+  inlineDataFull,
+  inlineDataOneVar,
+  minusGraphPattern,
+  optionalGraphPattern,
+  serviceGraphPattern,
+  whereClause
+});

package/dist/cjs/lib/index.js

@@ -0,0 +1,56 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 index_exports = {};
+__export(index_exports, {
+  gram: () => gram,
+  lex: () => lex
+});
+module.exports = __toCommonJS(index_exports);
+var gram = __toESM(require("./grammar/index.js"), 1);
+var lex = __toESM(require("./lexer/index.js"), 1);
+__reExport(index_exports, require("./expressionHelpers.js"), module.exports);
+__reExport(index_exports, require("./Sparql11types.js"), module.exports);
+__reExport(index_exports, require("./MinimalSparqlParser.js"), module.exports);
+__reExport(index_exports, require("./sparql11HelperTypes.js"), module.exports);
+__reExport(index_exports, require("./astFactory.js"), module.exports);
+__reExport(index_exports, require("./validation/validators.js"), module.exports);
+__reExport(index_exports, require("./utils.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gram,
+  lex,
+  ...require("./expressionHelpers.js"),
+  ...require("./Sparql11types.js"),
+  ...require("./MinimalSparqlParser.js"),
+  ...require("./sparql11HelperTypes.js"),
+  ...require("./astFactory.js"),
+  ...require("./validation/validators.js"),
+  ...require("./utils.js")
+});