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

package/lib/index.cjs

@@ -9674,58 +9674,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;
   }
 };
 
@@ -11375,9 +11432,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];
@@ -11526,7 +11587,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})`);
       }
@@ -11552,12 +11615,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);
       }
@@ -13547,13 +13610,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)
+      ));
     } }
   ])
 };
@@ -14796,6 +14857,7 @@ __export(grammar_exports2, {
   tripleTermSubject: () => tripleTermSubject,
   triplesSameSubject: () => triplesSameSubject2,
   triplesSameSubjectPath: () => triplesSameSubjectPath2,
+  unaryExpression: () => unaryExpression2,
   varOrReifierId: () => varOrReifierId,
   varOrTerm: () => varOrTerm2,
   versionDecl: () => versionDecl,
@@ -14856,7 +14918,7 @@ var sparql12LexerBuilder = LexerBuilder.create(lexer_exports.sparql11LexerBuilde
   buildInOBJECT
 ).addBefore(lexer_exports.terminals.langTag, LANG_DIR).delete(lexer_exports.terminals.langTag);
 
-// ../../packages/rules-sparql-1-2/lib/validator.ts
+// ../../packages/rules-sparql-1-2/lib/validators.ts
 var F2 = new Factory();
 function isLangDir(dir) {
   return dir === "ltr" || dir === "rtl";
@@ -15331,6 +15393,33 @@ var rdfLiteral2 = {
     ])) ?? value;
   }
 };
+var unaryExpression2 = {
+  name: "unaryExpression",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR1, OR2 }) => (C) => OR1([
+    { ALT: () => SUBRULE1(primaryExpression2) },
+    { ALT: () => {
+      const operator = CONSUME(lexer_exports.symbols.exclamation);
+      const expr = SUBRULE1(unaryExpression2);
+      return ACTION(() => C.factory.expressionOperation(
+        "!",
+        [expr],
+        C.factory.sourceLocation(operator, expr)
+      ));
+    } },
+    { ALT: () => {
+      const operator = OR2([
+        { ALT: () => CONSUME(lexer_exports.symbols.opPlus) },
+        { ALT: () => CONSUME(lexer_exports.symbols.opMinus) }
+      ]);
+      const expr = SUBRULE2(primaryExpression2);
+      return ACTION(() => C.factory.expressionOperation(
+        operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS",
+        [expr],
+        C.factory.sourceLocation(operator, expr)
+      ));
+    } }
+  ])
+};
 var generateTriplesBlock = {
   name: "triplesBlock",
   gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {

package/lib/index.d.ts

@@ -4,24 +4,8 @@ import { Factory } from '@traqula/rules-sparql-1-2';
 import type * as T12 from '@traqula/rules-sparql-1-2';
 declare const sparql12GeneratorBuilder: 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" | "reifiedTriple" | "annotationPath" | "annotationBlockPath" | "tripleTerm" | "versionDecl" | "generatePattern", {
-    expression: never;
-    aggregate: never;
-    graphRef: never;
-    path: never;
-    filter: never;
-    bind: never;
+}, "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" | "reifiedTriple" | "annotationPath" | "annotationBlockPath" | "tripleTerm" | "versionDecl" | "generatePattern", {
     query: never;
-    solutionModifier: never;
-    blankNode: never;
-    load: never;
-    clear: never;
-    drop: never;
-    create: never;
-    add: never;
-    move: never;
-    copy: never;
-    modify: never;
     update: never;
     prologue: import("@traqula/core").GeneratorRule<{
         factory: Factory;
@@ -34,9 +18,12 @@ declare const sparql12GeneratorBuilder: GeneratorBuilder<{
     prefixDecl: never;
     selectClause: never;
     whereClause: never;
+    solutionModifier: never;
+    expression: never;
     iriOrFunction: never;
     rdfLiteral: never;
     var: never;
+    aggregate: never;
     iri: never;
     prefixedName: never;
     argList: never;
@@ -45,6 +32,8 @@ declare const sparql12GeneratorBuilder: GeneratorBuilder<{
         factory: Factory;
     }, "triplesBlock", T12.PatternBgp, []>;
     triplesNodePath: never;
+    blankNode: never;
+    path: never;
     varOrTerm: never;
     iriFull: never;
     graphTerm: import("@traqula/core").GeneratorRule<{
@@ -56,6 +45,8 @@ declare const sparql12GeneratorBuilder: GeneratorBuilder<{
     collectionPath: never;
     blankNodePropertyListPath: never;
     graphPatternNotTriples: never;
+    filter: never;
+    bind: never;
     groupOrUnionGraphPattern: never;
     optionalGraphPattern: never;
     minusGraphPattern: never;
@@ -67,13 +58,22 @@ declare const sparql12GeneratorBuilder: GeneratorBuilder<{
     orderClause: never;
     limitOffsetClauses: never;
     datasetClauses: never;
+    load: never;
+    clear: never;
+    drop: never;
+    add: never;
+    move: never;
+    copy: never;
+    create: never;
     insertData: never;
     deleteData: never;
     deleteWhere: never;
+    graphRef: never;
     graphRefAll: never;
     quads: never;
     update1: never;
     quadsNotTriples: never;
+    modify: never;
     usingClauses: never;
     queryOrUpdate: never;
     reifiedTriple: import("@traqula/core").GeneratorRule<{

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@traqula/generator-sparql-1-2",
   "type": "module",
-  "version": "0.0.10",
+  "version": "0.0.13",
   "description": "SPARQL 1.2 generator",
   "lsd:module": true,
   "license": "MIT",
@@ -41,14 +41,14 @@
     "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/generator-sparql-1-1": "^0.0.10",
-    "@traqula/rules-sparql-1-1": "^0.0.10",
-    "@traqula/rules-sparql-1-2": "^0.0.10"
+    "@traqula/core": "^0.0.13",
+    "@traqula/generator-sparql-1-1": "^0.0.13",
+    "@traqula/rules-sparql-1-1": "^0.0.13",
+    "@traqula/rules-sparql-1-2": "^0.0.13"
   },
   "devDependencies": {
-    "@traqula/parser-sparql-1-2": "^0.0.10",
-    "@traqula/test-utils": "^0.0.10"
+    "@traqula/parser-sparql-1-2": "^0.0.13",
+    "@traqula/test-utils": "^0.0.13"
   },
-  "gitHead": "94b444f4b1a6904fa4e8979f023a119a48ee4a1d"
+  "gitHead": "324ed65dcfacb6cfa31007e0d5ee43f2599b7284"
 }