@traqula/rules-sparql-1-1-adjust 0.0.1-alpha.141 → 0.0.1-alpha.145

package/lib/index.cjs

@@ -9550,10 +9550,16 @@ function resolveIRI(iri3, base) {
       return base.replace(/(?:\?.*)?$/u, iri3);
     // Resolve root relative IRIs at the root of the base IRI
     case "/":
-      return base + iri3;
+      const baseMatch = base.match(/^(?:[a-z]+:\/*)?[^\/]*/);
+      if (!baseMatch) {
+        throw new Error(`Could not determine relative IRI using base: ${base}`);
+      }
+      const baseRoot = baseMatch[0];
+      return baseRoot + iri3;
     // Resolve all other IRIs at the base IRI's path
     default:
-      return base + iri3;
+      const basePath = base.replace(/[^\/:]*$/, "");
+      return basePath + iri3;
   }
 }
 
@@ -10418,12 +10424,6 @@ var blankNode = {
       {
         ALT: () => {
           const label = CONSUME(terminals_exports.blankNodeLabel).image;
-          ACTION(() => {
-            if (context.flushedBlankNodeLabels.has(label)) {
-              throw new Error("Detected reuse blank node across different request string.");
-            }
-            context.usedBlankNodeLabels.add(label);
-          });
           return ACTION(() => context.dataFactory.blankNode(label.replace("_:", "e_")));
         }
       },
@@ -10623,16 +10623,15 @@ function triplesSameSubjectImpl(name, allowPaths) {
       {
         ALT: () => {
           const subject = SUBRULE(varOrTerm);
-          const propNotEmpty = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty);
-          return ACTION(() => propNotEmpty.map((partial) => partial({ subject })));
+          return SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, subject);
         }
       },
       {
         ALT: () => {
           const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode);
-          const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList);
+          const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, subjectNode.node);
           return ACTION(() => [
-            ...restNode.map((partial) => partial({ subject: subjectNode.node })),
+            ...restNode,
             ...subjectNode.triples
           ]);
         }
@@ -10645,7 +10644,7 @@ var triplesSameSubjectPath = triplesSameSubjectImpl("triplesSameSubjectPath", tr
 function propertyListImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ SUBRULE, OPTION }) => () => OPTION(() => SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty)) ?? []
+    impl: ({ SUBRULE, OPTION }) => (subject) => OPTION(() => SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, subject)) ?? []
   };
 }
 var propertyList = propertyListImpl("propertyList", false);
@@ -10653,42 +10652,30 @@ var propertyListPath = propertyListImpl("propertyListPath", true);
 function propertyListNotEmptyImplementation(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION, OR1, OR2, context }) => () => {
+    impl: ({ ACTION, CONSUME, AT_LEAST_ONE, SUBRULE1, MANY2, OR1 }) => (subject) => {
       const result = [];
-      const resultAppendage = [];
-      const firstProperty = allowPaths ? OR1([
-        { ALT: () => SUBRULE1(verbPath) },
-        { ALT: () => SUBRULE1(verbSimple) }
-      ]) : SUBRULE1(verb);
-      const firstObjects = SUBRULE1(allowPaths ? objectListPath : objectList);
-      ACTION(() => {
-        const filterSubject = context.dataFactory.namedNode("internal:filterSubject");
-        for (const cObject of firstObjects) {
-          const triple = cObject({ subject: filterSubject, predicate: firstProperty });
-          const generator = (rest) => cObject({ ...rest, predicate: firstProperty });
-          if (triple.subject === filterSubject) {
-            result.push(generator);
-          } else {
-            resultAppendage.push(generator);
-          }
-        }
-      });
-      MANY(() => {
-        CONSUME(symbols_exports.semi);
-        OPTION(() => {
-          const predicate = allowPaths ? OR2([
-            { ALT: () => SUBRULE2(verbPath) },
-            { ALT: () => SUBRULE2(verbSimple) }
-          ]) : SUBRULE2(verb);
-          const objects = SUBRULE2(allowPaths ? objectListPath : objectList);
-          ACTION(() => {
-            result.push(
-              ...objects.map((object2) => (partS) => object2({ ...partS, predicate }))
-            );
+      let parsedSemi = true;
+      AT_LEAST_ONE({
+        GATE: () => parsedSemi,
+        DEF: () => {
+          parsedSemi = false;
+          const predicate = allowPaths ? OR1([
+            { ALT: () => SUBRULE1(verbPath) },
+            { ALT: () => SUBRULE1(verbSimple) }
+          ]) : SUBRULE1(verb);
+          const triples = SUBRULE1(
+            allowPaths ? objectListPath : objectList,
+            subject,
+            predicate
+          );
+          ACTION(() => result.push(...triples));
+          MANY2(() => {
+            CONSUME(symbols_exports.semi);
+            parsedSemi = true;
           });
-        });
+        }
       });
-      return [...result, ...resultAppendage];
+      return result;
     }
   };
 }
@@ -10705,11 +10692,11 @@ var verbSimple = {
 function objectListImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, SUBRULE, AT_LEAST_ONE_SEP }) => () => {
+    impl: ({ ACTION, SUBRULE, AT_LEAST_ONE_SEP }) => (subject, predicate) => {
       const objects = [];
       AT_LEAST_ONE_SEP({
         DEF: () => {
-          const objectTriples = SUBRULE(allowPaths ? objectPath : object);
+          const objectTriples = SUBRULE(allowPaths ? objectPath : object, subject, predicate);
           ACTION(() => objects.push(...objectTriples));
         },
         SEP: symbols_exports.comma
@@ -10723,11 +10710,11 @@ var objectListPath = objectListImpl("objectListPath", true);
 function objectImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, SUBRULE }) => () => {
+    impl: ({ ACTION, SUBRULE }) => (subject, predicate) => {
       const node = SUBRULE(allowPaths ? graphNodePath : graphNode);
       return ACTION(() => [
-        (part) => ({ ...part, object: node.node }),
-        ...node.triples.map((val) => () => val)
+        { subject, predicate, object: node.node },
+        ...node.triples
       ]);
     }
   };
@@ -10753,13 +10740,16 @@ function blankNodePropertyListImpl(name, allowPaths) {
     name,
     impl: ({ ACTION, SUBRULE, CONSUME, context }) => () => {
       CONSUME(symbols_exports.LSquare);
-      const propList = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty);
+      let blankNode2;
+      const propList = SUBRULE(
+        allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty,
+        ACTION(() => blankNode2 = context.dataFactory.blankNode())
+      );
       CONSUME(symbols_exports.RSquare);
       return ACTION(() => {
-        const subject = context.dataFactory.blankNode();
         return {
-          node: subject,
-          triples: propList.map((part) => part({ subject }))
+          node: blankNode2,
+          triples: propList
         };
       });
     }
@@ -10899,16 +10889,24 @@ var prefixDecl2 = {
 };
 var triplesTemplate = {
   name: "triplesTemplate",
-  impl: ({ SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
+  impl: ({ ACTION, AT_LEAST_ONE, AT_LEAST_ONE_SEP, SUBRULE, CONSUME, OPTION }) => () => {
     const triples = [];
-    triples.push(SUBRULE(triplesSameSubject));
-    OPTION1(() => {
-      CONSUME(symbols_exports.dot);
-      OPTION2(() => {
-        triples.push(SUBRULE(triplesTemplate));
-      });
+    let parsedDot = true;
+    AT_LEAST_ONE({
+      GATE: () => parsedDot,
+      DEF: () => {
+        parsedDot = false;
+        const template = SUBRULE(triplesSameSubject);
+        ACTION(() => {
+          triples.push(...template);
+        });
+        OPTION(() => {
+          CONSUME(symbols_exports.dot);
+          parsedDot = true;
+        });
+      }
     });
-    return triples.flat(1);
+    return triples;
   }
 };
 var verb = {
@@ -12652,6 +12650,7 @@ var updateUnit = {
 var update = {
   name: "update",
   impl: ({ ACTION, SUBRULE, CONSUME, OPTION1, OPTION2, context }) => () => {
+    const blankLabelsUsedInInsertData = /* @__PURE__ */ new Set();
     const prologueValues = SUBRULE(prologue);
     const result = {
       type: "update",
@@ -12661,12 +12660,6 @@ var update = {
     };
     OPTION1(() => {
       const updateOperation = SUBRULE(update1);
-      ACTION(() => {
-        for (const label of context.usedBlankNodeLabels) {
-          context.flushedBlankNodeLabels.add(label);
-        }
-        context.usedBlankNodeLabels.clear();
-      });
       const recursiveRes = OPTION2(() => {
         CONSUME(symbols_exports.semi);
         return SUBRULE(update);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@traqula/rules-sparql-1-1-adjust",
-  "version": "0.0.1-alpha.141+caaf4c7",
+  "version": "0.0.1-alpha.145+b7fd73e",
   "description": "TRAQULA Lexer and Grammar Rules for sparql 1.1-ADJUST",
   "lsd:module": true,
   "license": "MIT",
@@ -38,8 +38,8 @@
     "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.1-alpha.141+caaf4c7",
-    "@traqula/rules-sparql-1-1": "^0.0.1-alpha.141+caaf4c7"
+    "@traqula/core": "^0.0.1-alpha.145+b7fd73e",
+    "@traqula/rules-sparql-1-1": "^0.0.1-alpha.145+b7fd73e"
   },
-  "gitHead": "caaf4c71153d27f8fa113b51efb1dae91e182960"
+  "gitHead": "b7fd73efdfc32dec46beaa040431ba031a723b53"
 }