@traqula/generator-sparql-1-1 0.0.10 → 0.0.13

package/lib/index.cjs

@@ -9675,58 +9675,115 @@ function createToken2(config) {
   return createToken(config);
 }
 
-// ../../packages/core/lib/Transformer.ts
-var Transformer = class {
-  transformNode(curObject, searchType, patch) {
-    const copy3 = { ...curObject };
-    for (const [key, value] of Object.entries(copy3)) {
-      copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, searchType, patch));
-    }
-    if (copy3.type === searchType) {
-      return patch(copy3);
+// ../../packages/core/lib/Transformers.ts
+var TransformerType = class {
+  safeObjectVisit(value, mapper) {
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        return value.map((x) => this.safeObjectVisit(x, mapper));
+      }
+      return mapper(value);
     }
-    return copy3;
+    return value;
   }
-  transformNodeSpecific(curObject, searchType, searchSubType, patch) {
+  transformNode(curObject, nodeCallBacks) {
+    let continueCheck;
+    let transformation;
+    const casted = curObject;
+    if (casted.type) {
+      continueCheck = nodeCallBacks[casted.type]?.continue;
+      transformation = nodeCallBacks[casted.type]?.transform;
+    }
+    let shouldContinue = true;
+    if (continueCheck) {
+      shouldContinue = continueCheck(curObject);
+    }
+    if (!shouldContinue) {
+      return curObject;
+    }
     const copy3 = { ...curObject };
     for (const [key, value] of Object.entries(copy3)) {
-      copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, searchType, searchSubType, patch));
+      copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, nodeCallBacks));
     }
-    if (copy3.type === searchType && copy3.subType === searchSubType) {
-      return patch(copy3);
+    if (transformation) {
+      return transformation(copy3);
     }
     return copy3;
   }
-  visitObjects(curObject, visitor) {
-    for (const value of Object.values(curObject)) {
-      this.safeObjectVisit(value, (obj) => this.visitObjects(obj, visitor));
+  visitNode(curObject, nodeCallBacks) {
+    let callback;
+    const casted = curObject;
+    if (casted.type) {
+      callback = nodeCallBacks[casted.type];
     }
-  }
-  visitNode(curObject, searchType, visitor) {
-    for (const value of Object.values(curObject)) {
-      this.safeObjectVisit(value, (obj) => this.visitNode(obj, searchType, visitor));
+    let shouldIterate = true;
+    if (callback) {
+      shouldIterate = callback(curObject);
     }
-    if (curObject.type === searchType) {
-      visitor(curObject);
+    if (shouldIterate) {
+      for (const value of Object.values(curObject)) {
+        this.safeObjectVisit(value, (obj) => this.visitNode(obj, nodeCallBacks));
+      }
     }
   }
-  visitNodeSpecific(curObject, searchType, searchSubType, visitor) {
-    for (const value of Object.values(curObject)) {
-      this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, searchType, searchSubType, visitor));
+};
+var TransformerSubType = class extends TransformerType {
+  // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
+  //   for (const value of Object.values(curObject)) {
+  //     this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
+  //   }
+  // }
+  transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
+    let continueCheck;
+    let transformation;
+    const casted = curObject;
+    if (casted.type && casted.subType) {
+      const specific = nodeSpecificCallBacks[casted.type];
+      if (specific) {
+        continueCheck = specific[casted.subType]?.continue;
+        transformation = specific[casted.subType]?.transform;
+      }
+    }
+    let shouldContinue = true;
+    if (continueCheck) {
+      shouldContinue = continueCheck(curObject);
+    }
+    if (!shouldContinue) {
+      return curObject;
+    }
+    const copy3 = { ...curObject };
+    for (const [key, value] of Object.entries(copy3)) {
+      copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
     }
-    const cast = curObject;
-    if (cast.type === searchType && cast.subType === searchSubType) {
-      visitor(curObject);
+    if (transformation) {
+      return transformation(copy3);
     }
+    return copy3;
   }
-  safeObjectVisit(value, mapper) {
-    if (value && typeof value === "object") {
-      if (Array.isArray(value)) {
-        return value.map((x) => this.safeObjectVisit(x, mapper));
+  /**
+   * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
+   */
+  visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
+    let callback;
+    const casted = curObject;
+    if (casted.type && casted.subType) {
+      const specific = nodeSpecificCallBacks[casted.type];
+      if (specific) {
+        callback = specific[casted.subType];
+      }
+    }
+    if (!callback && casted.type) {
+      callback = nodeCallBacks[curObject.type];
+    }
+    let shouldIterate = true;
+    if (callback) {
+      shouldIterate = callback(curObject) ?? true;
+    }
+    if (shouldIterate) {
+      for (const value of Object.values(curObject)) {
+        this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
       }
-      return mapper(value);
     }
-    return value;
   }
 };
 
@@ -11317,9 +11374,13 @@ var Factory = class extends asArg(CoreFactory).call(ContextFactoryMixin).call(Ex
   }
 };
 
+// ../../packages/rules-sparql-1-1/lib/utils.ts
+var TransformerSparql11 = class extends TransformerSubType {
+};
+
 // ../../packages/rules-sparql-1-1/lib/validation/validators.ts
 var F = new Factory();
-var transformer = new Transformer();
+var transformer = new TransformerSparql11();
 function getAggregatesOfExpression(expression2) {
   if (F.isExpressionAggregate(expression2)) {
     return [expression2];
@@ -11468,7 +11529,9 @@ function checkNote13(patterns) {
     if (F.isPatternBind(pattern) && index > 0 && F.isPatternBgp(patterns[index - 1])) {
       const bgp = patterns[index - 1];
       const variables = [];
-      transformer.visitNodeSpecific(bgp, "term", "variable", (var_2) => variables.push(var_2));
+      transformer.visitNodeSpecific(bgp, {}, { term: { variable: (var_2) => {
+        variables.push(var_2);
+      } } });
       if (variables.some((var_2) => var_2.value === pattern.variable.value)) {
         throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
       }
@@ -11494,12 +11557,12 @@ function updateNoReuseBlankNodeLabels(updateQuery) {
     const operation = update2.operation;
     if (operation.subType === "insertdata") {
       const blankNodesHere = /* @__PURE__ */ new Set();
-      transformer.visitNodeSpecific(operation, "term", "blankNode", (blankNode2) => {
+      transformer.visitNodeSpecific(operation, {}, { term: { blankNode: (blankNode2) => {
         blankNodesHere.add(blankNode2.label);
         if (blankLabelsUsedInInsertData.has(blankNode2.label)) {
           throw new Error("Detected reuse blank node across different INSERT DATA clauses");
         }
-      });
+      } } });
       for (const blankNode2 of blankNodesHere) {
         blankLabelsUsedInInsertData.add(blankNode2);
       }
@@ -13489,13 +13552,11 @@ var unaryExpression = {
         { ALT: () => CONSUME(symbols_exports.opMinus) }
       ]);
       const expr = SUBRULE2(primaryExpression);
-      return ACTION(() => ({
-        type: "expression",
-        subType: "operation",
-        operator: operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS",
-        args: [expr],
-        loc: C.factory.sourceLocation(operator, expr)
-      }));
+      return ACTION(() => C.factory.expressionOperation(
+        operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS",
+        [expr],
+        C.factory.sourceLocation(operator, expr)
+      ));
     } }
   ])
 };

package/lib/index.d.ts

@@ -3,28 +3,8 @@ import type * as T11 from '@traqula/rules-sparql-1-1';
 import { Factory } from '@traqula/rules-sparql-1-1';
 export declare const sparql11GeneratorBuilder: GeneratorBuilder<{
     factory: Factory;
-}, "expression" | "aggregate" | "graphRef" | "path" | "filter" | "bind" | "query" | "solutionModifier" | "blankNode" | "load" | "clear" | "drop" | "create" | "add" | "move" | "copy" | "modify" | "update" | "prologue" | "selectQuery" | "constructQuery" | "describeQuery" | "askQuery" | "baseDecl" | "prefixDecl" | "selectClause" | "whereClause" | "iriOrFunction" | "rdfLiteral" | "var" | "iri" | "prefixedName" | "argList" | "groupGraphPattern" | "triplesBlock" | "triplesNodePath" | "varOrTerm" | "iriFull" | "graphTerm" | "graphNodePath" | "collectionPath" | "blankNodePropertyListPath" | "graphPatternNotTriples" | "groupOrUnionGraphPattern" | "optionalGraphPattern" | "minusGraphPattern" | "graphGraphPattern" | "serviceGraphPattern" | "inlineData" | "groupClause" | "havingClause" | "orderClause" | "limitOffsetClauses" | "datasetClauses" | "insertData" | "deleteData" | "deleteWhere" | "graphRefAll" | "quads" | "update1" | "quadsNotTriples" | "usingClauses" | "queryOrUpdate" | "generatePattern", {
-    expression: import("@traqula/core").GeneratorRule<any, "expression"> & T11.SparqlGrammarRule<"expression", T11.Expression, []> & T11.SparqlGeneratorRule<"expression", T11.Expression, []>;
-    aggregate: import("@traqula/core").GeneratorRule<{
-        factory: Factory;
-    }, "aggregate", T11.ExpressionAggregate, []>;
-    graphRef: import("@traqula/core").GeneratorRule<any, "graphRef"> & T11.SparqlGrammarRule<"graphRef", T11.GraphRefSpecific, []> & T11.SparqlGeneratorRule<"graphRef", T11.GraphRefSpecific, []>;
-    path: import("@traqula/core").GeneratorRule<{
-        factory: Factory;
-    }, "path", T11.Path, [boolean | undefined]>;
-    filter: import("@traqula/core").GeneratorRule<any, "filter"> & T11.SparqlGrammarRule<"filter", T11.PatternFilter, []> & T11.SparqlGeneratorRule<"filter", T11.PatternFilter, []>;
-    bind: import("@traqula/core").GeneratorRule<any, "bind"> & T11.SparqlGrammarRule<"bind", T11.PatternBind, []> & T11.SparqlGeneratorRule<"bind", T11.PatternBind, []>;
+}, "query" | "update" | "prologue" | "selectQuery" | "constructQuery" | "describeQuery" | "askQuery" | "baseDecl" | "prefixDecl" | "selectClause" | "whereClause" | "solutionModifier" | "expression" | "iriOrFunction" | "rdfLiteral" | "var" | "aggregate" | "iri" | "prefixedName" | "argList" | "groupGraphPattern" | "triplesBlock" | "triplesNodePath" | "blankNode" | "path" | "varOrTerm" | "iriFull" | "graphTerm" | "graphNodePath" | "collectionPath" | "blankNodePropertyListPath" | "graphPatternNotTriples" | "filter" | "bind" | "groupOrUnionGraphPattern" | "optionalGraphPattern" | "minusGraphPattern" | "graphGraphPattern" | "serviceGraphPattern" | "inlineData" | "groupClause" | "havingClause" | "orderClause" | "limitOffsetClauses" | "datasetClauses" | "load" | "clear" | "drop" | "add" | "move" | "copy" | "create" | "insertData" | "deleteData" | "deleteWhere" | "graphRef" | "graphRefAll" | "quads" | "update1" | "quadsNotTriples" | "modify" | "usingClauses" | "queryOrUpdate" | "generatePattern", {
     query: import("@traqula/core").GeneratorRule<any, "query"> & T11.SparqlGrammarRule<"query", T11.Query, []> & T11.SparqlGeneratorRule<"query", T11.Query, []>;
-    solutionModifier: import("@traqula/core").GeneratorRule<any, "solutionModifier"> & T11.SparqlGrammarRule<"solutionModifier", T11.SolutionModifiers, []> & T11.SparqlGeneratorRule<"solutionModifier", T11.SolutionModifiers, []>;
-    blankNode: import("@traqula/core").GeneratorRule<any, "blankNode"> & T11.SparqlGrammarRule<"blankNode", T11.TermBlank, []> & T11.SparqlGeneratorRule<"blankNode", T11.TermBlank, []>;
-    load: import("@traqula/core").GeneratorRule<any, "load"> & T11.SparqlGrammarRule<"load", T11.UpdateOperationLoad, []> & T11.SparqlGeneratorRule<"load", T11.UpdateOperationLoad, []>;
-    clear: import("@traqula/core").GeneratorRule<any, "clear"> & T11.SparqlGrammarRule<"clear", T11.UpdateOperationClear | T11.UpdateOperationDrop, []> & T11.SparqlGeneratorRule<"clear", T11.UpdateOperationClear | T11.UpdateOperationDrop, []>;
-    drop: import("@traqula/core").GeneratorRule<any, "drop"> & T11.SparqlGrammarRule<"drop", T11.UpdateOperationClear | T11.UpdateOperationDrop, []> & T11.SparqlGeneratorRule<"drop", T11.UpdateOperationClear | T11.UpdateOperationDrop, []>;
-    create: import("@traqula/core").GeneratorRule<any, "create"> & T11.SparqlGrammarRule<"create", T11.UpdateOperationCreate, []> & T11.SparqlGeneratorRule<"create", T11.UpdateOperationCreate, []>;
-    add: import("@traqula/core").GeneratorRule<any, "add"> & T11.SparqlGrammarRule<"add", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"add", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
-    move: import("@traqula/core").GeneratorRule<any, "move"> & T11.SparqlGrammarRule<"move", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"move", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
-    copy: import("@traqula/core").GeneratorRule<any, "copy"> & T11.SparqlGrammarRule<"copy", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"copy", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
-    modify: import("@traqula/core").GeneratorRule<any, "modify"> & T11.SparqlGrammarRule<"modify", T11.UpdateOperationModify, []> & T11.SparqlGeneratorRule<"modify", T11.UpdateOperationModify, []>;
     update: import("@traqula/core").GeneratorRule<any, "update"> & T11.SparqlGrammarRule<"update", T11.Update, []> & T11.SparqlGeneratorRule<"update", T11.Update, []>;
     prologue: import("@traqula/core").GeneratorRule<any, "prologue"> & T11.SparqlGrammarRule<"prologue", T11.ContextDefinition[], []> & T11.SparqlGeneratorRule<"prologue", T11.ContextDefinition[], []>;
     selectQuery: import("@traqula/core").GeneratorRule<any, "selectQuery"> & T11.SparqlGrammarRule<"selectQuery", Omit<T11.QuerySelect, T11.gram.HandledByBase>, []> & T11.SparqlGeneratorRule<"selectQuery", Omit<T11.QuerySelect, T11.gram.HandledByBase>, []>;
@@ -35,22 +15,33 @@ export declare const sparql11GeneratorBuilder: GeneratorBuilder<{
     prefixDecl: import("@traqula/core").GeneratorRule<any, "prefixDecl"> & T11.SparqlGrammarRule<"prefixDecl", T11.ContextDefinitionPrefix, []> & T11.SparqlGeneratorRule<"prefixDecl", T11.ContextDefinitionPrefix, []>;
     selectClause: import("@traqula/core").GeneratorRule<any, "selectClause"> & T11.SparqlGrammarRule<"selectClause", import("@traqula/core").Wrap<Pick<T11.QuerySelect, "variables" | "distinct" | "reduced">>, []> & T11.SparqlGeneratorRule<"selectClause", import("@traqula/core").Wrap<Pick<T11.QuerySelect, "variables" | "distinct" | "reduced">>, []>;
     whereClause: import("@traqula/core").GeneratorRule<any, "whereClause"> & T11.SparqlGrammarRule<"whereClause", import("@traqula/core").Wrap<T11.PatternGroup>, []> & T11.SparqlGeneratorRule<"whereClause", import("@traqula/core").Wrap<T11.PatternGroup>, []>;
+    solutionModifier: import("@traqula/core").GeneratorRule<any, "solutionModifier"> & T11.SparqlGrammarRule<"solutionModifier", T11.SolutionModifiers, []> & T11.SparqlGeneratorRule<"solutionModifier", T11.SolutionModifiers, []>;
+    expression: import("@traqula/core").GeneratorRule<any, "expression"> & T11.SparqlGrammarRule<"expression", T11.Expression, []> & T11.SparqlGeneratorRule<"expression", T11.Expression, []>;
     iriOrFunction: import("@traqula/core").GeneratorRule<any, "iriOrFunction"> & T11.SparqlGrammarRule<"iriOrFunction", T11.ExpressionFunctionCall | T11.TermIri, []> & T11.SparqlGeneratorRule<"iriOrFunction", T11.ExpressionFunctionCall | T11.TermIri, []>;
     rdfLiteral: import("@traqula/core").GeneratorRule<any, "rdfLiteral"> & T11.SparqlGrammarRule<"rdfLiteral", T11.TermLiteral, []> & T11.SparqlGeneratorRule<"rdfLiteral", T11.TermLiteral, []>;
     var: import("@traqula/core").GeneratorRule<any, "var"> & T11.SparqlGrammarRule<"var", T11.TermVariable, []> & T11.SparqlGeneratorRule<"var", T11.TermVariable, []>;
+    aggregate: import("@traqula/core").GeneratorRule<{
+        factory: Factory;
+    }, "aggregate", T11.ExpressionAggregate, []>;
     iri: import("@traqula/core").GeneratorRule<any, "iri"> & T11.SparqlGrammarRule<"iri", T11.TermIri, []> & T11.SparqlGeneratorRule<"iri", T11.TermIri, []>;
     prefixedName: import("@traqula/core").GeneratorRule<any, "prefixedName"> & T11.SparqlGrammarRule<"prefixedName", T11.TermIriPrefixed, []> & T11.SparqlGeneratorRule<"prefixedName", T11.TermIriPrefixed, []>;
     argList: import("@traqula/core").GeneratorRule<any, "argList"> & T11.SparqlGrammarRule<"argList", import("@traqula/core").Wrap<T11.gram.IArgList>, []> & T11.SparqlGeneratorRule<"argList", import("@traqula/core").Wrap<T11.gram.IArgList>, []>;
     groupGraphPattern: import("@traqula/core").GeneratorRule<any, "groupGraphPattern"> & T11.SparqlGrammarRule<"groupGraphPattern", T11.PatternGroup, []> & T11.SparqlGeneratorRule<"groupGraphPattern", T11.PatternGroup, []>;
     triplesBlock: import("@traqula/core").GeneratorRule<any, "triplesBlock"> & T11.SparqlGrammarRule<"triplesBlock", T11.PatternBgp, []> & T11.SparqlGeneratorRule<"triplesBlock", T11.PatternBgp, []>;
     triplesNodePath: import("@traqula/core").GeneratorRule<any, "triplesNodePath"> & T11.SparqlGrammarRule<"triplesNodePath", T11.TripleCollection, []> & T11.SparqlGeneratorRule<"triplesNodePath", T11.TripleCollection, []>;
+    blankNode: import("@traqula/core").GeneratorRule<any, "blankNode"> & T11.SparqlGrammarRule<"blankNode", T11.TermBlank, []> & T11.SparqlGeneratorRule<"blankNode", T11.TermBlank, []>;
+    path: import("@traqula/core").GeneratorRule<{
+        factory: Factory;
+    }, "path", T11.Path, [boolean | undefined]>;
     varOrTerm: import("@traqula/core").GeneratorRule<any, "varOrTerm"> & T11.SparqlGrammarRule<"varOrTerm", T11.Term, []> & T11.SparqlGeneratorRule<"varOrTerm", T11.Term, []>;
     iriFull: import("@traqula/core").GeneratorRule<any, "iriFull"> & T11.SparqlGrammarRule<"iriFull", T11.TermIriFull, []> & T11.SparqlGeneratorRule<"iriFull", T11.TermIriFull, []>;
     graphTerm: import("@traqula/core").GeneratorRule<any, "graphTerm"> & T11.SparqlGrammarRule<"graphTerm", T11.GraphTerm, []> & T11.SparqlGeneratorRule<"graphTerm", T11.GraphTerm, []>;
     graphNodePath: import("@traqula/core").GeneratorRule<any, "graphNodePath"> & T11.SparqlGrammarRule<"graphNodePath", T11.Term | T11.TripleCollection, []> & T11.SparqlGeneratorRule<"graphNodePath", T11.Term | T11.TripleCollection, []>;
     collectionPath: import("@traqula/core").GeneratorRule<any, "collectionPath"> & T11.SparqlGrammarRule<"collectionPath", T11.TripleCollectionList, []> & T11.SparqlGeneratorRule<"collectionPath", T11.TripleCollectionList, []>;
     blankNodePropertyListPath: import("@traqula/core").GeneratorRule<any, "blankNodePropertyListPath"> & T11.SparqlGrammarRule<"blankNodePropertyListPath", T11.TripleCollectionBlankNodeProperties, []> & T11.SparqlGeneratorRule<"blankNodePropertyListPath", T11.TripleCollectionBlankNodeProperties, []>;
-    graphPatternNotTriples: import("@traqula/core").GeneratorRule<any, "graphPatternNotTriples"> & T11.SparqlGrammarRule<"graphPatternNotTriples", T11.PatternGroup | T11.PatternUnion | T11.PatternOptional | T11.PatternMinus | T11.PatternGraph | T11.PatternService | T11.PatternFilter | T11.PatternBind | T11.PatternValues, []> & T11.SparqlGeneratorRule<"graphPatternNotTriples", T11.PatternGroup | T11.PatternUnion | T11.PatternOptional | T11.PatternMinus | T11.PatternGraph | T11.PatternService | T11.PatternFilter | T11.PatternBind | T11.PatternValues, []>;
+    graphPatternNotTriples: import("@traqula/core").GeneratorRule<any, "graphPatternNotTriples"> & T11.SparqlGrammarRule<"graphPatternNotTriples", T11.PatternGroup | T11.PatternValues | T11.PatternUnion | T11.PatternOptional | T11.PatternMinus | T11.PatternGraph | T11.PatternService | T11.PatternFilter | T11.PatternBind, []> & T11.SparqlGeneratorRule<"graphPatternNotTriples", T11.PatternGroup | T11.PatternValues | T11.PatternUnion | T11.PatternOptional | T11.PatternMinus | T11.PatternGraph | T11.PatternService | T11.PatternFilter | T11.PatternBind, []>;
+    filter: import("@traqula/core").GeneratorRule<any, "filter"> & T11.SparqlGrammarRule<"filter", T11.PatternFilter, []> & T11.SparqlGeneratorRule<"filter", T11.PatternFilter, []>;
+    bind: import("@traqula/core").GeneratorRule<any, "bind"> & T11.SparqlGrammarRule<"bind", T11.PatternBind, []> & T11.SparqlGeneratorRule<"bind", T11.PatternBind, []>;
     groupOrUnionGraphPattern: import("@traqula/core").GeneratorRule<any, "groupOrUnionGraphPattern"> & T11.SparqlGrammarRule<"groupOrUnionGraphPattern", T11.PatternGroup | T11.PatternUnion, []> & T11.SparqlGeneratorRule<"groupOrUnionGraphPattern", T11.PatternGroup | T11.PatternUnion, []>;
     optionalGraphPattern: import("@traqula/core").GeneratorRule<any, "optionalGraphPattern"> & T11.SparqlGrammarRule<"optionalGraphPattern", T11.PatternOptional, []> & T11.SparqlGeneratorRule<"optionalGraphPattern", T11.PatternOptional, []>;
     minusGraphPattern: import("@traqula/core").GeneratorRule<any, "minusGraphPattern"> & T11.SparqlGrammarRule<"minusGraphPattern", T11.PatternMinus, []> & T11.SparqlGeneratorRule<"minusGraphPattern", T11.PatternMinus, []>;
@@ -62,13 +53,22 @@ export declare const sparql11GeneratorBuilder: GeneratorBuilder<{
     orderClause: import("@traqula/core").GeneratorRule<any, "orderClause"> & T11.SparqlGrammarRule<"orderClause", T11.SolutionModifierOrder, []> & T11.SparqlGeneratorRule<"orderClause", T11.SolutionModifierOrder, []>;
     limitOffsetClauses: import("@traqula/core").GeneratorRule<any, "limitOffsetClauses"> & T11.SparqlGrammarRule<"limitOffsetClauses", T11.SolutionModifierLimitOffset, []> & T11.SparqlGeneratorRule<"limitOffsetClauses", T11.SolutionModifierLimitOffset, []>;
     datasetClauses: import("@traqula/core").GeneratorRule<any, "datasetClauses"> & T11.SparqlGrammarRule<"datasetClauses", T11.DatasetClauses, []> & T11.SparqlGeneratorRule<"datasetClauses", T11.DatasetClauses, []>;
+    load: import("@traqula/core").GeneratorRule<any, "load"> & T11.SparqlGrammarRule<"load", T11.UpdateOperationLoad, []> & T11.SparqlGeneratorRule<"load", T11.UpdateOperationLoad, []>;
+    clear: import("@traqula/core").GeneratorRule<any, "clear"> & T11.SparqlGrammarRule<"clear", T11.UpdateOperationClear | T11.UpdateOperationDrop, []> & T11.SparqlGeneratorRule<"clear", T11.UpdateOperationClear | T11.UpdateOperationDrop, []>;
+    drop: import("@traqula/core").GeneratorRule<any, "drop"> & T11.SparqlGrammarRule<"drop", T11.UpdateOperationClear | T11.UpdateOperationDrop, []> & T11.SparqlGeneratorRule<"drop", T11.UpdateOperationClear | T11.UpdateOperationDrop, []>;
+    add: import("@traqula/core").GeneratorRule<any, "add"> & T11.SparqlGrammarRule<"add", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"add", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
+    move: import("@traqula/core").GeneratorRule<any, "move"> & T11.SparqlGrammarRule<"move", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"move", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
+    copy: import("@traqula/core").GeneratorRule<any, "copy"> & T11.SparqlGrammarRule<"copy", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []> & T11.SparqlGeneratorRule<"copy", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, []>;
+    create: import("@traqula/core").GeneratorRule<any, "create"> & T11.SparqlGrammarRule<"create", T11.UpdateOperationCreate, []> & T11.SparqlGeneratorRule<"create", T11.UpdateOperationCreate, []>;
     insertData: import("@traqula/core").GeneratorRule<any, "insertData"> & T11.SparqlGrammarRule<"insertData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []> & T11.SparqlGeneratorRule<"insertData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []>;
     deleteData: import("@traqula/core").GeneratorRule<any, "deleteData"> & T11.SparqlGrammarRule<"deleteData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []> & T11.SparqlGeneratorRule<"deleteData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []>;
     deleteWhere: import("@traqula/core").GeneratorRule<any, "deleteWhere"> & T11.SparqlGrammarRule<"deleteWhere", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []> & T11.SparqlGeneratorRule<"deleteWhere", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, []>;
+    graphRef: import("@traqula/core").GeneratorRule<any, "graphRef"> & T11.SparqlGrammarRule<"graphRef", T11.GraphRefSpecific, []> & T11.SparqlGeneratorRule<"graphRef", T11.GraphRefSpecific, []>;
     graphRefAll: import("@traqula/core").GeneratorRule<any, "graphRefAll"> & T11.SparqlGrammarRule<"graphRefAll", T11.GraphRef, []> & T11.SparqlGeneratorRule<"graphRefAll", T11.GraphRef, []>;
     quads: import("@traqula/core").GeneratorRule<any, "quads"> & T11.SparqlGrammarRule<"quads", import("@traqula/core").Wrap<T11.Quads[]>, []> & T11.SparqlGeneratorRule<"quads", import("@traqula/core").Wrap<T11.Quads[]>, []>;
     update1: import("@traqula/core").GeneratorRule<any, "update1"> & T11.SparqlGrammarRule<"update1", T11.UpdateOperation, []> & T11.SparqlGeneratorRule<"update1", T11.UpdateOperation, []>;
     quadsNotTriples: import("@traqula/core").GeneratorRule<any, "quadsNotTriples"> & T11.SparqlGrammarRule<"quadsNotTriples", T11.GraphQuads, []> & T11.SparqlGeneratorRule<"quadsNotTriples", T11.GraphQuads, []>;
+    modify: import("@traqula/core").GeneratorRule<any, "modify"> & T11.SparqlGrammarRule<"modify", T11.UpdateOperationModify, []> & T11.SparqlGeneratorRule<"modify", T11.UpdateOperationModify, []>;
     usingClauses: import("@traqula/core").GeneratorRule<any, "usingClauses"> & T11.SparqlGrammarRule<"usingClauses", T11.DatasetClauses, []> & T11.SparqlGeneratorRule<"usingClauses", T11.DatasetClauses, []>;
     queryOrUpdate: import("@traqula/core").GeneratorRule<any, "queryOrUpdate"> & T11.SparqlGrammarRule<"queryOrUpdate", T11.SparqlQuery, []> & T11.SparqlGeneratorRule<"queryOrUpdate", T11.SparqlQuery, []>;
     generatePattern: import("@traqula/core").GeneratorRule<any, "generatePattern"> & T11.SparqlGeneratorRule<"generatePattern", T11.Pattern>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@traqula/generator-sparql-1-1",
   "type": "module",
-  "version": "0.0.10",
+  "version": "0.0.13",
   "description": "SPARQL 1.1 generator",
   "lsd:module": true,
   "license": "MIT",
@@ -41,13 +41,13 @@
     "build:transpile": " node \"../../node_modules/esbuild/bin/esbuild\" --format=cjs --bundle --log-level=error --outfile=lib/index.cjs lib/index.ts"
   },
   "dependencies": {
-    "@traqula/core": "^0.0.10",
-    "@traqula/rules-sparql-1-1": "^0.0.10"
+    "@traqula/core": "^0.0.13",
+    "@traqula/rules-sparql-1-1": "^0.0.13"
   },
   "devDependencies": {
-    "@traqula/parser-sparql-1-1": "^0.0.10",
+    "@traqula/parser-sparql-1-1": "^0.0.13",
     "@traqula/rules-sparql-1-1": "^0.0.1",
-    "@traqula/test-utils": "^0.0.10"
+    "@traqula/test-utils": "^0.0.13"
   },
-  "gitHead": "94b444f4b1a6904fa4e8979f023a119a48ee4a1d"
+  "gitHead": "324ed65dcfacb6cfa31007e0d5ee43f2599b7284"
 }