@shaclmate/compiler 2.0.12

package/generators/ts/TypeFactory.js

@@ -0,0 +1,198 @@
+import TermMap from "@rdfjs/term-map";
+import { xsd } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { NodeKind } from "shacl-ast";
+import { BooleanType } from "./BooleanType";
+import { IdentifierType } from "./IdentifierType";
+import { IntersectionType } from "./IntersectionType";
+import { ListType } from "./ListType.js";
+import { LiteralType } from "./LiteralType.js";
+import { NumberType } from "./NumberType.js";
+import { ObjectType } from "./ObjectType.js";
+import { OptionType } from "./OptionType";
+import { SetType } from "./SetType";
+import { StringType } from "./StringType.js";
+import { UnionType } from "./UnionType";
+import { tsName } from "./tsName.js";
+export class TypeFactory {
+    constructor({ configuration }) {
+        this.cachedObjectTypePropertiesByIdentifier = new TermMap();
+        this.cachedObjectTypesByIdentifier = new TermMap();
+        this.configuration = configuration;
+    }
+    createTypeFromAstType(astType) {
+        switch (astType.kind) {
+            case "IdentifierType":
+                return new IdentifierType({
+                    configuration: this.configuration,
+                    defaultValue: astType.defaultValue,
+                    hasValue: astType.hasValue,
+                    nodeKinds: astType.nodeKinds,
+                });
+            case "IntersectionType":
+                return new IntersectionType({
+                    configuration: this.configuration,
+                    memberTypes: astType.memberTypes.map((astType) => this.createTypeFromAstType(astType)),
+                });
+            case "LiteralType": {
+                const datatype = astType.datatype
+                    .altLazy(() => astType.defaultValue.map((defaultValue) => defaultValue.datatype))
+                    .altLazy(() => astType.hasValue.map((hasValue) => hasValue.datatype))
+                    .extractNullable();
+                if (datatype !== null) {
+                    if (datatype.equals(xsd.boolean)) {
+                        return new BooleanType({
+                            configuration: this.configuration,
+                            defaultValue: astType.defaultValue,
+                            hasValue: astType.hasValue,
+                        });
+                    }
+                    if (datatype.equals(xsd.integer)) {
+                        return new NumberType({
+                            configuration: this.configuration,
+                            defaultValue: astType.defaultValue,
+                            hasValue: astType.hasValue,
+                        });
+                    }
+                    if (datatype.equals(xsd.anyURI) || datatype.equals(xsd.string)) {
+                        return new StringType({
+                            configuration: this.configuration,
+                            defaultValue: astType.defaultValue,
+                            hasValue: astType.hasValue,
+                        });
+                    }
+                }
+                return new LiteralType({
+                    configuration: this.configuration,
+                    defaultValue: astType.defaultValue,
+                    hasValue: astType.hasValue,
+                });
+            }
+            case "ObjectType": {
+                if (astType.listItemType.isJust()) {
+                    return new ListType({
+                        configuration: this.configuration,
+                        identifierNodeKind: astType.nodeKinds.has(NodeKind.BLANK_NODE)
+                            ? NodeKind.BLANK_NODE
+                            : NodeKind.IRI,
+                        itemType: this.createTypeFromAstType(astType.listItemType.unsafeCoerce()),
+                        mintingStrategy: astType.mintingStrategy,
+                        rdfType: astType.rdfType,
+                    });
+                }
+                return this.createObjectTypeFromAstType(astType);
+            }
+            case "OptionType":
+                return new OptionType({
+                    configuration: this.configuration,
+                    itemType: this.createTypeFromAstType(astType.itemType),
+                });
+            case "SetType":
+                return new SetType({
+                    configuration: this.configuration,
+                    itemType: this.createTypeFromAstType(astType.itemType),
+                    minCount: astType.minCount,
+                });
+            case "UnionType":
+                return new UnionType({
+                    configuration: this.configuration,
+                    memberTypes: astType.memberTypes.map((astType) => this.createTypeFromAstType(astType)),
+                });
+        }
+    }
+    createObjectTypeFromAstType(astType) {
+        {
+            const cachedObjectType = this.cachedObjectTypesByIdentifier.get(astType.name.identifier);
+            if (cachedObjectType) {
+                return cachedObjectType;
+            }
+        }
+        const identifierType = new IdentifierType({
+            configuration: this.configuration,
+            defaultValue: Maybe.empty(),
+            hasValue: Maybe.empty(),
+            nodeKinds: astType.nodeKinds,
+        });
+        const objectType = new ObjectType({
+            abstract: astType.abstract,
+            configuration: this.configuration,
+            export_: astType.export,
+            identifierType,
+            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
+            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
+            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
+            lazyProperties: () => {
+                const properties = astType.properties.map((astProperty) => this.createObjectTypePropertyFromAstProperty(astProperty));
+                if (astType.parentObjectTypes.length === 0) {
+                    properties.push(new ObjectType.IdentifierProperty({
+                        configuration: this.configuration,
+                        mintingStrategy: astType.mintingStrategy,
+                        name: this.configuration.objectTypeIdentifierPropertyName,
+                        type: identifierType,
+                    }));
+                } // Else parent will have the identifier property
+                // Type discriminator property
+                const typeDiscriminatorValues = new Set();
+                if (!astType.abstract) {
+                    typeDiscriminatorValues.add(objectType.discriminatorValue);
+                }
+                for (const descendantObjectType of objectType.descendantObjectTypes) {
+                    if (!descendantObjectType.abstract) {
+                        typeDiscriminatorValues.add(descendantObjectType.discriminatorValue);
+                    }
+                }
+                properties.push(new ObjectType.TypeDiscriminatorProperty({
+                    abstract: astType.abstract,
+                    configuration: this.configuration,
+                    name: this.configuration.objectTypeDiscriminatorPropertyName,
+                    override: objectType.parentObjectTypes.length > 0 &&
+                        !objectType.parentObjectTypes[0].abstract,
+                    type: {
+                        name: [...typeDiscriminatorValues]
+                            .sort()
+                            .map((name) => `"${name}"`)
+                            .join("|"),
+                    },
+                    value: objectType.discriminatorValue,
+                }));
+                return properties.sort((left, right) => left.name.localeCompare(right.name));
+            },
+            mintingStrategy: astType.mintingStrategy,
+            name: tsName(astType.name),
+            rdfType: astType.rdfType,
+        });
+        this.cachedObjectTypesByIdentifier.set(astType.name.identifier, objectType);
+        return objectType;
+    }
+    createObjectTypePropertyFromAstProperty(astObjectTypeProperty) {
+        {
+            const cachedProperty = this.cachedObjectTypePropertiesByIdentifier.get(astObjectTypeProperty.name.identifier);
+            if (cachedProperty) {
+                return cachedProperty;
+            }
+        }
+        let type;
+        if (astObjectTypeProperty.type.kind === "ObjectType" &&
+            !astObjectTypeProperty.inline) {
+            // Non-inlined object type = its identifier
+            type = new IdentifierType({
+                configuration: this.configuration,
+                defaultValue: Maybe.empty(),
+                hasValue: Maybe.empty(),
+                nodeKinds: astObjectTypeProperty.type.nodeKinds,
+            });
+        }
+        else {
+            type = this.createTypeFromAstType(astObjectTypeProperty.type);
+        }
+        const property = new ObjectType.ShaclProperty({
+            configuration: this.configuration,
+            name: tsName(astObjectTypeProperty.name),
+            path: astObjectTypeProperty.path.iri,
+            type,
+        });
+        this.cachedObjectTypePropertiesByIdentifier.set(astObjectTypeProperty.name.identifier, property);
+        return property;
+    }
+}
+//# sourceMappingURL=TypeFactory.js.map

package/generators/ts/UnionType.d.ts

@@ -0,0 +1,18 @@
+import { Maybe } from "purify-ts";
+import { Type } from "./Type.js";
+export declare class UnionType extends Type {
+    readonly kind = "UnionType";
+    readonly memberTypes: readonly Type[];
+    constructor({ memberTypes, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
+        memberTypes: readonly Type[];
+    });
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get name(): string;
+    private get typesSharedDiscriminatorProperty();
+    equalsFunction(): string;
+    fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    propertySparqlGraphPatternExpression(parameters: Parameters<Type["propertySparqlGraphPatternExpression"]>[0]): Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression;
+    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+}
+//# sourceMappingURL=UnionType.d.ts.map

package/generators/ts/UnionType.js

@@ -0,0 +1,165 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { Type } from "./Type.js";
+const syntheticTypeDiscriminatorPropertyName = "type";
+function syntheticTypeDiscriminatorValue({ type, typeIndex, }) {
+    return `${typeIndex}-${type.name}`;
+}
+export class UnionType extends Type {
+    constructor({ memberTypes, ...superParameters }) {
+        super(superParameters);
+        this.kind = "UnionType";
+        invariant(memberTypes.length >= 2);
+        this.memberTypes = memberTypes;
+    }
+    get discriminatorProperty() {
+        return this.typesSharedDiscriminatorProperty.altLazy(() => Maybe.of({
+            name: syntheticTypeDiscriminatorPropertyName,
+            values: this.memberTypes.map((_, typeIndex) => typeIndex.toString()),
+        }));
+    }
+    get name() {
+        if (this.typesSharedDiscriminatorProperty.isJust()) {
+            // If every type shares a discriminator (e.g., RDF/JS "termType" or generated ObjectType "type"),
+            // just join their names with "|"
+            return `(${this.memberTypes.map((type) => type.name).join(" | ")})`;
+        }
+        return `(${this.memberTypes.map((type, typeIndex) => `{ ${syntheticTypeDiscriminatorPropertyName}: "${syntheticTypeDiscriminatorValue({ type, typeIndex })}", value: ${type.name} }`).join(" | ")})`;
+    }
+    get typesSharedDiscriminatorProperty() {
+        // Do all the composed types share a single discriminator property?
+        let typesSharedDiscriminatorProperty;
+        for (const type of this.memberTypes) {
+            const typeDiscriminatorProperty = type.discriminatorProperty.extract();
+            if (!typeDiscriminatorProperty) {
+                return Maybe.empty();
+            }
+            if (!typesSharedDiscriminatorProperty) {
+                typesSharedDiscriminatorProperty = {
+                    name: typeDiscriminatorProperty.name,
+                    values: typeDiscriminatorProperty.values.concat(),
+                };
+            }
+            else if (typeDiscriminatorProperty.name === typesSharedDiscriminatorProperty.name) {
+                typesSharedDiscriminatorProperty.values =
+                    typesSharedDiscriminatorProperty.values.concat(typeDiscriminatorProperty.values);
+            }
+            else {
+                return Maybe.empty();
+            }
+        }
+        return Maybe.fromNullable(typesSharedDiscriminatorProperty);
+    }
+    equalsFunction() {
+        return `
+(left: ${this.name}, right: ${this.name}) => {
+${this.memberTypes
+            .flatMap((type, typeIndex) => this.typesSharedDiscriminatorProperty
+            .map((typesSharedDiscriminatorProperty) => {
+            // Types share a discriminator property already, use it
+            return type.discriminatorProperty.unsafeCoerce().values.map((value) => `if (left.${typesSharedDiscriminatorProperty.name} === "${value}" && right.${typesSharedDiscriminatorProperty.name} === "${value}") {
+  return ${type.equalsFunction()}(left, right);
+}`);
+        })
+            .orDefaultLazy(() => [
+            // Types don't share a discriminator property, have to use the one we synthesized
+            `if (left.${syntheticTypeDiscriminatorPropertyName} === "${syntheticTypeDiscriminatorValue({ type, typeIndex })}" && right.${syntheticTypeDiscriminatorPropertyName} === "${syntheticTypeDiscriminatorValue({ type, typeIndex })}") {
+  return ${type.equalsFunction()}(left.value, right.value);
+}`,
+        ]))
+            .join("\n")}
+
+  return purify.Left({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "BooleanEquals" }, type: "Property" });
+}`;
+    }
+    fromRdfExpression(parameters) {
+        let expression = "";
+        this.memberTypes.forEach((type, typeIndex) => {
+            let typeExpression = type.fromRdfExpression(parameters);
+            if (!this.typesSharedDiscriminatorProperty.isJust()) {
+                typeExpression = `${typeExpression}.map(value => ({ type: "${typeIndex}-${type.name}" as const, value }) as (${this.name}))`;
+            }
+            typeExpression = `(${typeExpression} as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
+            expression =
+                expression.length > 0
+                    ? `${expression}.altLazy(() => ${typeExpression})`
+                    : typeExpression;
+        });
+        return expression;
+    }
+    hashStatements({ variables, }) {
+        const caseBlocks = [];
+        this.memberTypes.forEach((type, typeIndex) => {
+            if (this.typesSharedDiscriminatorProperty.isJust()) {
+                for (const typeDiscriminatorPropertyValue of type.discriminatorProperty.unsafeCoerce()
+                    .values) {
+                    caseBlocks.push(`case "${typeDiscriminatorPropertyValue}": { ${type.hashStatements({
+                        variables,
+                    })}; break; }`);
+                }
+            }
+            else {
+                caseBlocks.push(`case "${syntheticTypeDiscriminatorValue({
+                    type,
+                    typeIndex,
+                })}": { ${type.hashStatements({ variables: { hasher: variables.hasher, value: `${variables}.value` } })}; break; }`);
+            }
+        });
+        const switchValue = this.typesSharedDiscriminatorProperty
+            .map((typeSharedDiscriminatorProperty) => `${variables.value}.${typeSharedDiscriminatorProperty.name}`)
+            .orDefaultLazy(() => `${variables.value}.${syntheticTypeDiscriminatorPropertyName}`);
+        return [`switch (${switchValue}) { ${caseBlocks.join("\n")} }`];
+    }
+    propertySparqlGraphPatternExpression(parameters) {
+        return new Type.SparqlGraphPatternExpression(`sparqlBuilder.GraphPattern.union(${this.memberTypes
+            .map((type) => type
+            .propertySparqlGraphPatternExpression(parameters)
+            .toSparqlGraphPatternExpression()
+            .toString())
+            .join(", ")})`);
+    }
+    toRdfExpression({ variables, }) {
+        let expression = "";
+        this.memberTypes.forEach((type, typeIndex) => {
+            if (this.typesSharedDiscriminatorProperty.isJust()) {
+                if (expression.length === 0) {
+                    expression = type.toRdfExpression({
+                        variables,
+                    });
+                }
+                else {
+                    expression = `(${type.discriminatorProperty
+                        .unsafeCoerce()
+                        .values.map((value) => `${variables.value}.${this.typesSharedDiscriminatorProperty.unsafeCoerce().name} === "${value}"`)
+                        .join(" || ")}) ? ${type.toRdfExpression({ variables })} : ${expression}`;
+                }
+            }
+            else {
+                if (expression.length === 0) {
+                    expression = type.toRdfExpression({
+                        variables: { ...variables, value: `${variables.value}.value` },
+                    });
+                }
+                else {
+                    // No shared type discriminator between the types, use the one we synthesized
+                    expression = `(${variables.value}.${syntheticTypeDiscriminatorPropertyName} === "${syntheticTypeDiscriminatorValue({ type, typeIndex })}") ? (${type.toRdfExpression({ variables: { ...variables, value: `${variables.value}.value` } })}) : (${expression})`;
+                }
+            }
+        });
+        return expression;
+    }
+}
+__decorate([
+    Memoize()
+], UnionType.prototype, "discriminatorProperty", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "typesSharedDiscriminatorProperty", null);
+//# sourceMappingURL=UnionType.js.map

package/generators/ts/_ObjectType/IdentifierProperty.d.ts

@@ -0,0 +1,23 @@
+import { Maybe } from "purify-ts";
+import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure } from "ts-morph";
+import { MintingStrategy } from "../../../ast";
+import type { IdentifierType } from "../IdentifierType.js";
+import { Property } from "./Property.js";
+export declare class IdentifierProperty extends Property<IdentifierType> {
+    readonly equalsFunction = "purifyHelpers.Equatable.booleanEquals";
+    private readonly mintingStrategy;
+    constructor({ mintingStrategy, ...superParameters }: {
+        mintingStrategy: Maybe<MintingStrategy>;
+        type: IdentifierType;
+    } & ConstructorParameters<typeof Property>[0]);
+    get classConstructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
+    get classPropertyDeclaration(): OptionalKind<PropertyDeclarationStructure>;
+    get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
+    classConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["classConstructorStatements"]>[0]): readonly string[];
+    fromRdfStatements({ variables, }: Parameters<Property<IdentifierType>["fromRdfStatements"]>[0]): readonly string[];
+    hashStatements(parameters: Parameters<Property<IdentifierType>["hashStatements"]>[0]): readonly string[];
+    sparqlGraphPatternExpression(): Maybe<string>;
+    toRdfStatements(): readonly string[];
+}
+//# sourceMappingURL=IdentifierProperty.d.ts.map

package/generators/ts/_ObjectType/IdentifierProperty.js

@@ -0,0 +1,82 @@
+import { Maybe } from "purify-ts";
+import { Scope, } from "ts-morph";
+import { MintingStrategy } from "../../../ast";
+import { Property } from "./Property.js";
+export class IdentifierProperty extends Property {
+    constructor({ mintingStrategy, ...superParameters }) {
+        super(superParameters);
+        this.equalsFunction = "purifyHelpers.Equatable.booleanEquals";
+        this.mintingStrategy = mintingStrategy;
+    }
+    get classConstructorParametersPropertySignature() {
+        return Maybe.of({
+            hasQuestionToken: this.mintingStrategy.isJust(),
+            isReadonly: true,
+            name: this.name,
+            type: this.type.name,
+        });
+    }
+    get classGetAccessorDeclaration() {
+        if (!this.mintingStrategy.isJust()) {
+            return Maybe.empty();
+        }
+        let mintIdentifier;
+        switch (this.mintingStrategy.unsafeCoerce()) {
+            case MintingStrategy.SHA256:
+                mintIdentifier =
+                    "dataFactory.namedNode(`urn:shaclmate:object:${this.type}:${this.hash(sha256.create())}`)";
+                break;
+            case MintingStrategy.UUIDv4:
+                mintIdentifier =
+                    "dataFactory.namedNode(`urn:shaclmate:object:${this.type}:${uuid.v4()}`)";
+                break;
+        }
+        return Maybe.of({
+            name: this.name,
+            returnType: this.type.name,
+            statements: [
+                `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`,
+            ],
+        });
+    }
+    get classPropertyDeclaration() {
+        if (this.mintingStrategy.isJust()) {
+            // Mutable _identifier that will be lazily initialized by the getter
+            return {
+                name: `_${this.name}`,
+                scope: Scope.Private,
+                type: `${this.type.name} | undefined`,
+            };
+        }
+        return {
+            isReadonly: true,
+            name: this.name,
+            type: this.type.name,
+        };
+    }
+    get interfacePropertySignature() {
+        return {
+            isReadonly: true,
+            name: this.name,
+            type: this.type.name,
+        };
+    }
+    classConstructorStatements({ variables, }) {
+        return [
+            `this.${this.mintingStrategy.isJust() ? "_" : ""}${this.name} = ${variables.parameter};`,
+        ];
+    }
+    fromRdfStatements({ variables, }) {
+        return [`const ${this.name} = ${variables.resource}.identifier`];
+    }
+    hashStatements(parameters) {
+        return this.type.hashStatements(parameters);
+    }
+    sparqlGraphPatternExpression() {
+        return Maybe.empty();
+    }
+    toRdfStatements() {
+        return [];
+    }
+}
+//# sourceMappingURL=IdentifierProperty.js.map

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

@@ -0,0 +1,38 @@
+import type { Maybe } from "purify-ts";
+import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
+import type { Configuration } from "../Configuration.js";
+import type { Type } from "../Type.js";
+export declare abstract class Property<TypeT extends {
+    readonly name: string;
+}> {
+    abstract readonly classConstructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    abstract readonly classGetAccessorDeclaration: Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
+    abstract readonly classPropertyDeclaration: OptionalKind<PropertyDeclarationStructure>;
+    abstract readonly equalsFunction: string;
+    abstract readonly interfacePropertySignature: OptionalKind<PropertySignatureStructure>;
+    readonly name: string;
+    readonly type: TypeT;
+    protected readonly configuration: Configuration;
+    constructor({ configuration, name, type, }: {
+        configuration: Configuration;
+        name: string;
+        type: TypeT;
+    });
+    get importStatements(): readonly string[];
+    abstract classConstructorStatements(parameters: {
+        variables: {
+            parameter: string;
+        };
+    }): readonly string[];
+    abstract fromRdfStatements(parameters: {
+        variables: {
+            resource: string;
+        };
+    }): readonly string[];
+    abstract hashStatements(parameters: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    abstract sparqlGraphPatternExpression(): Maybe<string>;
+    abstract toRdfStatements(parameters: {
+        variables: Omit<Parameters<Type["toRdfExpression"]>[0]["variables"], "predicate">;
+    }): readonly string[];
+}
+//# sourceMappingURL=Property.d.ts.map

package/generators/ts/_ObjectType/Property.js

@@ -0,0 +1,11 @@
+export class Property {
+    constructor({ configuration, name, type, }) {
+        this.configuration = configuration;
+        this.name = name;
+        this.type = type;
+    }
+    get importStatements() {
+        return [];
+    }
+}
+//# sourceMappingURL=Property.js.map

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

@@ -0,0 +1,25 @@
+import type * as rdfjs from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
+import type { Type } from "../Type.js";
+import { Property } from "./Property.js";
+export declare class ShaclProperty extends Property<Type> {
+    private readonly path;
+    constructor({ path, ...superParameters }: {
+        path: rdfjs.NamedNode;
+        type: Type;
+    } & ConstructorParameters<typeof Property>[0]);
+    get classConstructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
+    get classPropertyDeclaration(): OptionalKind<PropertyDeclarationStructure>;
+    get equalsFunction(): string;
+    get importStatements(): readonly string[];
+    get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
+    private get pathExpression();
+    classConstructorStatements({ variables, }: Parameters<Property<Type>["classConstructorStatements"]>[0]): readonly string[];
+    fromRdfStatements({ variables, }: Parameters<Property<Type>["fromRdfStatements"]>[0]): readonly string[];
+    hashStatements(parameters: Parameters<Property<Type>["hashStatements"]>[0]): readonly string[];
+    sparqlGraphPatternExpression(): Maybe<string>;
+    toRdfStatements({ variables, }: Parameters<Property<Type>["toRdfStatements"]>[0]): readonly string[];
+}
+//# sourceMappingURL=ShaclProperty.d.ts.map

package/generators/ts/_ObjectType/ShaclProperty.js

@@ -0,0 +1,106 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { pascalCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { Property } from "./Property.js";
+export class ShaclProperty extends Property {
+    constructor({ path, ...superParameters }) {
+        super(superParameters);
+        this.path = path;
+    }
+    get classConstructorParametersPropertySignature() {
+        let hasQuestionToken = false;
+        const typeNames = new Set(); // Remove duplicates with a set
+        for (const conversion of this.type.conversions) {
+            if (conversion.sourceTypeName === "undefined") {
+                hasQuestionToken = true;
+            }
+            else {
+                typeNames.add(conversion.sourceTypeName);
+            }
+        }
+        return Maybe.of({
+            hasQuestionToken,
+            isReadonly: true,
+            name: this.name,
+            type: [...typeNames].sort().join(" | "),
+        });
+    }
+    get classGetAccessorDeclaration() {
+        return Maybe.empty();
+    }
+    get classPropertyDeclaration() {
+        return {
+            isReadonly: true,
+            name: this.name,
+            type: this.type.name,
+        };
+    }
+    get equalsFunction() {
+        return this.type.equalsFunction();
+    }
+    get importStatements() {
+        return this.type.importStatements;
+    }
+    get interfacePropertySignature() {
+        return {
+            isReadonly: true,
+            name: this.name,
+            type: this.type.name,
+        };
+    }
+    get pathExpression() {
+        return `${this.configuration.dataFactoryVariable}.namedNode("${this.path.value}")`;
+    }
+    classConstructorStatements({ variables, }) {
+        const typeConversions = this.type.conversions;
+        if (typeConversions.length === 1) {
+            return [`this.${this.name} = ${variables.parameter};`];
+        }
+        const statements = [];
+        for (const conversion of this.type.conversions) {
+            statements.push(`if (${conversion.sourceTypeCheckExpression ? conversion.sourceTypeCheckExpression(variables.parameter) : `typeof ${variables.parameter} === "${conversion.sourceTypeName}"`}) { this.${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+        }
+        // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
+        statements.push(`{ this.${this.name} = ${variables.parameter}; // never\n }`);
+        return [statements.join(" else ")];
+    }
+    fromRdfStatements({ variables, }) {
+        return [
+            `const _${this.name}Either: purify.Either<rdfjsResource.Resource.ValueError, ${this.type.name}> = ${this.type.fromRdfExpression({ variables: { ...variables, predicate: this.pathExpression, resourceValues: `${variables.resource}.values(${this.pathExpression}, { unique: true })` } })};`,
+            `if (_${this.name}Either.isLeft()) { return _${this.name}Either; }`,
+            `const ${this.name} = _${this.name}Either.unsafeCoerce();`,
+        ];
+    }
+    hashStatements(parameters) {
+        return this.type.hashStatements(parameters);
+    }
+    sparqlGraphPatternExpression() {
+        return Maybe.of(this.type
+            .propertySparqlGraphPatternExpression({
+            variables: {
+                object: `this.variable("${pascalCase(this.name)}")`,
+                predicate: this.pathExpression,
+                subject: "this.subject",
+            },
+        })
+            .toSparqlGraphPatternExpression()
+            .toString());
+    }
+    toRdfStatements({ variables, }) {
+        return [
+            `${variables.resource}.add(${this.pathExpression}, ${this.type.toRdfExpression({
+                variables: { ...variables, predicate: this.pathExpression },
+            })});`,
+        ];
+    }
+}
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "pathExpression", null);
+//# sourceMappingURL=ShaclProperty.js.map