@shaclmate/compiler 2.0.24 → 3.0.0

package/dist/generators/ts/forwardingObjectSetClassDeclaration.js

@@ -0,0 +1,29 @@
+import { Scope, StructureKind } from "ts-morph";
+import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+export function forwardingObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
+    const delegateName = `${syntheticNamePrefix}delegate`;
+    return {
+        getAccessors: [
+            {
+                isAbstract: true,
+                name: delegateName,
+                scope: Scope.Protected,
+                returnType: `${syntheticNamePrefix}ObjectSet`,
+            },
+        ],
+        implements: [`${syntheticNamePrefix}ObjectSet`],
+        isAbstract: true,
+        isExported: true,
+        kind: StructureKind.Class,
+        name: `${syntheticNamePrefix}ForwardingObjectSet`,
+        methods: [...objectTypes, ...objectUnionTypes].flatMap((objectType) => Object.values(objectSetMethodSignatures({ objectType })).map((methodSignature) => ({
+            ...methodSignature,
+            kind: StructureKind.Method,
+            statements: [
+                `return this.${delegateName}.${methodSignature.name}(${methodSignature.parameters.map((parameter) => parameter.name).join(", ")});`,
+            ],
+        }))),
+    };
+}
+//# sourceMappingURL=forwardingObjectSetClassDeclaration.js.map

package/dist/generators/ts/objectSetDeclarations.js

@@ -1,3 +1,4 @@
+import { forwardingObjectSetClassDeclaration } from "./forwardingObjectSetClassDeclaration.js";
 import { objectSetInterfaceDeclaration } from "./objectSetInterfaceDeclaration.js";
 import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetClassDeclaration.js";
 import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
@@ -41,6 +42,7 @@ export function objectSetDeclarations({ objectUnionTypes, ...parameters }) {
             objectTypes,
             objectUnionTypes,
         }),
+        forwardingObjectSetClassDeclaration({ objectTypes, objectUnionTypes }),
     ];
     if (objectTypesWithRdfFeatureCount > 0) {
         statements.push(rdfjsDatasetObjectSetClassDeclaration({

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -14,12 +14,13 @@ export function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnion
         },
     };
     const fromRdfFunctionType = `(resource: rdfjsResource.Resource, options: { objectSet: ${syntheticNamePrefix}ObjectSet }) => purify.Either<Error, ${typeParameters.ObjectT.name}>`;
+    const objectTypeType = `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfTypes: readonly rdfjs.NamedNode[] }`;
     const reusableMethodDeclarations = [];
     if (objectTypes.length > 0) {
         const parameters = {
             objectType: {
                 name: "objectType",
-                type: `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfType?: rdfjs.NamedNode }`,
+                type: objectTypeType,
             },
             query: {
                 hasQuestionToken: true,
@@ -93,11 +94,18 @@ if (query?.where) {
   return purify.Either.of(objects);
 }
 
-if (!objectType.${syntheticNamePrefix}fromRdfType) {
+if (objectType.${syntheticNamePrefix}fromRdfTypes.length === 0) {
   return purify.Either.of([]);
 }
 
-const resources = [...this.resourceSet.instancesOf(objectType.${syntheticNamePrefix}fromRdfType)];
+const resources: rdfjsResource.Resource[] = [];
+for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
+  for (const resource of this.resourceSet.instancesOf(fromRdfType)) {
+    if (!resources.some(existingResource => existingResource.identifier.equals(resource.identifier))) {
+      resources.push(resource);
+    }
+  }
+}
 // Sort resources by identifier so limit and offset are deterministic
 resources.sort((left, right) => left.identifier.value.localeCompare(right.identifier.value));
 
@@ -138,7 +146,6 @@ return purify.Either.of(objects);
         });
     }
     if (objectUnionTypes.length > 0) {
-        const objectTypeType = `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfType?: rdfjs.NamedNode }`;
         const parameters = {
             objectTypes: {
                 name: "objectTypes",
@@ -226,15 +233,18 @@ if (query?.where) {
 
 const resources: { objectType: ${objectTypeType}, resource: rdfjsResource.Resource }[] = [];
 for (const objectType of objectTypes) {
-  if (!objectType.${syntheticNamePrefix}fromRdfType) {
+  if (objectType.${syntheticNamePrefix}fromRdfTypes.length === 0) {
     continue;
   }
 
-  for (const resource of this.resourceSet.instancesOf(objectType.${syntheticNamePrefix}fromRdfType)) {
-    resources.push({ objectType, resource });
+  for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
+    for (const resource of this.resourceSet.instancesOf(fromRdfType)) {
+      if (!resources.some(({ resource: existingResource }) => existingResource.identifier.equals(resource.identifier))) {
+        resources.push({ objectType, resource });
+      }
+    }
   }
 }
-
 // Sort resources by identifier so limit and offset are deterministic
 resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
 
@@ -300,16 +310,13 @@ return purify.Either.of(objects);
             }
             const methodSignatures = objectSetMethodSignatures({ objectType });
             let runtimeObjectType;
+            const runtimeObjectType_ = (objectType) => `{ ${syntheticNamePrefix}fromRdf: ${objectType.staticModuleName}.${syntheticNamePrefix}fromRdf, ${syntheticNamePrefix}fromRdfTypes: [${objectType.fromRdfTypeVariable.toList().concat(objectType.descendantFromRdfTypeVariables).join(", ")}] }`;
             switch (objectType.kind) {
                 case "ObjectType":
-                    runtimeObjectType = objectType.fromRdfType.isJust()
-                        ? `${objectType.staticModuleName}`
-                        : `{ ...${objectType.staticModuleName}, ${syntheticNamePrefix}fromRdfType: undefined }`;
+                    runtimeObjectType = runtimeObjectType_(objectType);
                     break;
                 case "ObjectUnionType":
-                    runtimeObjectType = `[${objectType.memberTypes.map((memberType) => memberType.fromRdfType.isJust()
-                        ? `${memberType.staticModuleName}`
-                        : `{ ...${memberType.staticModuleName}, ${syntheticNamePrefix}fromRdfType: undefined }`)}]`;
+                    runtimeObjectType = `[${objectType.memberTypes.map((memberType) => runtimeObjectType_(memberType)).join(", ")}]`;
                     break;
             }
             return [

package/dist/generators/ts/rdfjsTermExpression.js

@@ -8,11 +8,11 @@ export function rdfjsTermExpression(rdfjsTerm) {
         case "Literal":
             if (rdfjsTerm.datatype.equals(xsd.string)) {
                 if (rdfjsTerm.language.length === 0) {
-                    return `dataFactory.literal("${rdfjsTerm.value}")`;
+                    return `dataFactory.literal(${JSON.stringify(rdfjsTerm.value)})`;
                 }
-                return `dataFactory.literal("${rdfjsTerm.value}", "${rdfjsTerm.language}")`;
+                return `dataFactory.literal(${JSON.stringify(rdfjsTerm.value)}, "${rdfjsTerm.language}")`;
             }
-            return `dataFactory.literal("${rdfjsTerm.value}", ${rdfjsTermExpression(rdfjsTerm.datatype)})`;
+            return `dataFactory.literal(${JSON.stringify(rdfjsTerm.value)}, ${rdfjsTermExpression(rdfjsTerm.datatype)})`;
         case "NamedNode": {
             if (rdfjsTerm.value.startsWith(rdf[""].value)) {
                 const unqualifiedName = rdfjsTerm.value.substring(rdf[""].value.length);

package/dist/input/PropertyPath.d.ts

@@ -34,7 +34,7 @@ export declare namespace PropertyPath {
     function $fromRdf(resource: Resource, _?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
+        preferredLanguages?: readonly string[];
     }): Either<Error, PropertyPath>;
     function $toRdf(_propertyPath: PropertyPath, _options?: any): Resource;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "2.0.24",
+    "@shaclmate/shacl-ast": "3.0.0",
     "@rdfjs/prefix-map": "^0.1.2",
     "@rdfjs/term-map": "^2.0.2",
     "@rdfjs/term-set": "^2.0.3",
@@ -22,13 +22,10 @@
     "typescript-memoize": "^1.1.1"
   },
   "devDependencies": {
-    "@shaclmate/kitchen-sink-example": "2.0.24",
-    "@shaclmate/runtime": "2.0.24",
+    "@shaclmate/kitchen-sink-example": "3.0.0",
+    "@shaclmate/runtime": "3.0.0",
     "@kos-kit/sparql-client": "2.0.115",
-    "@types/n3": "^1.21.1",
-    "oxigraph": "0.4.11",
-    "n3": "^1.21.3",
-    "rdfjs-resource": "1.0.22"
+    "oxigraph": "0.4.11"
   },
   "exports": {
     ".": {
@@ -79,5 +76,5 @@
     "unlink": "npm unlink -g @shaclmate/compiler"
   },
   "type": "module",
-  "version": "2.0.24"
+  "version": "3.0.0"
 }