@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.d.ts

@@ -1,8 +1,8 @@
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }: {
-    objectTypes: readonly ObjectType[];
-    objectUnionTypes: readonly ObjectUnionType[];
+export declare function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }: {
+    namedObjectTypes: readonly NamedObjectType[];
+    namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): Code;
 //# sourceMappingURL=rdfjsDatasetObjectSetClassDeclaration.d.ts.map

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -1,15 +1,14 @@
-import { snippets_FromRdfOptions } from "./_snippets/snippets_FromRdfOptions.js";
 import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
 import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
-export function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
-    const objectTypeType = code `\
+export function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
+    const namedObjectTypeType = code `\
 {
   ${syntheticNamePrefix}filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
-  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options?: ${snippets_FromRdfOptions}) => ${imports.Either}<Error, ObjectT>;
+  ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<ObjectT>;
   ${syntheticNamePrefix}fromRdfTypes: readonly ${imports.NamedNode}[]
 }`;
     const parameters = {
@@ -42,13 +41,15 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
   }
 
   ${joinCode([
-        ...[...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
-            if (!objectType.features.has("rdf")) {
+        ...[...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
+            if (!namedObjectType.features.has("rdf")) {
                 return Object.values(unsupportedObjectSetMethodDeclarations({
-                    objectType,
+                    namedObjectType,
                 }));
             }
-            const methodSignatures = objectSetMethodSignatures({ objectType });
+            const methodSignatures = objectSetMethodSignatures({
+                namedObjectType,
+            });
             const delegatingMethods = [
                 // object
                 code `\
@@ -57,7 +58,7 @@ async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${
 }`,
                 // objectSync
                 code `\
-${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${imports.Either}<Error, ${objectType.name}> {
+${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${imports.Either}<Error, ${namedObjectType.name}> {
   return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages }).map(objects => objects[0]);
 }`,
                 // objectCount
@@ -77,7 +78,7 @@ async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdenti
 }`,
                 // objectIdentifiersSync
                 code `\
-${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${imports.Either}<Error, readonly ${objectType.identifierTypeAlias}[]> {
+${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]> {
   return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier));
 }`,
                 // objects
@@ -87,37 +88,37 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 }`,
                 // objectsSync has per-object type logic, not just forwarding
             ];
-            const runtimeObjectType = (filterFunction, objectType) => {
-                const fromRdfTypes = objectType.fromRdfTypeVariable
+            const runtimeObjectType = (filterFunction, namedObjectType) => {
+                const fromRdfTypes = namedObjectType.fromRdfTypeVariable
                     .toList()
-                    .concat(objectType.descendantFromRdfTypeVariables);
-                return code `{ ${syntheticNamePrefix}filter: ${filterFunction}, ${syntheticNamePrefix}fromRdf: ${objectType.staticModuleName}.${syntheticNamePrefix}fromRdf, ${syntheticNamePrefix}fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+                    .concat(namedObjectType.descendantFromRdfTypeVariables);
+                return code `{ ${syntheticNamePrefix}filter: ${filterFunction}, ${syntheticNamePrefix}fromRdfResource: ${namedObjectType.staticModuleName}.${syntheticNamePrefix}fromRdfResource, ${syntheticNamePrefix}fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
             };
-            switch (objectType.kind) {
-                case "ObjectType": {
+            switch (namedObjectType.kind) {
+                case "NamedObjectType": {
                     return delegatingMethods.concat(code `\
-${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${objectType.name}[]> {
-  return this.${syntheticNamePrefix}objectsSync<${objectType.name}, ${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType(objectType.filterFunction, objectType)}, query);
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
+  return this.${syntheticNamePrefix}objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
 }`);
                 }
-                case "ObjectUnionType":
+                case "NamedObjectUnionType":
                     return delegatingMethods.concat(code `\
-${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${objectType.name}[]> {
-  return this.${syntheticNamePrefix}objectUnionsSync<${objectType.name}, ${objectType.filterType}, ${objectType.identifierTypeAlias}>([
-    ${joinCode(objectType.memberTypes
-                        .filter((memberType) => !memberType.abstract)
-                        .map((memberType) => runtimeObjectType(objectType.filterFunction, memberType)), { on: ", " })}
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
+  return this.${syntheticNamePrefix}objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
+    ${joinCode(namedObjectType.members
+                        .filter((member) => !member.type.abstract)
+                        .map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);
                 default:
-                    objectType;
+                    namedObjectType;
                     return [];
             }
         }),
-        ...(objectTypes.length > 0
+        ...(namedObjectTypes.length > 0
             ? [
                 code `\
-protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(objectType: ${objectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
@@ -126,7 +127,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
   let offset = query?.offset ?? 0;
   if (offset < 0) { offset = 0; }
 
-  const fromRdfOptions: ${snippets_FromRdfOptions} = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
+  const fromRdfResourceOptions: Parameters<${snippets.FromRdfResourceFunction}<ObjectT>>[1] = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
 
   let resources: { object?: ObjectT, resource: ${imports.Resource} }[];
   const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
@@ -134,11 +135,11 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
   if (query?.identifiers) {
     resources = query.identifiers.map(identifier => ({ resource: resourceSet.resource(identifier) }));
     sortResources = false;
-  } else if (objectType.${syntheticNamePrefix}fromRdfTypes.length > 0) {
+  } else if (namedObjectType.${syntheticNamePrefix}fromRdfTypes.length > 0) {
     const identifierSet = new ${snippets.IdentifierSet}();
     resources = [];
     sortResources = true;
-    for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
+    for (const fromRdfType of namedObjectType.${syntheticNamePrefix}fromRdfTypes) {
       for (const resource of resourceSet.instancesOf(fromRdfType, { graph })) {
         if (!identifierSet.has(resource.identifier)) {
           identifierSet.add(resource.identifier);
@@ -169,7 +170,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
       identifierSet.add(quad.subject);
       const resource = resourceSet.resource(quad.subject);
       // Eagerly eliminate the majority of resources that won't match the object type
-      objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions).ifRight(object => {
+      namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
         resources.push({ object, resource });
       });
     }
@@ -184,14 +185,14 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
   const objects: ObjectT[] = [];
   for (let { object, resource } of resources) {
     if (!object) {
-      const objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions);
+      const objectEither = namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
       if (objectEither.isLeft()) {
         return objectEither;
       }
       object = objectEither.unsafeCoerce();
     }
 
-    if (query?.filter && !objectType.${syntheticNamePrefix}filter(query.filter, object)) {
+    if (query?.filter && !namedObjectType.${syntheticNamePrefix}filter(query.filter, object)) {
       continue;
     }
 
@@ -206,10 +207,10 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
   }`,
             ]
             : []),
-        ...(objectUnionTypes.length > 0
+        ...(namedObjectUnionTypes.length > 0
             ? [
                 code `\
-protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(objectTypes: readonly ${objectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
@@ -218,24 +219,24 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
   let offset = query?.offset ?? 0;
   if (offset < 0) { offset = 0; }
 
-  const fromRdfOptions: ${snippets_FromRdfOptions} = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
+  const fromRdfResourceOptions: Parameters<${snippets.FromRdfResourceFunction}<ObjectT>>[1] = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
 
-  let resources: { object?: ObjectT, objectType?: ${objectTypeType}, resource: ${imports.Resource} }[];
+  let resources: { object?: ObjectT, namedObjectType?: ${namedObjectTypeType}, resource: ${imports.Resource} }[];
   const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
   let sortResources: boolean;
   if (query?.identifiers) {
     resources = query.identifiers.map(identifier => ({ resource: resourceSet.resource(identifier) }));
     sortResources = false;
-  } else if (objectTypes.every(objectType => objectType.${syntheticNamePrefix}fromRdfTypes.length > 0)) {
+  } else if (namedObjectTypes.every(namedObjectType => namedObjectType.${syntheticNamePrefix}fromRdfTypes.length > 0)) {
     const identifierSet = new ${snippets.IdentifierSet}();
     resources = [];
     sortResources = true;
-    for (const objectType of objectTypes) {
-      for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
+    for (const namedObjectType of namedObjectTypes) {
+      for (const fromRdfType of namedObjectType.${syntheticNamePrefix}fromRdfTypes) {
         for (const resource of resourceSet.instancesOf(fromRdfType, { graph })) {
           if (!identifierSet.has(resource.identifier)) {
             identifierSet.add(resource.identifier);
-            resources.push({ objectType, resource });
+            resources.push({ namedObjectType, resource });
           }
         }
       }
@@ -263,9 +264,9 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
       identifierSet.add(quad.subject);
       // Eagerly eliminate the majority of resources that won't match the object types
       const resource = resourceSet.resource(quad.subject);
-      for (const objectType of objectTypes) {
-        if (objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions).ifRight(object => {
-          resources.push({ object, objectType, resource });
+      for (const namedObjectType of namedObjectTypes) {
+        if (namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
+          resources.push({ object, namedObjectType, resource });
         }).isRight()) {
           break;
         }
@@ -280,17 +281,17 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
 
   let objectI = 0;
   const objects: ObjectT[] = [];
-  for (let { object, objectType, resource } of resources) {
+  for (let { object, namedObjectType, resource } of resources) {
     if (!object) {
       let objectEither: ${imports.Either}<Error, ObjectT>;
-      if (objectType) {
-        objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions);
+      if (namedObjectType) {
+        objectEither = namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
       } else {
         objectEither = ${imports.Left}(new Error("no object types"));
-        for (const tryObjectType of objectTypes) {
-          objectEither = tryObjectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions);
+        for (const tryObjectType of namedObjectTypes) {
+          objectEither = tryObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
           if (objectEither.isRight()) {
-            objectType = tryObjectType;
+            namedObjectType = tryObjectType;
             break;
           }
         }
@@ -300,11 +301,11 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
       }
       object = objectEither.unsafeCoerce();
     }
-    if (!objectType) {
-      throw new Error("objectType should be set here");
+    if (!namedObjectType) {
+      throw new Error("namedObjectType should be set here");
     }
 
-    if (query?.filter && !objectType.${syntheticNamePrefix}filter(query.filter, object)) {
+    if (query?.filter && !namedObjectType.${syntheticNamePrefix}filter(query.filter, object)) {
       continue;
     }
 

package/dist/generators/ts/singleEntryRecord.d.ts

@@ -0,0 +1,2 @@
+export declare function singleEntryRecord<T>(key: string, value: T): Record<string, T>;
+//# sourceMappingURL=singleEntryRecord.d.ts.map

package/dist/generators/ts/singleEntryRecord.js

@@ -0,0 +1,6 @@
+export function singleEntryRecord(key, value) {
+    const record = {};
+    record[key] = value;
+    return record;
+}
+//# sourceMappingURL=singleEntryRecord.js.map

package/dist/generators/ts/snippets.d.ts

@@ -34,9 +34,12 @@ export declare const snippets: {
     filterNumeric: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     filterString: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     filterTerm: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
-    FromRdfOptions: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    FocusSparqlConstructTriplesFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    FocusSparqlWherePatternsFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     fromRdfLanguageIn: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     fromRdfPreferredLanguages: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    FromRdfResourceFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    FromRdfResourceValuesFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     Hasher: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     IdentifierFilter: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     identifierFromString: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
@@ -71,7 +74,8 @@ export declare const snippets: {
     NumericFilter: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     NumericSchema: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     numericSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
-    PropertiesFromRdfParameters: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    PropertiesFromRdfResourceFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    PropertyPath: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     RdfVocabularies: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     shaclPropertyFromRdf: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     ShaclPropertySchema: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
@@ -80,16 +84,12 @@ export declare const snippets: {
     setSparqlConstructTriples: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     setSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     sortSparqlPatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
-    SparqlConstructTriplesFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
-    SparqlConstructTriplesFunctionParameters: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     SparqlFilterPattern: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     sparqlInstancesOfPattern: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     SparqlPattern_isSolutionGenerating: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     SparqlPattern: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     sparqlPropertyPath: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     sparqlValueInPattern: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
-    SparqlWherePatternsFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
-    SparqlWherePatternsFunctionParameters: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     strictEquals: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     StringFilter: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     StringSchema: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
@@ -99,6 +99,10 @@ export declare const snippets: {
     TermSchema: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     termSchemaSparqlPatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     termSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    ToRdfResourceFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    ToRdfResourceValuesFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     UnwrapR: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    ValueSparqlConstructTriplesFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    ValueSparqlWherePatternsFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
 };
 //# sourceMappingURL=snippets.d.ts.map

package/dist/generators/ts/snippets.js

@@ -21,7 +21,10 @@ import { snippets_decodeBigDecimalLiteral } from "./_snippets/snippets_decodeBig
 import { snippets_deduplicateSparqlPatterns } from "./_snippets/snippets_deduplicateSparqlPatterns.js";
 import { snippets_defaultValueSparqlWherePatterns } from "./_snippets/snippets_defaultValueSparqlWherePatterns.js";
 import { snippets_EqualsResult } from "./_snippets/snippets_EqualsResult.js";
-import { snippets_FromRdfOptions } from "./_snippets/snippets_FromRdfOptions.js";
+import { snippets_FocusSparqlConstructTriplesFunction } from "./_snippets/snippets_FocusSparqlConstructTriplesFunction.js";
+import { snippets_FocusSparqlWherePatternsFunction } from "./_snippets/snippets_FocusSparqlWherePatternsFunction.js";
+import { snippets_FromRdfResourceFunction } from "./_snippets/snippets_FromRdfResourceFunction.js";
+import { snippets_FromRdfResourceValuesFunction } from "./_snippets/snippets_FromRdfResourceValuesFunction.js";
 import { snippets_filterArray } from "./_snippets/snippets_filterArray.js";
 import { snippets_filterBigDecimal } from "./_snippets/snippets_filterBigDecimal.js";
 import { snippets_filterBlankNode } from "./_snippets/snippets_filterBlankNode.js";
@@ -70,16 +73,13 @@ import { snippets_NumericFilter } from "./_snippets/snippets_NumericFilter.js";
 import { snippets_NumericSchema } from "./_snippets/snippets_NumericSchema.js";
 import { snippets_normalizeSparqlWherePatterns } from "./_snippets/snippets_normalizeSparqlWherePatterns.js";
 import { snippets_numericSparqlWherePatterns } from "./_snippets/snippets_numericSparqlWherePatterns.js";
-import { snippets_PropertiesFromRdfParameters } from "./_snippets/snippets_PropertiesFromRdfParameters.js";
+import { snippets_PropertiesFromRdfResourceFunction } from "./_snippets/snippets_PropertiesFromRdfResourceFunction.js";
+import { snippets_PropertyPath } from "./_snippets/snippets_PropertyPath.js";
 import { snippets_RdfVocabularies } from "./_snippets/snippets_RdfVocabularies.js";
 import { snippets_ShaclPropertySchema } from "./_snippets/snippets_ShaclPropertySchema.js";
-import { snippets_SparqlConstructTriplesFunction } from "./_snippets/snippets_SparqlConstructTriplesFunction.js";
-import { snippets_SparqlConstructTriplesFunctionParameters } from "./_snippets/snippets_SparqlConstructTriplesFunctionParameters.js";
 import { snippets_SparqlFilterPattern } from "./_snippets/snippets_SparqlFilterPattern.js";
 import { snippets_SparqlPattern } from "./_snippets/snippets_SparqlPattern.js";
 import { snippets_SparqlPattern_isSolutionGenerating } from "./_snippets/snippets_SparqlPattern_isSolutionGenerating.js";
-import { snippets_SparqlWherePatternsFunction } from "./_snippets/snippets_SparqlWherePatternsFunction.js";
-import { snippets_SparqlWherePatternsFunctionParameters } from "./_snippets/snippets_SparqlWherePatternsFunctionParameters.js";
 import { snippets_StringFilter } from "./_snippets/snippets_StringFilter.js";
 import { snippets_StringSchema } from "./_snippets/snippets_StringSchema.js";
 import { snippets_setSparqlConstructTriples } from "./_snippets/snippets_setSparqlConstructTriples.js";
@@ -95,10 +95,14 @@ import { snippets_strictEquals } from "./_snippets/snippets_strictEquals.js";
 import { snippets_stringSparqlWherePatterns } from "./_snippets/snippets_stringSparqlWherePatterns.js";
 import { snippets_TermFilter } from "./_snippets/snippets_TermFilter.js";
 import { snippets_TermSchema } from "./_snippets/snippets_TermSchema.js";
+import { snippets_ToRdfResourceFunction } from "./_snippets/snippets_ToRdfResourceFunction.js";
+import { snippets_ToRdfResourceValuesFunction } from "./_snippets/snippets_ToRdfResourceValuesFunction.js";
 import { snippets_termFilterSparqlPatterns } from "./_snippets/snippets_termFilterSparqlPatterns.js";
 import { snippets_termSchemaSparqlPatterns } from "./_snippets/snippets_termSchemaSparqlPatterns.js";
 import { snippets_termSparqlWherePatterns } from "./_snippets/snippets_termSparqlWherePatterns.js";
 import { snippets_UnwrapR } from "./_snippets/snippets_UnwrapR.js";
+import { snippets_ValueSparqlConstructTriplesFunction } from "./_snippets/snippets_ValueSparqlConstructTriplesFunction.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./_snippets/snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets = {
     arrayIntersection: snippets_arrayIntersection,
     arrayEquals: snippets_arrayEquals,
@@ -135,9 +139,12 @@ export const snippets = {
     filterNumeric: snippets_filterNumeric,
     filterString: snippets_filterString,
     filterTerm: snippets_filterTerm,
-    FromRdfOptions: snippets_FromRdfOptions,
+    FocusSparqlConstructTriplesFunction: snippets_FocusSparqlConstructTriplesFunction,
+    FocusSparqlWherePatternsFunction: snippets_FocusSparqlWherePatternsFunction,
     fromRdfLanguageIn: snippets_fromRdfLanguageIn,
     fromRdfPreferredLanguages: snippets_fromRdfPreferredLanguages,
+    FromRdfResourceFunction: snippets_FromRdfResourceFunction,
+    FromRdfResourceValuesFunction: snippets_FromRdfResourceValuesFunction,
     Hasher: snippets_Hasher,
     IdentifierFilter: snippets_IdentifierFilter,
     identifierFromString: snippets_identifierFromString,
@@ -172,7 +179,8 @@ export const snippets = {
     NumericFilter: snippets_NumericFilter,
     NumericSchema: snippets_NumericSchema,
     numericSparqlWherePatterns: snippets_numericSparqlWherePatterns,
-    PropertiesFromRdfParameters: snippets_PropertiesFromRdfParameters,
+    PropertiesFromRdfResourceFunction: snippets_PropertiesFromRdfResourceFunction,
+    PropertyPath: snippets_PropertyPath,
     RdfVocabularies: snippets_RdfVocabularies,
     shaclPropertyFromRdf: snippets_shaclPropertyFromRdf,
     ShaclPropertySchema: snippets_ShaclPropertySchema,
@@ -181,16 +189,12 @@ export const snippets = {
     setSparqlConstructTriples: snippets_setSparqlConstructTriples,
     setSparqlWherePatterns: snippets_setSparqlWherePatterns,
     sortSparqlPatterns: snippets_sortSparqlPatterns,
-    SparqlConstructTriplesFunction: snippets_SparqlConstructTriplesFunction,
-    SparqlConstructTriplesFunctionParameters: snippets_SparqlConstructTriplesFunctionParameters,
     SparqlFilterPattern: snippets_SparqlFilterPattern,
     sparqlInstancesOfPattern: snippets_sparqlInstancesOfPattern,
     SparqlPattern_isSolutionGenerating: snippets_SparqlPattern_isSolutionGenerating,
     SparqlPattern: snippets_SparqlPattern,
     sparqlPropertyPath: snippets_sparqlPropertyPath,
     sparqlValueInPattern: snippets_sparqlValueInPattern,
-    SparqlWherePatternsFunction: snippets_SparqlWherePatternsFunction,
-    SparqlWherePatternsFunctionParameters: snippets_SparqlWherePatternsFunctionParameters,
     strictEquals: snippets_strictEquals,
     StringFilter: snippets_StringFilter,
     StringSchema: snippets_StringSchema,
@@ -200,6 +204,10 @@ export const snippets = {
     TermSchema: snippets_TermSchema,
     termSchemaSparqlPatterns: snippets_termSchemaSparqlPatterns,
     termSparqlWherePatterns: snippets_termSparqlWherePatterns,
+    ToRdfResourceFunction: snippets_ToRdfResourceFunction,
+    ToRdfResourceValuesFunction: snippets_ToRdfResourceValuesFunction,
     UnwrapR: snippets_UnwrapR,
+    ValueSparqlConstructTriplesFunction: snippets_ValueSparqlConstructTriplesFunction,
+    ValueSparqlWherePatternsFunction: snippets_ValueSparqlWherePatternsFunction,
 };
 //# sourceMappingURL=snippets.js.map

package/dist/generators/ts/sparqlObjectSetClassDeclaration.d.ts

@@ -1,8 +1,8 @@
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }: {
-    objectTypes: readonly ObjectType[];
-    objectUnionTypes: readonly ObjectUnionType[];
+export declare function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }: {
+    namedObjectTypes: readonly NamedObjectType[];
+    namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): Code;
 //# sourceMappingURL=sparqlObjectSetClassDeclaration.d.ts.map

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -4,16 +4,15 @@ import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
-export function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
-    const sparqlWherePatternsFunctionType = code `(parameters: { filter: ObjectFilterT | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string; }) => readonly ${imports.sparqljs}.Pattern[]`;
+export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
     const parameters = {
-        constructObjectType: code `objectType: {\
-  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>; objectSet: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[]; }) => ${imports.Either}<Error, ObjectT>;
+        constructObjectType: code `namedObjectType: {\
+  ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT>;
+  ${syntheticNamePrefix}fromRdfResource:  ${snippets.FromRdfResourceFunction}<ObjectT>;
   ${syntheticNamePrefix}sparqlConstructQueryString: (parameters: { filter?: ObjectFilterT; subject: ${imports.NamedNode} | ${imports.Variable}; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions) => string;
-  ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType};
 }`,
         query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
-        selectObjectTypeType: code `objectType: { ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType} }`,
+        selectObjectTypeType: code `namedObjectType: { ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
     };
     const typeParameters = {
         ObjectT: code `ObjectT extends { readonly $identifier: ObjectIdentifierT }`,
@@ -31,17 +30,17 @@ export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePre
     this.graph = options?.graph;
   }
 
-${joinCode([...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
-        if (!objectType.features.has("sparql")) {
+${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
+        if (!namedObjectType.features.has("sparql")) {
             return Object.values(unsupportedObjectSetMethodDeclarations({
-                objectType,
+                namedObjectType,
             }));
         }
         const methodSignatures = objectSetMethodSignatures({
-            objectType,
+            namedObjectType,
             queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
         });
-        const runtimeObjectType = objectType.staticModuleName;
+        const runtimeObjectType = namedObjectType.staticModuleName;
         return [
             code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
@@ -49,15 +48,15 @@ async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${
 }`,
             code `\
 async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
-  return this.${syntheticNamePrefix}objectCount<${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.${syntheticNamePrefix}objectCount<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
             code `\
 async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
-  return this.${syntheticNamePrefix}objectIdentifiers<${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.${syntheticNamePrefix}objectIdentifiers<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
             code `\
 async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
-  return this.${syntheticNamePrefix}objects<${objectType.name}, ${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.${syntheticNamePrefix}objects<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
         ];
     }), { on: "\n\n" })}
@@ -112,7 +111,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       offset = 0;
     }
 
-    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query);
+    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
       return ${imports.Left}(new Error("no SPARQL WHERE patterns for identifiers"));
     }
@@ -140,12 +139,12 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 
   protected async ${syntheticNamePrefix}objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectT[]>> {
     return ${imports.EitherAsync}(async ({ liftEither }) => {
-      const identifiers = await liftEither(await this.${syntheticNamePrefix}objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(objectType, query));
+      const identifiers = await liftEither(await this.${syntheticNamePrefix}objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(namedObjectType, query));
       if (identifiers.length === 0) {
         return [];
       }
 
-      const constructQueryString = objectType.${syntheticNamePrefix}sparqlConstructQueryString({
+      const constructQueryString = namedObjectType.${syntheticNamePrefix}sparqlConstructQueryString({
         subject: this.${syntheticNamePrefix}objectVariable,
         where: [{
           type: "values" as const,
@@ -162,14 +161,14 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       const dataset = ${imports.datasetFactory}.dataset(quads.concat());
       const objects: ObjectT[] = [];
       for (const identifier of identifiers) {
-        objects.push(await liftEither(objectType.${syntheticNamePrefix}fromRdf(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
+        objects.push(await liftEither(namedObjectType.${syntheticNamePrefix}fromRdfResource(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
       }
       return objects;
     });
   }
 
   protected async ${syntheticNamePrefix}objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, number>> {
-    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query);
+    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
       return ${imports.Left}(new Error("no SPARQL WHERE patterns for count"));
     }
@@ -211,7 +210,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       patterns = patterns.concat(query.where(this.${syntheticNamePrefix}objectVariable));
     }
 
-    patterns = patterns.concat(objectType.${syntheticNamePrefix}sparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.${syntheticNamePrefix}objectVariable.value }));
+    patterns = patterns.concat(namedObjectType.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.${syntheticNamePrefix}objectVariable.value }));
 
     patterns = ${snippets.normalizeSparqlWherePatterns}(patterns).concat();
 

package/dist/generators/ts/synthesizeUberObjectUnionType.d.ts

@@ -1,9 +1,9 @@
-import type { ObjectType } from "./ObjectType.js";
-import { ObjectUnionType } from "./ObjectUnionType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 /**
  * Synthesize the $Object union.
  */
 export declare function synthesizeUberObjectUnionType(parameters: {
-    objectTypes: readonly ObjectType[];
-}): ObjectUnionType;
+    namedObjectTypes: readonly NamedObjectType[];
+}): NamedObjectUnionType;
 //# sourceMappingURL=synthesizeUberObjectUnionType.d.ts.map