@shaclmate/compiler 2.0.14 → 2.0.15

package/generators/ts/_ObjectType/IdentifierProperty.js

@@ -1,11 +1,12 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Import } from "../Import.js";
+import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { Property } from "./Property.js";
 export class IdentifierProperty extends Property {
-    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, objectTypeDeclarationType, override, ...superParameters }) {
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, override, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "purifyHelpers.Equatable.booleanEquals";
+        this.equalsFunction = "booleanEquals";
         this.mutable = false;
         invariant(this.visibility === "public");
         this.abstract = abstract;
@@ -19,7 +20,6 @@ export class IdentifierProperty extends Property {
         else {
             this.mintingStrategy = "none";
         }
-        this.objectTypeDeclarationType = objectTypeDeclarationType;
         this.lazyObjectTypeMutable = lazyObjectTypeMutable;
         this.override = override;
     }
@@ -76,6 +76,7 @@ export class IdentifierProperty extends Property {
             case "none":
                 // Immutable, public identifier property, no getter
                 return Maybe.of({
+                    isReadonly: true,
                     name: this.name,
                     type: this.type.name,
                 });
@@ -91,11 +92,11 @@ export class IdentifierProperty extends Property {
         }
     }
     get constructorParametersPropertySignature() {
-        if (this.objectTypeDeclarationType === "class" && this.abstract) {
+        if (this.objectType.declarationType === "class" && this.abstract) {
             return Maybe.empty();
         }
         return Maybe.of({
-            hasQuestionToken: this.objectTypeDeclarationType === "class" &&
+            hasQuestionToken: this.objectType.declarationType === "class" &&
                 this.mintingStrategy !== "none",
             isReadonly: true,
             name: this.name,
@@ -103,8 +104,9 @@ export class IdentifierProperty extends Property {
         });
     }
     get declarationImports() {
-        const imports = this.type.useImports.concat();
-        if (this.objectTypeDeclarationType === "class") {
+        const imports = this.type.useImports().concat();
+        if (this.objectType.features.has("hash") &&
+            this.objectType.declarationType === "class") {
             switch (this.mintingStrategy) {
                 case "sha256":
                     imports.push(Import.SHA256);
@@ -130,6 +132,13 @@ export class IdentifierProperty extends Property {
             type: "string",
         };
     }
+    get snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
+        }
+        return snippetDeclarations;
+    }
     classConstructorStatements({ variables, }) {
         if (this.abstract) {
             return [];

package/generators/ts/_ObjectType/Property.d.ts

@@ -1,7 +1,7 @@
 import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure, Scope } from "ts-morph";
-import type { PropertyVisibility } from "../../../enums/index.js";
+import type { PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../../../enums/index.js";
 import type { Import } from "../Import.js";
 import type { Type } from "../Type.js";
 export declare abstract class Property<TypeT extends {
@@ -21,7 +21,7 @@ export declare abstract class Property<TypeT extends {
      */
     abstract readonly constructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
     /**
-     * Function declaration that takes two values of the property and compares them, returning and purifyHelpers.Equatable.EqualsResult.
+     * Function declaration that takes two values of the property and compares them, returning and EqualsResult.
      */
     abstract readonly equalsFunction: string;
     /**
@@ -40,6 +40,15 @@ export declare abstract class Property<TypeT extends {
      * TypeScript identifier-safe name of the property.
      */
     readonly name: string;
+    /**
+     * Reusable function, type, and other declarations that are not particular to this property but that property-specific code
+     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
+     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
+     * as a snippet and reference it.
+     *
+     * The generator deduplicates snippet declarations across all types before adding them to the source.
+     */
+    abstract readonly snippetDeclarations: readonly string[];
     /**
      * Property type
   .   */
@@ -49,9 +58,14 @@ export declare abstract class Property<TypeT extends {
      */
     readonly visibility: PropertyVisibility;
     protected readonly dataFactoryVariable: string;
-    constructor({ dataFactoryVariable, name, type, visibility, }: {
+    protected readonly objectType: {
+        readonly declarationType: TsObjectDeclarationType;
+        readonly features: Set<TsFeature>;
+    };
+    constructor({ dataFactoryVariable, name, objectType, type, visibility, }: {
         dataFactoryVariable: string;
         name: string;
+        objectType: Property<TypeT>["objectType"];
         type: TypeT;
         visibility: PropertyVisibility;
     });

package/generators/ts/_ObjectType/Property.js

@@ -1,9 +1,10 @@
 import { Scope, } from "ts-morph";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 export class Property {
-    constructor({ dataFactoryVariable, name, type, visibility, }) {
+    constructor({ dataFactoryVariable, name, objectType, type, visibility, }) {
         this.dataFactoryVariable = dataFactoryVariable;
         this.name = name;
+        this.objectType = objectType;
         this.type = type;
         this.visibility = visibility;
     }

package/generators/ts/_ObjectType/ShaclProperty.d.ts

@@ -26,6 +26,7 @@ export declare class ShaclProperty extends Property<Type> {
     get equalsFunction(): string;
     get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
     get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get snippetDeclarations(): readonly string[];
     private get declarationComment();
     private get pathExpression();
     classConstructorStatements({ variables, }: Parameters<Property<Type>["classConstructorStatements"]>[0]): readonly string[];

package/generators/ts/_ObjectType/ShaclProperty.js

@@ -50,7 +50,7 @@ export class ShaclProperty extends Property {
         });
     }
     get declarationImports() {
-        return this.type.useImports;
+        return this.type.useImports(this.objectType.features);
     }
     get equalsFunction() {
         return this.type.equalsFunction;
@@ -70,6 +70,9 @@ export class ShaclProperty extends Property {
             type: this.type.jsonName,
         };
     }
+    get snippetDeclarations() {
+        return this.type.snippetDeclarations(this.objectType.features);
+    }
     get declarationComment() {
         return this.comment
             .alt(this.description)

package/generators/ts/_ObjectType/TypeDiscriminatorProperty.d.ts

@@ -1,17 +1,14 @@
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
-import type { TsObjectDeclarationType } from "../../../enums/index.js";
 import { Property } from "./Property.js";
 export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminatorProperty.Type> {
-    readonly equalsFunction = "purifyHelpers.Equatable.strictEquals";
+    readonly equalsFunction = "strictEquals";
     readonly mutable = false;
     readonly value: string;
     private readonly abstract;
-    private readonly objectTypeDeclarationType;
     private readonly override;
-    constructor({ abstract, objectTypeDeclarationType, override, type, value, ...superParameters }: {
+    constructor({ abstract, override, type, value, ...superParameters }: {
         abstract: boolean;
-        objectTypeDeclarationType: TsObjectDeclarationType;
         override: boolean;
         type: TypeDiscriminatorProperty.Type;
         value: string;
@@ -21,6 +18,7 @@ export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminato
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
     get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get snippetDeclarations(): readonly string[];
     classConstructorStatements(): readonly string[];
     fromJsonStatements(): readonly string[];
     fromRdfStatements(): readonly string[];

package/generators/ts/_ObjectType/TypeDiscriminatorProperty.js

@@ -7,15 +7,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { Property } from "./Property.js";
 export class TypeDiscriminatorProperty extends Property {
-    constructor({ abstract, objectTypeDeclarationType, override, type, value, ...superParameters }) {
+    constructor({ abstract, override, type, value, ...superParameters }) {
         super({ ...superParameters, type });
-        this.equalsFunction = "purifyHelpers.Equatable.strictEquals";
+        this.equalsFunction = "strictEquals";
         this.mutable = false;
         invariant(this.visibility === "public");
         this.abstract = abstract;
-        this.objectTypeDeclarationType = objectTypeDeclarationType;
         this.override = override;
         this.value = value;
     }
@@ -53,6 +53,13 @@ export class TypeDiscriminatorProperty extends Property {
             type: this.type.name,
         };
     }
+    get snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.strictEquals);
+        }
+        return snippetDeclarations;
+    }
     classConstructorStatements() {
         return [];
     }
@@ -60,7 +67,7 @@ export class TypeDiscriminatorProperty extends Property {
         return this.fromRdfStatements();
     }
     fromRdfStatements() {
-        return !this.abstract && this.objectTypeDeclarationType === "interface"
+        return !this.abstract && this.objectType.declarationType === "interface"
             ? [`const ${this.name} = "${this.value}" as const`]
             : [];
     }

package/generators/ts/_ObjectType/equalsFunctionOrMethodDeclaration.js

@@ -59,7 +59,7 @@ export function equalsFunctionOrMethodDeclaration() {
                     type: this.name,
                 },
             ],
-        returnType: "purifyHelpers.Equatable.EqualsResult",
+        returnType: "EqualsResult",
         statements: [
             `return ${chain
                 .map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : `chain(() => ${chainPart})`)

package/generators/ts/_ObjectType/fromJsonFunctionDeclarations.js

@@ -17,7 +17,7 @@ export function fromJsonFunctionDeclarations() {
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         propertiesFromJsonFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}.propertiesFromJson(${variables.jsonObject});`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
         initializers.push(`..._super${parentObjectTypeI}`);
-        propertiesFromJsonFunctionReturnType.push(`purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromJson>>`);
+        propertiesFromJsonFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromJson>>`);
     });
     for (const property of this.properties) {
         const propertyFromJsonStatements = property.fromJsonStatements({

package/generators/ts/_ObjectType/fromRdfFunctionDeclarations.js

@@ -20,7 +20,7 @@ export function fromRdfFunctionDeclarations() {
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         propertiesFromRdfFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}.propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, resource: ${variables.resource} });`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
         initializers.push(`..._super${parentObjectTypeI}`);
-        propertiesFromRdfFunctionReturnType.push(`purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromRdf>>`);
+        propertiesFromRdfFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromRdf>>`);
     });
     this.fromRdfType.ifJust((rdfType) => {
         propertiesFromRdfFunctionStatements.push(`if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${this.rdfjsTermExpression(rdfType)})) { return purify.Left(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type\``, predicate: this.rdfjsTermExpression(rdfType) })})); }`);

package/generators/ts/_ObjectType/sparqlConstructQueryFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+export declare function sparqlConstructQueryFunctionDeclaration(this: {
+    readonly name: string;
+}): FunctionDeclarationStructure;
+//# sourceMappingURL=sparqlConstructQueryFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/sparqlConstructQueryFunctionDeclaration.js

@@ -0,0 +1,21 @@
+import { StructureKind } from "ts-morph";
+export function sparqlConstructQueryFunctionDeclaration() {
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "sparqlConstructQuery",
+        parameters: [
+            {
+                hasQuestionToken: true,
+                name: "parameters",
+                type: '{ ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type">',
+            },
+        ],
+        returnType: "sparqljs.ConstructQuery",
+        statements: [
+            "const { ignoreRdfType, subject, ...queryParameters } = parameters ?? {}",
+            `return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.name}.sparqlConstructTemplateTriples({ ignoreRdfType, subject })), type: "query", where: (queryParameters.where ?? []).concat(${this.name}.sparqlWherePatterns({ ignoreRdfType, subject })) };`,
+        ],
+    };
+}
+//# sourceMappingURL=sparqlConstructQueryFunctionDeclaration.js.map

package/generators/ts/_ObjectType/sparqlConstructQueryStringFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+export declare function sparqlConstructQueryStringFunctionDeclaration(this: {
+    readonly name: string;
+}): FunctionDeclarationStructure;
+//# sourceMappingURL=sparqlConstructQueryStringFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/sparqlConstructQueryStringFunctionDeclaration.js

@@ -0,0 +1,20 @@
+import { StructureKind } from "ts-morph";
+export function sparqlConstructQueryStringFunctionDeclaration() {
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "sparqlConstructQueryString",
+        parameters: [
+            {
+                hasQuestionToken: true,
+                name: "parameters",
+                type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions',
+            },
+        ],
+        returnType: "string",
+        statements: [
+            `return new sparqljs.Generator(parameters).stringify(${this.name}.sparqlConstructQuery(parameters));`,
+        ],
+    };
+}
+//# sourceMappingURL=sparqlConstructQueryStringFunctionDeclaration.js.map

package/generators/ts/_ObjectType/sparqlFunctionDeclarations.js

@@ -1,6 +1,8 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { camelCase } from "change-case";
 import { StructureKind } from "ts-morph";
+import { sparqlConstructQueryFunctionDeclaration } from "./sparqlConstructQueryFunctionDeclaration.js";
+import { sparqlConstructQueryStringFunctionDeclaration } from "./sparqlConstructQueryStringFunctionDeclaration.js";
 export function sparqlFunctionDeclarations() {
     if (!this.features.has("sparql")) {
         return [];
@@ -8,43 +10,34 @@ export function sparqlFunctionDeclarations() {
     if (this.extern) {
         return [];
     }
-    const subjectDefault = camelCase(this.name);
     const variables = { subject: "subject", variablePrefix: "variablePrefix" };
     const rdfTypeVariable = `${this.dataFactoryVariable}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    const subjectDefault = camelCase(this.name);
+    const preambleStatements = [
+        `const subject = parameters?.subject ?? ${this.dataFactoryVariable}.variable!("${subjectDefault}");`,
+        `const variablePrefix = parameters?.variablePrefix ?? (subject.termType === "Variable" ? subject.value : "${subjectDefault}");`,
+    ];
+    const sparqlConstructTemplateTriples = [
+        ...this.parentObjectTypes.map((parentObjectType) => `...${parentObjectType.name}.sparqlConstructTemplateTriples({ ignoreRdfType: true, subject, variablePrefix })`),
+        ...(this.fromRdfType.isJust()
+            ? [
+                `...(parameters?.ignoreRdfType ? [] : [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }])`,
+            ]
+            : []),
+        ...this.ownProperties.flatMap((property) => property.sparqlConstructTemplateTriples({ variables })),
+    ];
+    const sparqlWherePatterns = [
+        ...this.parentObjectTypes.map((parentObjectType) => `...${parentObjectType.name}.sparqlWherePatterns({ ignoreRdfType: true, subject, variablePrefix })`),
+        ...(this.fromRdfType.isJust()
+            ? [
+                `...(parameters?.ignoreRdfType ? [] : [{ triples: [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${this.rdfjsTermExpression(this.fromRdfType.unsafeCoerce())} }], type: "bgp" as const }, { triples: [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }], type: "bgp" as const }])`,
+            ]
+            : []),
+        ...this.ownProperties.flatMap((property) => property.sparqlWherePatterns({ variables })),
+    ];
     return [
-        {
-            isExported: true,
-            kind: StructureKind.Function,
-            name: "sparqlConstructQuery",
-            parameters: [
-                {
-                    hasQuestionToken: true,
-                    name: "parameters",
-                    type: '{ ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type">',
-                },
-            ],
-            returnType: "sparqljs.ConstructQuery",
-            statements: [
-                "const { ignoreRdfType, subject, variablePrefix, ...queryParameters } = parameters ?? {}",
-                `return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.name}.sparqlConstructTemplateTriples({ ignoreRdfType, subject })), type: "query", where: (queryParameters.where ?? []).concat(${this.name}.sparqlWherePatterns({ ignoreRdfType, subject, variablePrefix })) };`,
-            ],
-        },
-        {
-            isExported: true,
-            kind: StructureKind.Function,
-            name: "sparqlConstructQueryString",
-            parameters: [
-                {
-                    hasQuestionToken: true,
-                    name: "parameters",
-                    type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions',
-                },
-            ],
-            returnType: "string",
-            statements: [
-                `return new sparqljs.Generator(parameters).stringify(${this.name}.sparqlConstructQuery(parameters));`,
-            ],
-        },
+        sparqlConstructQueryFunctionDeclaration.bind(this)(),
+        sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
         {
             isExported: true,
             kind: StructureKind.Function,
@@ -52,23 +45,16 @@ export function sparqlFunctionDeclarations() {
             parameters: [
                 {
                     hasQuestionToken: true,
-                    name: "parameters",
+                    name: `${sparqlConstructTemplateTriples.length === 0 ? "_" : ""}parameters`,
                     type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                 },
             ],
             returnType: "readonly sparqljs.Triple[]",
             statements: [
-                `const subject = parameters?.subject ?? ${this.dataFactoryVariable}.variable!("${subjectDefault}");`,
-                `const variablePrefix = parameters?.variablePrefix ?? (subject.termType === "Variable" ? subject.value : "${subjectDefault}");`,
-                `return [${[
-                    ...this.parentObjectTypes.map((parentObjectType) => `...${parentObjectType.name}.sparqlConstructTemplateTriples({ ignoreRdfType: true, subject, variablePrefix })`),
-                    ...(this.fromRdfType.isJust()
-                        ? [
-                            `...(parameters?.ignoreRdfType ? [] : [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }])`,
-                        ]
-                        : []),
-                    this.ownProperties.flatMap((property) => property.sparqlConstructTemplateTriples({ variables })),
-                ].join(", ")}];`,
+                ...(sparqlConstructTemplateTriples.length > 0
+                    ? preambleStatements
+                    : []),
+                `return [${sparqlConstructTemplateTriples.join(", ")}];`,
             ],
         },
         {
@@ -77,23 +63,14 @@ export function sparqlFunctionDeclarations() {
             name: "sparqlWherePatterns",
             parameters: [
                 {
-                    name: "parameters",
+                    name: `${sparqlWherePatterns.length === 0 ? "_" : ""}parameters`,
                     type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                 },
             ],
             returnType: "readonly sparqljs.Pattern[]",
             statements: [
-                `const subject = parameters?.subject ?? ${this.dataFactoryVariable}.variable!("${subjectDefault}");`,
-                `const variablePrefix = parameters?.variablePrefix ?? (subject.termType === "Variable" ? subject.value : "${subjectDefault}");`,
-                `return [${[
-                    ...this.parentObjectTypes.map((parentObjectType) => `...${parentObjectType.name}.sparqlWherePatterns({ ignoreRdfType: true, subject, variablePrefix })`),
-                    ...(this.fromRdfType.isJust()
-                        ? [
-                            `...(parameters?.ignoreRdfType ? [] : [{ triples: [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${this.rdfjsTermExpression(this.fromRdfType.unsafeCoerce())} }], type: "bgp" as const }, { triples: [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }], type: "bgp" as const }])`,
-                        ]
-                        : []),
-                    this.ownProperties.flatMap((property) => property.sparqlWherePatterns({ variables })),
-                ].join(", ")}];`,
+                ...(sparqlWherePatterns.length > 0 ? preambleStatements : []),
+                `return [${sparqlWherePatterns.join(", ")}];`,
             ],
         },
     ];

package/generators/ts/_ObjectType/toJsonFunctionOrMethodDeclaration.js

@@ -19,7 +19,7 @@ export function toJsonFunctionOrMethodDeclaration() {
             break;
         case "interface":
             for (const parentObjectType of this.parentObjectTypes) {
-                jsonObjectMembers.push(`...${parentObjectType.name}.toJson(${this.thisVariable});`);
+                jsonObjectMembers.push(`...${parentObjectType.name}.toJson(${this.thisVariable})`);
             }
             parameters.push({
                 name: this.thisVariable,

package/input/generated.d.ts

@@ -1,8 +1,8 @@
 import type * as rdfjs from "@rdfjs/types";
 import { PropertyPath } from "@shaclmate/shacl-ast/PropertyPath.js";
 import * as purify from "purify-ts";
-import type * as purifyHelpers from "purify-ts-helpers";
 import * as rdfjsResource from "rdfjs-resource";
+type UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never;
 export interface BaseShaclCoreShape {
     readonly and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
     readonly classes: readonly rdfjs.NamedNode[];
@@ -94,7 +94,7 @@ export declare namespace ShaclCorePropertyShape {
         path: PropertyPath;
         type: "ShaclCorePropertyShape" | "ShaclmatePropertyShape";
         uniqueLang: purify.Maybe<boolean>;
-    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof BaseShaclCoreShape.propertiesFromRdf>>>;
+    } & UnwrapR<ReturnType<typeof BaseShaclCoreShape.propertiesFromRdf>>>;
     function fromRdf(parameters: Parameters<typeof ShaclCorePropertyShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyShape>;
 }
 export interface ShaclmatePropertyShape extends ShaclCorePropertyShape {
@@ -118,7 +118,7 @@ export declare namespace ShaclmatePropertyShape {
         name: purify.Maybe<string>;
         type: "ShaclmatePropertyShape";
         visibility: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_Visibility_Private" | "http://minorg.github.io/shaclmate/ns#_Visibility_Protected" | "http://minorg.github.io/shaclmate/ns#_Visibility_Public">>;
-    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ShaclCorePropertyShape.propertiesFromRdf>>>;
+    } & UnwrapR<ReturnType<typeof ShaclCorePropertyShape.propertiesFromRdf>>>;
     function fromRdf(parameters: Parameters<typeof ShaclmatePropertyShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclmatePropertyShape>;
 }
 export interface OwlOntology {
@@ -142,8 +142,8 @@ export declare namespace OwlOntology {
 export interface ShaclmateOntology extends OwlOntology {
     readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
     readonly tsDataFactoryVariable: purify.Maybe<string>;
-    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
-    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
     readonly tsImports: readonly string[];
     readonly tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
     readonly tsObjectIdentifierPropertyName: purify.Maybe<string>;
@@ -159,14 +159,14 @@ export declare namespace ShaclmateOntology {
     }): purify.Either<rdfjsResource.Resource.ValueError, {
         identifier: rdfjs.BlankNode | rdfjs.NamedNode;
         tsDataFactoryVariable: purify.Maybe<string>;
-        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
-        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
         tsImports: readonly string[];
         tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
         tsObjectIdentifierPropertyName: purify.Maybe<string>;
         tsObjectTypeDiscriminatorPropertyName: purify.Maybe<string>;
         type: "ShaclmateOntology";
-    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof OwlOntology.propertiesFromRdf>>>;
+    } & UnwrapR<ReturnType<typeof OwlOntology.propertiesFromRdf>>>;
     function fromRdf(parameters: Parameters<typeof ShaclmateOntology.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclmateOntology>;
 }
 export interface ShaclCoreNodeShape extends BaseShaclCoreShape {
@@ -188,7 +188,7 @@ export declare namespace ShaclCoreNodeShape {
         ignoredProperties: purify.Maybe<readonly rdfjs.NamedNode[]>;
         properties: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
         type: "ShaclCoreNodeShape" | "ShaclmateNodeShape";
-    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof BaseShaclCoreShape.propertiesFromRdf>>>;
+    } & UnwrapR<ReturnType<typeof BaseShaclCoreShape.propertiesFromRdf>>>;
     function fromRdf(parameters: Parameters<typeof ShaclCoreNodeShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCoreNodeShape>;
 }
 export interface ShaclmateNodeShape extends ShaclCoreNodeShape {
@@ -201,8 +201,8 @@ export interface ShaclmateNodeShape extends ShaclCoreNodeShape {
     readonly mutable: purify.Maybe<boolean>;
     readonly name: purify.Maybe<string>;
     readonly toRdfTypes: readonly rdfjs.NamedNode[];
-    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
-    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
     readonly tsImports: readonly string[];
     readonly tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
     readonly tsObjectIdentifierPropertyName: purify.Maybe<string>;
@@ -225,14 +225,14 @@ export declare namespace ShaclmateNodeShape {
         mutable: purify.Maybe<boolean>;
         name: purify.Maybe<string>;
         toRdfTypes: readonly rdfjs.NamedNode[];
-        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
-        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
         tsImports: readonly string[];
         tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
         tsObjectIdentifierPropertyName: purify.Maybe<string>;
         tsObjectTypeDiscriminatorPropertyName: purify.Maybe<string>;
         type: "ShaclmateNodeShape";
-    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ShaclCoreNodeShape.propertiesFromRdf>>>;
+    } & UnwrapR<ReturnType<typeof ShaclCoreNodeShape.propertiesFromRdf>>>;
     function fromRdf(parameters: Parameters<typeof ShaclmateNodeShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclmateNodeShape>;
 }
 export interface ShaclCorePropertyGroup {
@@ -271,4 +271,5 @@ export declare namespace ShaclmateShape {
         resource: rdfjsResource.Resource;
     }): purify.Either<rdfjsResource.Resource.ValueError, ShaclmateShape>;
 }
+export {};
 //# sourceMappingURL=generated.d.ts.map