@traqula/generator-sparql-1-1 0.0.9 → 0.0.12

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;
+      }
     }
-    const cast = curObject;
-    if (cast.type === searchType && cast.subType === searchSubType) {
-      visitor(curObject);
+    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));
+    }
+    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);
       }
@@ -12334,7 +12397,7 @@ var aggregate = {
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
     F2.printFilter(ast, () => {
-      PRINT_WORD(ast.aggregation, "(");
+      PRINT_WORD(ast.aggregation.toUpperCase(), "(");
       if (ast.distinct) {
         PRINT_WORD("DISTINCT");
       }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@traqula/generator-sparql-1-1",
   "type": "module",
-  "version": "0.0.9",
+  "version": "0.0.12",
   "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.9",
-    "@traqula/rules-sparql-1-1": "^0.0.9"
+    "@traqula/core": "^0.0.12",
+    "@traqula/rules-sparql-1-1": "^0.0.12"
   },
   "devDependencies": {
-    "@traqula/parser-sparql-1-1": "^0.0.9",
+    "@traqula/parser-sparql-1-1": "^0.0.12",
     "@traqula/rules-sparql-1-1": "^0.0.1",
-    "@traqula/test-utils": "^0.0.9"
+    "@traqula/test-utils": "^0.0.12"
   },
-  "gitHead": "c13cd255122c688daad98bf313a3397cbffdc45d"
+  "gitHead": "3517d5a5223c64dc61184b5f603f6d98c12bd166"
 }