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

package/dist/cjs/lib/factoryMixins/PathFactory.js

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PathFactory_exports = {};
+__export(PathFactory_exports, {
+  PathFactoryMixin: () => PathFactoryMixin
+});
+module.exports = __toCommonJS(PathFactory_exports);
+const nodeType = "path";
+function PathFactoryMixin(Base) {
+  return class PathFactory extends Base {
+    isPathPure(obj) {
+      return this.isOfType(obj, nodeType);
+    }
+    path(subType, items, loc) {
+      const base = {
+        type: nodeType,
+        loc,
+        items
+      };
+      if (subType === "|" || subType === "/") {
+        return {
+          ...base,
+          subType
+        };
+      }
+      if ((subType === "?" || subType === "*" || subType === "+" || subType === "^") && items.length === 1) {
+        return {
+          ...base,
+          subType,
+          items
+        };
+      }
+      if (subType === "^" && items.length === 1 && !this.isPathPure(items[0])) {
+        return {
+          ...base,
+          subType,
+          items
+        };
+      }
+      if (subType === "!" && items.length === 1 && (this.isPathAlternativeLimited(items[0]) || !this.isPathPure(items[0]) || this.isPathNegatedElt(items[0]))) {
+        return {
+          ...base,
+          subType,
+          items
+        };
+      }
+      throw new Error("Invalid path type");
+    }
+    isPathOfType(obj, subTypes) {
+      return this.isOfType(obj, nodeType) && subTypes.includes(obj.subType);
+    }
+    isPathChain(obj) {
+      return this.isOfSubType(obj, nodeType, "/") || this.isOfSubType(obj, nodeType, "|");
+    }
+    isPathModified(obj) {
+      return this.isOfSubType(obj, nodeType, "?") || this.isOfSubType(obj, nodeType, "*") || this.isOfSubType(obj, nodeType, "+") || this.isOfSubType(obj, nodeType, "^");
+    }
+    isPathNegatedElt(obj) {
+      const casted = obj;
+      return this.isOfSubType(obj, nodeType, "^") && Array.isArray(casted.items) && casted.items.length === 1 && typeof casted.items[0] === "object" && (casted.items[0] ?? false) && !this.isPathPure(casted.items[0]);
+    }
+    isPathNegated(obj) {
+      return this.isOfSubType(obj, nodeType, "!");
+    }
+    isPathAlternativeLimited(obj) {
+      const casted = obj;
+      return this.isOfSubType(obj, nodeType, "|") && Array.isArray(casted.items) && casted.items.every((item) => !this.isPathPure(item) || this.isPathNegatedElt(item));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PathFactoryMixin
+});

package/dist/cjs/lib/factoryMixins/Patternfactory.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Patternfactory_exports = {};
+__export(Patternfactory_exports, {
+  PatternFactoryMixin: () => PatternFactoryMixin
+});
+module.exports = __toCommonJS(Patternfactory_exports);
+const nodeType = "pattern";
+function PatternFactoryMixin(Base) {
+  return class PatternFactory extends Base {
+    isPattern(obj) {
+      return this.isOfType(obj, nodeType);
+    }
+    patternBgp(triples, loc) {
+      return { type: nodeType, subType: "bgp", triples, loc };
+    }
+    isPatternBgp(obj) {
+      return this.isOfSubType(obj, nodeType, "bgp");
+    }
+    patternGroup(patterns, loc) {
+      return { type: nodeType, subType: "group", patterns, loc };
+    }
+    isPatternGroup(obj) {
+      return this.isOfSubType(obj, nodeType, "group");
+    }
+    patternGraph(name, patterns, loc) {
+      return { type: nodeType, subType: "graph", name, patterns, loc };
+    }
+    isPatternGraph(obj) {
+      return this.isOfSubType(obj, nodeType, "graph");
+    }
+    patternOptional(patterns, loc) {
+      return { type: nodeType, subType: "optional", patterns, loc };
+    }
+    isPatternOptional(obj) {
+      return this.isOfSubType(obj, nodeType, "optional");
+    }
+    patternValues(variables, values, loc) {
+      return { type: nodeType, subType: "values", variables, values, loc };
+    }
+    isPatternValues(obj) {
+      return this.isOfSubType(obj, nodeType, "values");
+    }
+    patternFilter(expression, loc) {
+      return {
+        type: nodeType,
+        subType: "filter",
+        expression,
+        loc
+      };
+    }
+    isPatternFilter(obj) {
+      return this.isOfSubType(obj, nodeType, "filter");
+    }
+    patternBind(expression, variable, loc) {
+      return {
+        type: nodeType,
+        subType: "bind",
+        expression,
+        variable,
+        loc
+      };
+    }
+    isPatternBind(obj) {
+      return this.isOfSubType(obj, nodeType, "bind");
+    }
+    patternUnion(patterns, loc) {
+      return {
+        type: nodeType,
+        subType: "union",
+        patterns,
+        loc
+      };
+    }
+    isPatternUnion(obj) {
+      return this.isOfSubType(obj, nodeType, "union");
+    }
+    patternMinus(patterns, loc) {
+      return {
+        type: nodeType,
+        subType: "minus",
+        patterns,
+        loc
+      };
+    }
+    isPatternMinus(obj) {
+      return this.isOfSubType(obj, nodeType, "minus");
+    }
+    patternService(name, patterns, silent, loc) {
+      return {
+        type: nodeType,
+        subType: "service",
+        silent,
+        name,
+        patterns,
+        loc
+      };
+    }
+    isPatternService(obj) {
+      return this.isOfSubType(obj, nodeType, "service");
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PatternFactoryMixin
+});

package/dist/cjs/lib/factoryMixins/QueryFactory.js

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var QueryFactory_exports = {};
+__export(QueryFactory_exports, {
+  QueryFactoryMixin: () => QueryFactoryMixin
+});
+module.exports = __toCommonJS(QueryFactory_exports);
+const nodeType = "query";
+function QueryFactoryMixin(Base) {
+  return class QueryFactory extends Base {
+    isQuery(obj) {
+      return this.isOfType(obj, nodeType);
+    }
+    isQuerySelect(obj) {
+      return this.isOfSubType(obj, nodeType, "select");
+    }
+    queryConstruct(loc, context, template, where, solutionModifiers, datasets, values) {
+      return {
+        type: "query",
+        subType: "construct",
+        context,
+        template,
+        where,
+        solutionModifiers,
+        datasets,
+        values,
+        loc
+      };
+    }
+    isQueryConstruct(obj) {
+      return this.isOfSubType(obj, nodeType, "construct");
+    }
+    isQueryDescribe(obj) {
+      return this.isOfSubType(obj, nodeType, "describe");
+    }
+    isQueryAsk(obj) {
+      return this.isOfSubType(obj, nodeType, "ask");
+    }
+    querySelect(arg, loc) {
+      return {
+        type: nodeType,
+        subType: "select",
+        ...arg,
+        loc
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueryFactoryMixin
+});

package/dist/cjs/lib/factoryMixins/SolutionModifiersFactory.js

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SolutionModifiersFactory_exports = {};
+__export(SolutionModifiersFactory_exports, {
+  SolutionModifiersFactoryMixin: () => SolutionModifiersFactoryMixin
+});
+module.exports = __toCommonJS(SolutionModifiersFactory_exports);
+const nodeType = "solutionModifier";
+function SolutionModifiersFactoryMixin(Base) {
+  return class SolutionModifiersFactory extends Base {
+    isSolutionModifier(obj) {
+      return this.isOfType(obj, nodeType);
+    }
+    solutionModifierHaving(having, loc) {
+      return {
+        type: nodeType,
+        subType: "having",
+        having,
+        loc
+      };
+    }
+    isSolutionModifierHaving(obj) {
+      return this.isOfSubType(obj, nodeType, "having");
+    }
+    solutionModifierOrder(orderDefs, loc) {
+      return {
+        type: nodeType,
+        subType: "order",
+        orderDefs,
+        loc
+      };
+    }
+    isSolutionModifierOrder(obj) {
+      return this.isOfSubType(obj, nodeType, "order");
+    }
+    solutionModifierLimitOffset(limit, offset, loc) {
+      return {
+        type: nodeType,
+        subType: "limitOffset",
+        limit,
+        offset,
+        loc
+      };
+    }
+    isSolutionModifierLimitOffset(obj) {
+      return this.isOfSubType(obj, nodeType, "limitOffset");
+    }
+    solutionModifierGroup(groupings, loc) {
+      return {
+        type: "solutionModifier",
+        subType: "group",
+        groupings,
+        loc
+      };
+    }
+    isSolutionModifierGroup(obj) {
+      return this.isOfSubType(obj, nodeType, "group");
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SolutionModifiersFactoryMixin
+});

package/dist/cjs/lib/factoryMixins/TermFactory.js

@@ -0,0 +1,105 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TermFactory_exports = {};
+__export(TermFactory_exports, {
+  TermFactoryMixin: () => TermFactoryMixin
+});
+module.exports = __toCommonJS(TermFactory_exports);
+const nodeType = "term";
+function TermFactoryMixin(Base) {
+  return class TermFactory extends Base {
+    __blankNodeCounter = 0;
+    resetBlankNodeCounter() {
+      this.__blankNodeCounter = 0;
+    }
+    isTerm(x) {
+      return this.isOfType(x, "term");
+    }
+    termBlank(label, loc) {
+      const base = {
+        type: "term",
+        subType: "blankNode",
+        loc
+      };
+      if (label === void 0) {
+        return { ...base, label: `g_${this.__blankNodeCounter++}` };
+      }
+      return { ...base, label: `e_${label}` };
+    }
+    isTermBlank(obj) {
+      return this.isOfSubType(obj, nodeType, "blankNode");
+    }
+    termLiteral(loc, value, langOrIri) {
+      return {
+        type: nodeType,
+        subType: "literal",
+        value,
+        langOrIri,
+        loc
+      };
+    }
+    isTermLiteral(obj) {
+      return this.isOfSubType(obj, nodeType, "literal");
+    }
+    isTermLiteralLangStr(obj) {
+      return this.isTermLiteral(obj) && typeof obj.langOrIri === "string";
+    }
+    isTermLiteralStr(obj) {
+      return this.isTermLiteral(obj) && typeof obj.langOrIri === "undefined";
+    }
+    isTermLiteralTyped(obj) {
+      const casted = obj;
+      return this.isTermLiteral(obj) && typeof casted.langOrIri === "object" && casted.langOrIri !== null && this.isTermNamed(casted.langOrIri);
+    }
+    termVariable(value, loc) {
+      return {
+        type: nodeType,
+        subType: "variable",
+        value,
+        loc
+      };
+    }
+    isTermVariable(obj) {
+      return this.isOfSubType(obj, nodeType, "variable");
+    }
+    termNamed(loc, value, prefix) {
+      const base = {
+        type: nodeType,
+        subType: "namedNode",
+        value,
+        loc
+      };
+      if (prefix === void 0) {
+        return base;
+      }
+      return { ...base, prefix };
+    }
+    isTermNamed(obj) {
+      return this.isOfSubType(obj, nodeType, "namedNode");
+    }
+    isTermNamedPrefixed(obj) {
+      const casted = obj;
+      return this.isTermNamed(obj) && typeof casted.prefix === "string";
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TermFactoryMixin
+});

package/dist/cjs/lib/factoryMixins/UpdateOperationFactory.js

@@ -0,0 +1,150 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var UpdateOperationFactory_exports = {};
+__export(UpdateOperationFactory_exports, {
+  UpdateOperationFactoryMixin: () => UpdateOperationFactoryMixin
+});
+module.exports = __toCommonJS(UpdateOperationFactory_exports);
+const nodeType = "updateOperation";
+function UpdateOperationFactoryMixin(Base) {
+  return class UpdateOperationFactory extends Base {
+    isUpdateOperation(obj) {
+      return this.isOfType(obj, nodeType);
+    }
+    updateOperationLoad(loc, source, silent, destination) {
+      return {
+        type: nodeType,
+        subType: "load",
+        silent,
+        source,
+        ...destination && { destination },
+        loc
+      };
+    }
+    isUpdateOperationLoad(obj) {
+      return this.isOfSubType(obj, nodeType, "load");
+    }
+    updateOperationClearDrop(subType, silent, destination, loc) {
+      return {
+        type: "updateOperation",
+        subType,
+        silent,
+        destination,
+        loc
+      };
+    }
+    updateOperationClear(destination, silent, loc) {
+      return this.updateOperationClearDrop("clear", silent, destination, loc);
+    }
+    isUpdateOperationClear(obj) {
+      return this.isOfSubType(obj, nodeType, "clear");
+    }
+    updateOperationDrop(destination, silent, loc) {
+      return this.updateOperationClearDrop("drop", silent, destination, loc);
+    }
+    isUpdateOperationDrop(obj) {
+      return this.isOfSubType(obj, nodeType, "drop");
+    }
+    updateOperationCreate(destination, silent, loc) {
+      return {
+        type: "updateOperation",
+        subType: "create",
+        silent,
+        destination,
+        loc
+      };
+    }
+    isUpdateOperationCreate(obj) {
+      return this.isOfSubType(obj, nodeType, "create");
+    }
+    updateOperationAddMoveCopy(subType, source, destination, silent, loc) {
+      return {
+        type: "updateOperation",
+        subType,
+        silent,
+        source,
+        destination,
+        loc
+      };
+    }
+    updateOperationAdd(source, destination, silent, loc) {
+      return this.updateOperationAddMoveCopy("add", source, destination, silent, loc);
+    }
+    isUpdateOperationAdd(obj) {
+      return this.isOfSubType(obj, nodeType, "add");
+    }
+    updateOperationMove(source, destination, silent, loc) {
+      return this.updateOperationAddMoveCopy("move", source, destination, silent, loc);
+    }
+    isUpdateOperationMove(obj) {
+      return this.isOfSubType(obj, nodeType, "move");
+    }
+    updateOperationCopy(source, destination, silent, loc) {
+      return this.updateOperationAddMoveCopy("copy", source, destination, silent, loc);
+    }
+    isUpdateOperationCopy(obj) {
+      return this.isOfSubType(obj, nodeType, "copy");
+    }
+    updateOperationInsDelDataWhere(subType, data, loc) {
+      return {
+        type: "updateOperation",
+        subType,
+        data,
+        loc
+      };
+    }
+    updateOperationInsertData(data, loc) {
+      return this.updateOperationInsDelDataWhere("insertdata", data, loc);
+    }
+    isUpdateOperationInsertData(obj) {
+      return this.isOfSubType(obj, nodeType, "insertdata");
+    }
+    updateOperationDeleteData(data, loc) {
+      return this.updateOperationInsDelDataWhere("deletedata", data, loc);
+    }
+    isUpdateOperationDeleteData(obj) {
+      return this.isOfSubType(obj, nodeType, "deletedata");
+    }
+    updateOperationDeleteWhere(data, loc) {
+      return this.updateOperationInsDelDataWhere("deletewhere", data, loc);
+    }
+    isUpdateOperationDeleteWhere(obj) {
+      return this.isOfSubType(obj, nodeType, "deletewhere");
+    }
+    updateOperationModify(loc, insert, del, where, from, graph) {
+      return {
+        type: "updateOperation",
+        subType: "modify",
+        insert: insert ?? [],
+        delete: del ?? [],
+        graph,
+        where,
+        from,
+        loc
+      };
+    }
+    isUpdateOperationModify(obj) {
+      return this.isOfSubType(obj, nodeType, "modify");
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UpdateOperationFactoryMixin
+});

package/dist/cjs/lib/factoryMixins/mixins.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mixins_exports = {};
+__export(mixins_exports, {
+  asArg: () => asArg
+});
+module.exports = __toCommonJS(mixins_exports);
+function asArg(arg) {
+  return new FlatCall(arg);
+}
+class FlatCall {
+  input;
+  constructor(input) {
+    this.input = input;
+  }
+  call(func) {
+    this.input = func(this.input);
+    return this;
+  }
+  returns() {
+    return this.input;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asArg
+});