@shaclmate/compiler 4.0.20 → 4.0.22

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -38,6 +38,7 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     } & ConstructorParameters<typeof AbstractType>[0]);
     get recursive(): boolean;
     get schema(): Code;
+    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     protected get schemaObject(): {
         item: Code;
         kind: Code;

package/dist/generators/ts/AbstractContainerType.js

@@ -31,6 +31,9 @@ export class AbstractContainerType extends AbstractType {
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
     get schemaObject() {
         return {
             ...super.schemaObject,

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -32,6 +32,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     get recursive(): boolean;
     get schema(): Code;
     get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
@@ -39,9 +40,9 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         kind: Code;
     };
     hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     protected resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }: {

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -63,6 +63,9 @@ export class AbstractLazyObjectType extends AbstractType {
             resolveType: this.resolveType.schemaType,
         }}`;
     }
+    get toRdfResourceValueTypes() {
+        return this.partialType.toRdfResourceValueTypes;
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partial() }))`;
     }
@@ -86,15 +89,15 @@ export class AbstractLazyObjectType extends AbstractType {
             },
         });
     }
+    jsonSchema(parameters) {
+        return this.partialType.jsonSchema(parameters);
+    }
     jsonType(parameters) {
         return this.partialType.jsonType(parameters);
     }
     jsonUiSchemaElement(parameters) {
         return this.partialType.jsonUiSchemaElement(parameters);
     }
-    jsonSchema(parameters) {
-        return this.partialType.jsonSchema(parameters);
-    }
     toJsonExpression({ variables, }) {
         return this.partialType.toJsonExpression({
             variables: {

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -107,7 +107,7 @@ export namespace ${syntheticNamePrefix}Json {
             staticModuleDeclarations[`${syntheticNamePrefix}fromRdfResourceValues`] =
                 code `export const ${syntheticNamePrefix}fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
             staticModuleDeclarations[`${syntheticNamePrefix}toRdfResourceValues`] =
-                code `export const ${syntheticNamePrefix}toRdfResourceValues: ${snippets.ToRdfResourceValuesFunction}<${this.name}> = ${this.inlineToRdfResourceValuesFunction};`;
+                code `export const ${syntheticNamePrefix}toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
         }
         if (this.features.has("sparql")) {
             staticModuleDeclarations[`${syntheticNamePrefix}valueSparqlConstructTriples`] =

package/dist/generators/ts/AbstractTermType.d.ts

@@ -32,6 +32,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get schema(): Code;
     get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
+    get toRdfResourceValueTypes(): Set<"BlankNode" | "Literal" | "NamedNode">;
     get valueSparqlConstructTriplesFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];

package/dist/generators/ts/AbstractTermType.js

@@ -93,6 +93,9 @@ export class AbstractTermType extends AbstractType {
     get termTypes() {
         return new Set([...this.nodeKinds].map(NodeKind.toTermType));
     }
+    get toRdfResourceValueTypes() {
+        return new Set([...this.nodeKinds].map(NodeKind.toTermType));
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `((_: object) => [])`;
     }
@@ -170,6 +173,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "termTypes", null);
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "valueSparqlConstructTriplesFunction", null);

package/dist/generators/ts/AbstractType.d.ts

@@ -217,6 +217,10 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): Code;
+    /**
+     * The type(s) of the array elements produced by the toRdfResourceValuesExpression.
+     */
+    abstract readonly toRdfResourceValueTypes: ReadonlySet<"BlankNode" | "NamedNode" | "Literal">;
     /**
      * An expression that converts a property value of this type to a value or an array of values that can be .add'd to a Resource with
      *   resource.add(predicate, convertedValue, graph)

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -10,7 +10,6 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     private readonly discriminant;
     private readonly identifierType;
     readonly abstract = false;
-    private readonly lazyMembers;
     readonly recursive: boolean;
     constructor({ identifierType, members, recursive, ...superParameters }: {
         identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
@@ -25,6 +24,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     get mutable(): boolean;
     get schema(): Code;
     get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get typeofs(): AbstractType["typeofs"];
     protected get concreteMembers(): readonly AbstractUnionType.ConcreteMember<MemberTypeT>[];
     protected get inlineEqualsFunction(): Code;
@@ -32,19 +32,20 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     protected get inlineFilterType(): Code;
     protected get inlineFromJsonFunction(): Code;
     protected get inlineFromRdfResourceValuesFunction(): Code;
-    protected get inlineJsonType(): AbstractType.JsonType;
     protected get inlineJsonSchema(): Code;
+    protected get inlineJsonType(): AbstractType.JsonType;
     protected get inlineName(): Code;
-    protected get inlineValueSparqlConstructTriplesFunction(): Code;
-    protected get inlineValueSparqlWherePatternsFunction(): Code;
     protected get inlineToJsonFunction(): Code;
     protected get inlineToRdfResourceValuesFunction(): Code;
+    protected get inlineValueSparqlConstructTriplesFunction(): Code;
+    protected get inlineValueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
         kind: Code;
         members: Code;
     };
     jsonUiSchemaElement(): Maybe<Code>;
     protected inlineHashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    private readonly lazyMembers;
 }
 type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
 type ExtrinsicDiscriminant = {

package/dist/generators/ts/AbstractUnionType.js

@@ -13,24 +13,10 @@ import { removeUndefined } from "./removeUndefined.js";
 import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-const emptyTermTypesSet = new Set();
-function termTypes(type) {
-    switch (type.kind) {
-        case "BlankNodeType":
-        case "IriType":
-        case "IdentifierType":
-        case "LiteralType":
-        case "TermType":
-            return type.termTypes;
-        default:
-            return emptyTermTypesSet;
-    }
-}
 export class AbstractUnionType extends AbstractType {
     discriminant;
     identifierType;
     abstract = false;
-    lazyMembers;
     recursive;
     constructor({ identifierType, members, recursive, ...superParameters }) {
         super(superParameters);
@@ -222,6 +208,15 @@ export class AbstractUnionType extends AbstractType {
             }}`), { on: ";" })} }`,
         }}`;
     }
+    get toRdfResourceValueTypes() {
+        const set = new Set();
+        for (const member of this.members) {
+            for (const value of member.type.toRdfResourceValueTypes) {
+                set.add(value);
+            }
+        }
+        return set;
+    }
     get typeofs() {
         return NonEmptyList.fromArray(this.concreteMembers.flatMap((member) => member.type.typeofs)).unsafeCoerce();
     }
@@ -318,55 +313,55 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
     }))
 ) satisfies ${snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
     }
-    get inlineJsonType() {
+    get inlineJsonSchema() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
             case "hybrid":
-                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
-                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
+                            return code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
                         case "intrinsic":
-                            return code `${jsonType}`;
+                            return type.jsonSchema({
+                                includeDiscriminantProperty: true,
+                                context: "type",
+                            });
                         default:
                             throw new Error();
                     }
-                }), { on: "|" })})`);
+                }), { on: "," })}]).readonly()`;
             case "intrinsic":
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
+                    includeDiscriminantProperty: true,
+                    context: "type",
+                })), { on: "," })}]).readonly()`;
             case "typeof":
-                return new AbstractType.JsonType(joinCode(this.concreteMembers.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
+                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
                 throw discriminant;
         }
     }
-    get inlineJsonSchema() {
+    get inlineJsonType() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
+                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
             case "hybrid":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ primaryDiscriminantValue, type }, memberI) => {
+                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
-                            return code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
+                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
                         case "intrinsic":
-                            return type.jsonSchema({
-                                includeDiscriminantProperty: true,
-                                context: "type",
-                            });
+                            return code `${jsonType}`;
                         default:
                             throw new Error();
                     }
-                }), { on: "," })}]).readonly()`;
+                }), { on: "|" })})`);
             case "intrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
-                    includeDiscriminantProperty: true,
-                    context: "type",
-                })), { on: "," })}]).readonly()`;
             case "typeof":
-                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
+                return new AbstractType.JsonType(joinCode(this.concreteMembers.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
             default:
                 throw discriminant;
         }
@@ -400,28 +395,6 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
                 throw new Error("should never reach this point");
         }
     }
-    get inlineValueSparqlConstructTriplesFunction() {
-        return code `\
-((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
-  let triples: ${imports.sparqljs}.Triple[] = [];
-
-  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
-triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
-  
-  return triples;
-}) satisfies ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
-    }
-    get inlineValueSparqlWherePatternsFunction() {
-        return code `\
-((({ filter, schema, ...otherParameters }) => {
-  const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
-
-  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
-unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
-  
-  return [{ patterns: unionPatterns, type: "union" }];
-}) satisfies ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
-    }
     get inlineToJsonFunction() {
         return code `\
 ((value: ${this.name}): ${this.jsonType().name} => {
@@ -432,7 +405,19 @@ ${joinCode(this.concreteMembers.map(({ typeCheck, typeToJsonExpression, unwrap,
     }
     get inlineToRdfResourceValuesFunction() {
         return code `\
-(((value, _options) => {
+(((value, _options): (${joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
+            switch (toRdfResourceValueType) {
+                case "BlankNode":
+                    return code `${imports.BlankNode}`;
+                case "Literal":
+                    return code `${imports.Literal}`;
+                case "NamedNode":
+                    return code `${imports.NamedNode}`;
+                default:
+                    toRdfResourceValueType;
+                    throw new Error();
+            }
+        }), { on: " | " })})[] => {
 ${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
             variables: {
                 graph: code `_options.graph`,
@@ -444,7 +429,29 @@ ${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if ($
         })}; }`))}
 
   throw new Error("unable to serialize to RDF");
-}) as ${snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
+}) satisfies ${snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
+    }
+    get inlineValueSparqlConstructTriplesFunction() {
+        return code `\
+((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
+  let triples: ${imports.sparqljs}.Triple[] = [];
+
+  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
+triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
+  
+  return triples;
+}) satisfies ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
+    }
+    get inlineValueSparqlWherePatternsFunction() {
+        return code `\
+((({ filter, schema, ...otherParameters }) => {
+  const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
+
+  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
+unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
+  
+  return [{ patterns: unionPatterns, type: "union" }];
+}) satisfies ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
     }
     get schemaObject() {
         return {
@@ -469,6 +476,7 @@ ${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if ($
         })
             .concat())} }`);
     }
+    lazyMembers;
 }
 __decorate([
     Memoize()
@@ -485,6 +493,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "typeofs", null);
@@ -512,6 +523,19 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "inlineValueSparqlWherePatternsFunction", null);
+function termTypes(type) {
+    switch (type.kind) {
+        case "BlankNodeType":
+        case "IriType":
+        case "IdentifierType":
+        case "LiteralType":
+        case "TermType":
+            return type.termTypes;
+        default:
+            return emptyTermTypesSet;
+    }
+}
+const emptyTermTypesSet = new Set();
 export var Discriminant;
 (function (Discriminant) {
     function infer(members) {

package/dist/generators/ts/NamedObjectType.d.ts

@@ -77,6 +77,7 @@ export declare class NamedObjectType extends AbstractType {
     get properties(): readonly NamedObjectType.Property[];
     get schema(): Code;
     get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get toRdfjsResourceType(): Code;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;

package/dist/generators/ts/NamedObjectType.js

@@ -4,6 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { NodeKind } from "@shaclmate/shacl-ast";
 import { camelCase } from "change-case";
 import { Maybe, NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
@@ -228,6 +229,9 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get schemaType() {
         return code `typeof ${this.schema}`;
     }
+    get toRdfResourceValueTypes() {
+        return new Set([...this.identifierType.nodeKinds].map(NodeKind.toTermType));
+    }
     get toRdfjsResourceType() {
         if (this.parentObjectTypes.length > 0) {
             return this.parentObjectTypes[0].toRdfjsResourceType;
@@ -396,6 +400,9 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "toRdfjsResourceType", null);

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js

@@ -20,7 +20,7 @@ export function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration() {
     }
     parameters.push(code `options?: Parameters<${snippets.ToRdfResourceFunction}<${this.name}>>[1]`);
     const statements = [
-        code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${imports.ResourceSet}(${imports.datasetFactory}.dataset(), { dataFactory: ${imports.dataFactory} });`,
+        code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: ${imports.datasetFactory}.dataset() });`,
     ];
     if (this.parentObjectTypes.length > 0) {
         const superToRdfOptions = code `{ ${variables.ignoreRdfType}: true, ${variables.graph}: options?.${variables.graph}, ${variables.resourceSet} }`;

package/dist/generators/ts/_snippets/snippets_ToRdfResourceValuesFunction.js

@@ -2,9 +2,10 @@ import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_PropertyPath } from "./snippets_PropertyPath.js";
+const ReturnT = code `${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}`;
 export const snippets_ToRdfResourceValuesFunction = conditionalOutput(`${syntheticNamePrefix}ToRdfResourceValuesFunction`, code `\
-export type ${syntheticNamePrefix}ToRdfResourceValuesFunction<T> =
-  (value: T,
+export type ${syntheticNamePrefix}ToRdfResourceValuesFunction<ValueT, ReturnT extends ${ReturnT} = ${ReturnT}> =
+  (value: ValueT,
    options: {
      graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
      ignoreRdfType?: boolean;
@@ -12,5 +13,5 @@ export type ${syntheticNamePrefix}ToRdfResourceValuesFunction<T> =
      resource: ${imports.Resource};
      resourceSet: ${imports.ResourceSet};
    }
-  ) => (bigint | boolean | number | string | ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode})[];`);
+  ) => ReturnT[];`);
 //# sourceMappingURL=snippets_ToRdfResourceValuesFunction.js.map

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -37,7 +37,7 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
   }
 
   protected ${syntheticNamePrefix}resourceSet(): ${imports.ResourceSet} {
-    return new ${imports.ResourceSet}(this.${syntheticNamePrefix}dataset(), { dataFactory: ${imports.dataFactory} });
+    return new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: this.${syntheticNamePrefix}dataset() });
   }
 
   ${joinCode([

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -161,7 +161,7 @@ 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(namedObjectType.${syntheticNamePrefix}fromRdfResource(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
+        objects.push(await liftEither(namedObjectType.${syntheticNamePrefix}fromRdfResource(new ${imports.Resource}({ dataFactory: ${imports.dataFactory}, dataset: dataset, identifier: identifier as ${imports.NamedNode} }), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
       }
       return objects;
     });

package/dist/input/generated.d.ts

@@ -80,13 +80,13 @@ export type $ToRdfResourceFunction<T> = (value: T, options?: {
     ignoreRdfType?: boolean;
     resourceSet?: ResourceSet;
 }) => Resource;
-export type $ToRdfResourceValuesFunction<T> = (value: T, options: {
+export type $ToRdfResourceValuesFunction<ValueT, ReturnT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> = (value: ValueT, options: {
     graph?: Exclude<Quad_Graph, Variable>;
     ignoreRdfType?: boolean;
     propertyPath: $PropertyPath;
     resource: Resource;
     resourceSet: ResourceSet;
-}) => (bigint | boolean | number | string | BlankNode | Literal | NamedNode)[];
+}) => ReturnT[];
 export interface PropertyShape {
     readonly $identifier: PropertyShape.$Identifier;
     readonly $type: "PropertyShape";
@@ -2695,7 +2695,13 @@ export declare namespace Shape {
         };
     };
     const $toRdfResource: $ToRdfResourceFunction<Shape>;
-    const $toRdfResourceValues: $ToRdfResourceValuesFunction<Shape>;
+    const $toRdfResourceValues: (value: Shape, _options: {
+        graph?: Exclude<Quad_Graph, Variable>;
+        ignoreRdfType?: boolean;
+        propertyPath: $PropertyPath;
+        resource: Resource;
+        resourceSet: ResourceSet;
+    }) => (BlankNode | NamedNode)[];
     function isShape(object: $Object): object is Shape;
 }
 export type $Object = NodeShape | Ontology | PropertyGroup | PropertyShape;
@@ -3733,7 +3739,13 @@ export declare namespace $Object {
         };
     };
     const $toRdfResource: $ToRdfResourceFunction<$Object>;
-    const $toRdfResourceValues: $ToRdfResourceValuesFunction<$Object>;
+    const $toRdfResourceValues: (value: $Object, _options: {
+        graph?: Exclude<Quad_Graph, Variable>;
+        ignoreRdfType?: boolean;
+        propertyPath: $PropertyPath;
+        resource: Resource;
+        resourceSet: ResourceSet;
+    }) => (BlankNode | NamedNode)[];
 }
 export interface $ObjectSet {
     nodeShape(identifier: NodeShape.$Identifier, options?: {

package/dist/input/generated.js

@@ -2166,7 +2166,10 @@ export var PropertyShape;
     };
     function $toRdfResource(_propertyShape, options) {
         const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+            new ResourceSet({
+                dataFactory: dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
         const resource = resourceSet.resource(_propertyShape.$identifier);
         if (!options?.ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"), options?.graph);
@@ -2546,7 +2549,10 @@ export var PropertyGroup;
     };
     function $toRdfResource(_propertyGroup, options) {
         const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+            new ResourceSet({
+                dataFactory: dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
         const resource = resourceSet.resource(_propertyGroup.$identifier);
         if (!options?.ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), options?.graph);
@@ -2974,7 +2980,10 @@ export var Ontology;
     };
     function $toRdfResource(_ontology, options) {
         const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+            new ResourceSet({
+                dataFactory: dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
         const resource = resourceSet.resource(_ontology.$identifier);
         if (!options?.ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), options?.graph);
@@ -5315,7 +5324,10 @@ export var NodeShape;
     };
     function $toRdfResource(_nodeShape, options) {
         const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+            new ResourceSet({
+                dataFactory: dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
         const resource = resourceSet.resource(_nodeShape.$identifier);
         if (!options?.ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"), options?.graph);
@@ -6069,7 +6081,10 @@ export class $RdfjsDatasetObjectSet {
         return this.#dataset();
     }
     $resourceSet() {
-        return new ResourceSet(this.$dataset(), { dataFactory: dataFactory });
+        return new ResourceSet({
+            dataFactory: dataFactory,
+            dataset: this.$dataset(),
+        });
     }
     async nodeShape(identifier, options) {
         return this.nodeShapeSync(identifier, options);

package/package.json

@@ -1,15 +1,15 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.20",
+    "@shaclmate/shacl-ast": "4.0.22",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
     "@rdfjs/term-set": "~2.0.3",
     "@rdfjs/types": "~2.0.1",
-    "@rdfx/data-factory": "0.0.11",
-    "@rdfx/literal": "0.0.11",
-    "@rdfx/resource": "0.0.11",
-    "@rdfx/string": "0.0.11",
+    "@rdfx/data-factory": "0.0.12",
+    "@rdfx/literal": "0.0.12",
+    "@rdfx/resource": "0.0.12",
+    "@rdfx/string": "0.0.12",
     "@sindresorhus/base62": "~0.1.0",
     "@tpluscode/rdf-ns-builders": "~4.3.0",
     "@types/rdfjs__dataset": "~2.0.7",
@@ -70,5 +70,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.20"
+  "version": "4.0.22"
 }