@shaclmate/compiler 2.0.12

package/generators/ts/ListType.js

@@ -0,0 +1,119 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { NodeKind } from "shacl-ast";
+import { MintingStrategy } from "../../ast";
+import { Type } from "./Type.js";
+export class ListType extends Type {
+    constructor({ identifierNodeKind, itemType, mintingStrategy, rdfType, ...superParameters }) {
+        super(superParameters);
+        this.kind = "ListType";
+        this.identifierNodeKind = identifierNodeKind;
+        this.itemType = itemType;
+        this.mintingStrategy = mintingStrategy.orDefault(MintingStrategy.SHA256);
+        this.rdfType = rdfType;
+    }
+    get discriminatorProperty() {
+        return Maybe.empty();
+    }
+    get importStatements() {
+        if (this.identifierNodeKind === NodeKind.IRI) {
+            return ['import { sha256 } from "js-sha256";'];
+        }
+        return [];
+    }
+    get name() {
+        return `readonly ${this.itemType.name}[]`;
+    }
+    chainSparqlGraphPatternExpression({ variables, }) {
+        return Maybe.of(new Type.SparqlGraphPatternsExpression(`new sparqlBuilder.RdfListGraphPatterns({ ${this.itemType
+            .chainSparqlGraphPatternExpression({
+            variables: {
+                subject: "itemVariable",
+            },
+        })
+            .map((itemSparqlGraphPatternsExpression) => `itemGraphPatterns: (itemVariable) => ${itemSparqlGraphPatternsExpression.toSparqlGraphPatternsExpression()}, `)
+            .orDefault("")} rdfList: ${variables.subject} })`));
+    }
+    equalsFunction() {
+        return `(left, right) => purifyHelpers.Arrays.equals(left, right, ${this.itemType.equalsFunction()})`;
+    }
+    fromRdfExpression({ variables, }) {
+        return `${variables.resourceValues}.head().chain(value => value.toList()).map(values => values.flatMap(value => ${this.itemType.fromRdfExpression({ variables: { ...variables, resourceValues: "value.toValues()" } })}.toMaybe().toList()))`;
+    }
+    hashStatements({ variables, }) {
+        return [
+            `for (const element of ${variables.value}) { ${this.itemType.hashStatements({ variables: { ...variables, value: "element" } }).join("\n")} }`,
+        ];
+    }
+    toRdfExpression({ variables, }) {
+        let listIdentifier;
+        let mutableResourceTypeName;
+        let resourceSetMethodName;
+        let subListIdentifier;
+        switch (this.identifierNodeKind) {
+            case NodeKind.BLANK_NODE: {
+                listIdentifier = subListIdentifier = "dataFactory.blankNode()";
+                mutableResourceTypeName = "rdfjsResource.MutableResource";
+                resourceSetMethodName = "mutableResource";
+                break;
+            }
+            case NodeKind.IRI: {
+                switch (this.mintingStrategy) {
+                    case MintingStrategy.SHA256:
+                        listIdentifier = `dataFactory.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
+        (hasher, item) => {
+          ${this.itemType.hashStatements({ variables: { hasher: "hasher", value: "item" } })}
+          return hasher;
+        },
+        sha256.create(),
+      )}\`)`;
+                        break;
+                    case MintingStrategy.UUIDv4:
+                        listIdentifier =
+                            "dataFactory.namedNode(`urn:shaclmate:list:${uuid.v4()}`)";
+                        break;
+                }
+                mutableResourceTypeName =
+                    "rdfjsResource.MutableResource<rdfjs.NamedNode>";
+                resourceSetMethodName = "mutableNamedResource";
+                subListIdentifier =
+                    "dataFactory.namedNode(`${listResource.identifier.value}:${itemIndex}`)";
+                break;
+            }
+        }
+        return `${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex) => {
+    if (itemIndex === 0) {
+      currentSubListResource = listResource;
+    } else {
+      const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}({
+        identifier: ${subListIdentifier},
+        mutateGraph: ${variables.mutateGraph},
+      });
+      currentSubListResource!.add(dataFactory.namedNode("${rdf.rest.value}"), newSubListResource.identifier);
+      currentSubListResource = newSubListResource;
+    }
+    
+    ${this.rdfType.map((rdfType) => `currentSubListResource.add(dataFactory.namedNode("${rdf.type.value}"), dataFactory.namedNode("${rdfType.value}"))`).orDefault("")}
+        
+    currentSubListResource.add(dataFactory.namedNode("${rdf.first.value}"), ${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: `dataFactory.namedNode("${rdf.first.value}")`, resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
+
+    if (itemIndex + 1 === ${variables.value}.length) {
+      currentSubListResource.add(dataFactory.namedNode("${rdf.rest.value}"), dataFactory.namedNode("${rdf.nil.value}"));
+    }
+    
+    return { currentSubListResource, listResource };
+  },
+  {
+    currentSubListResource: null,
+    listResource: resourceSet.${resourceSetMethodName}({
+      identifier: ${listIdentifier},
+      mutateGraph: ${variables.mutateGraph}
+    }),
+  } as {
+    currentSubListResource: ${mutableResourceTypeName} | null;
+    listResource: ${mutableResourceTypeName};
+  },
+).listResource.identifier`;
+    }
+}
+//# sourceMappingURL=ListType.js.map

package/generators/ts/LiteralType.d.ts

@@ -0,0 +1,14 @@
+import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { RdfjsTermType } from "./RdfjsTermType.js";
+import type { Type } from "./Type";
+export declare class LiteralType extends RdfjsTermType<Literal> {
+    readonly kind = "LiteralType";
+    get conversions(): readonly Type.Conversion[];
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get importStatements(): readonly string[];
+    get name(): string;
+    fromRdfResourceValueExpression({ variables, }: Parameters<RdfjsTermType<Literal>["fromRdfResourceValueExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<RdfjsTermType<Literal>["hashStatements"]>[0]): readonly string[];
+}
+//# sourceMappingURL=LiteralType.d.ts.map

package/generators/ts/LiteralType.js

@@ -0,0 +1,61 @@
+import { Maybe } from "purify-ts";
+import { RdfjsTermType } from "./RdfjsTermType.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression";
+export class LiteralType extends RdfjsTermType {
+    constructor() {
+        super(...arguments);
+        this.kind = "LiteralType";
+    }
+    get conversions() {
+        const conversions = [];
+        conversions.push({
+            conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+            sourceTypeName: "boolean",
+        });
+        conversions.push({
+            conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+            sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof Date`,
+            sourceTypeName: "Date",
+        });
+        conversions.push({
+            conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+            sourceTypeName: "number",
+        });
+        conversions.push({
+            conversionExpression: (value) => `${this.configuration.dataFactoryVariable}.literal(${value})`,
+            sourceTypeName: "string",
+        });
+        this.defaultValue.ifJust((defaultValue) => {
+            conversions.push({
+                conversionExpression: () => rdfjsTermExpression(defaultValue, this.configuration),
+                sourceTypeName: "undefined",
+            });
+        });
+        conversions.push({
+            conversionExpression: (value) => value,
+            sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+            sourceTypeName: this.name,
+        });
+        return conversions;
+    }
+    get discriminatorProperty() {
+        return Maybe.of({
+            name: "termType",
+            type: "string",
+            values: ["Literal"],
+        });
+    }
+    get importStatements() {
+        return ["// @ts-ignore", 'import * as rdfLiteral from "rdf-literal";'];
+    }
+    get name() {
+        return "rdfjs.Literal";
+    }
+    fromRdfResourceValueExpression({ variables, }) {
+        return `${variables.resourceValue}.toLiteral()`;
+    }
+    hashStatements({ variables, }) {
+        return [`${variables.hasher}.update(${variables.value}.value);`];
+    }
+}
+//# sourceMappingURL=LiteralType.js.map

package/generators/ts/NumberType.d.ts

@@ -0,0 +1,7 @@
+import { PrimitiveType } from "./PrimitiveType.js";
+export declare class NumberType extends PrimitiveType {
+    get name(): string;
+    fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType["fromRdfResourceValueExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<PrimitiveType["hashStatements"]>[0]): readonly string[];
+}
+//# sourceMappingURL=NumberType.d.ts.map

package/generators/ts/NumberType.js

@@ -0,0 +1,13 @@
+import { PrimitiveType } from "./PrimitiveType.js";
+export class NumberType extends PrimitiveType {
+    get name() {
+        return "number";
+    }
+    fromRdfResourceValueExpression({ variables, }) {
+        return `${variables.resourceValue}.toNumber()`;
+    }
+    hashStatements({ variables, }) {
+        return [`${variables.hasher}.update(${variables.value}.toString());`];
+    }
+}
+//# sourceMappingURL=NumberType.js.map

package/generators/ts/ObjectType.d.ts

@@ -0,0 +1,71 @@
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { MintingStrategy } from "../../ast";
+import type { IdentifierType } from "./IdentifierType.js";
+import { Type } from "./Type.js";
+import * as _ObjectType from "./_ObjectType";
+export declare class ObjectType extends Type {
+    readonly abstract: boolean;
+    classDeclaration: typeof _ObjectType.classDeclaration;
+    equalsFunctionDeclaration: typeof _ObjectType.equalsFunctionDeclaration;
+    readonly export_: boolean;
+    fromRdfFunctionDeclaration: typeof _ObjectType.fromRdfFunctionDeclaration;
+    hashFunctionDeclaration: typeof _ObjectType.hashFunctionDeclaration;
+    readonly identifierType: IdentifierType;
+    interfaceDeclaration: typeof _ObjectType.interfaceDeclaration;
+    readonly kind = "ObjectType";
+    readonly mintingStrategy: Maybe<MintingStrategy>;
+    readonly name: string;
+    readonly rdfType: Maybe<NamedNode>;
+    sparqlGraphPatternsClassDeclaration: typeof _ObjectType.sparqlGraphPatternsClassDeclaration;
+    toRdfFunctionDeclaration: typeof _ObjectType.toRdfFunctionDeclaration;
+    private readonly lazyAncestorObjectTypes;
+    private readonly lazyDescendantObjectTypes;
+    private readonly lazyParentObjectTypes;
+    private readonly lazyProperties;
+    constructor({ abstract, identifierType, export_, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, mintingStrategy, name, rdfType, ...superParameters }: {
+        abstract: boolean;
+        export_: boolean;
+        identifierType: IdentifierType;
+        lazyAncestorObjectTypes: () => readonly ObjectType[];
+        lazyDescendantObjectTypes: () => readonly ObjectType[];
+        lazyParentObjectTypes: () => readonly ObjectType[];
+        lazyProperties: () => readonly ObjectType.Property[];
+        mintingStrategy: Maybe<MintingStrategy>;
+        name: string;
+        rdfType: Maybe<NamedNode>;
+    } & ConstructorParameters<typeof Type>[0]);
+    get ancestorObjectTypes(): readonly ObjectType[];
+    get conversions(): readonly Type.Conversion[];
+    get descendantObjectTypes(): readonly ObjectType[];
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get discriminatorValue(): string;
+    get hashFunctionName(): string;
+    get importStatements(): readonly string[];
+    get parentObjectTypes(): readonly ObjectType[];
+    get properties(): readonly ObjectType.Property[];
+    chainSparqlGraphPatternExpression({ variables, }: Parameters<Type["chainSparqlGraphPatternExpression"]>[0]): Maybe<Type.SparqlGraphPatternsExpression>;
+    equalsFunction(): string;
+    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    rdfjsResourceType(options?: {
+        mutable?: boolean;
+    }): {
+        readonly mutable: boolean;
+        readonly name: string;
+        readonly named: boolean;
+    };
+    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    protected ensureAtMostOneSuperObjectType(): void;
+}
+export declare namespace ObjectType {
+    const IdentifierProperty: typeof _ObjectType.IdentifierProperty;
+    type IdentifierProperty = _ObjectType.IdentifierProperty;
+    const Property: typeof _ObjectType.Property;
+    type Property = _ObjectType.Property<any>;
+    const ShaclProperty: typeof _ObjectType.ShaclProperty;
+    type ShaclProperty = _ObjectType.ShaclProperty;
+    const TypeDiscriminatorProperty: typeof _ObjectType.TypeDiscriminatorProperty;
+    type TypeDiscriminatorProperty = _ObjectType.TypeDiscriminatorProperty;
+}
+//# sourceMappingURL=ObjectType.d.ts.map

package/generators/ts/ObjectType.js

@@ -0,0 +1,160 @@
+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 { Memoize } from "typescript-memoize";
+import { MintingStrategy } from "../../ast";
+import { Type } from "./Type.js";
+import * as _ObjectType from "./_ObjectType";
+export class ObjectType extends Type {
+    constructor({ abstract, identifierType, export_, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, mintingStrategy, name, rdfType, ...superParameters }) {
+        super(superParameters);
+        this.classDeclaration = _ObjectType.classDeclaration;
+        this.equalsFunctionDeclaration = _ObjectType.equalsFunctionDeclaration;
+        this.fromRdfFunctionDeclaration = _ObjectType.fromRdfFunctionDeclaration;
+        this.hashFunctionDeclaration = _ObjectType.hashFunctionDeclaration;
+        this.interfaceDeclaration = _ObjectType.interfaceDeclaration;
+        this.kind = "ObjectType";
+        this.sparqlGraphPatternsClassDeclaration = _ObjectType.sparqlGraphPatternsClassDeclaration;
+        this.toRdfFunctionDeclaration = _ObjectType.toRdfFunctionDeclaration;
+        this.abstract = abstract;
+        this.export_ = export_;
+        // Lazily initialize some members in getters to avoid recursive construction
+        this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
+        this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
+        this.lazyParentObjectTypes = lazyParentObjectTypes;
+        this.lazyProperties = lazyProperties;
+        this.identifierType = identifierType;
+        this.mintingStrategy = mintingStrategy;
+        this.rdfType = rdfType;
+        this.name = name;
+    }
+    get ancestorObjectTypes() {
+        return this.lazyAncestorObjectTypes();
+    }
+    get conversions() {
+        return [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof ${this.name}`,
+                sourceTypeName: this.name,
+            },
+        ];
+    }
+    get descendantObjectTypes() {
+        return this.lazyDescendantObjectTypes();
+    }
+    get discriminatorProperty() {
+        return Maybe.of({
+            name: this.configuration.objectTypeDiscriminatorPropertyName,
+            type: "string",
+            values: [this.discriminatorValue],
+        });
+    }
+    get discriminatorValue() {
+        return this.name;
+    }
+    get hashFunctionName() {
+        if (this.lazyDescendantObjectTypes().length > 0 ||
+            this.ancestorObjectTypes.length > 0) {
+            return `hash${this.name}`;
+        }
+        return "hash";
+    }
+    get importStatements() {
+        const importStatements = this.properties.flatMap((property) => property.importStatements);
+        this.mintingStrategy.ifJust((mintingStrategy) => {
+            switch (mintingStrategy) {
+                case MintingStrategy.SHA256:
+                    importStatements.push('import { sha256 } from "js-sha256";');
+                    break;
+                case MintingStrategy.UUIDv4:
+                    importStatements.push('import * as uuid from "uuid";');
+                    break;
+            }
+        });
+        return importStatements;
+    }
+    get parentObjectTypes() {
+        return this.lazyParentObjectTypes();
+    }
+    get properties() {
+        const properties = this.lazyProperties()
+            .concat()
+            .sort((left, right) => left.name.localeCompare(right.name));
+        const propertyNames = new Set();
+        for (const property of properties) {
+            if (propertyNames.has(property.name)) {
+                throw new Error(`duplicate property '${property.name}'`);
+            }
+        }
+        return properties;
+    }
+    chainSparqlGraphPatternExpression({ variables, }) {
+        return Maybe.of(new Type.SparqlGraphPatternsExpression(`new ${this.name}.SparqlGraphPatterns(${variables.subject})`));
+    }
+    equalsFunction() {
+        switch (this.configuration.objectTypeDeclarationType) {
+            case "class":
+                return "purifyHelpers.Equatable.equals";
+            case "interface":
+                return `${this.name}.equals`;
+        }
+    }
+    fromRdfExpression({ variables, }) {
+        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(resource => ${this.name}.fromRdf(resource))`;
+    }
+    hashStatements({ variables, }) {
+        return [
+            `${this.name}.${this.hashFunctionName}(${variables.value}, ${variables.hasher});`,
+        ];
+    }
+    rdfjsResourceType(options) {
+        if (this.parentObjectTypes.length > 0) {
+            return this.parentObjectTypes[0].rdfjsResourceType(options);
+        }
+        return {
+            mutable: !!options?.mutable,
+            name: `rdfjsResource.${options?.mutable ? "Mutable" : ""}Resource${this.identifierType.isNamedNodeKind ? "<rdfjs.NamedNode>" : ""}`,
+            named: this.identifierType.isNamedNodeKind,
+        };
+    }
+    toRdfExpression({ variables, }) {
+        switch (this.configuration.objectTypeDeclarationType) {
+            case "class":
+                return `${variables.value}.toRdf({ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }).identifier`;
+            case "interface":
+                return `${this.name}.toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }).identifier`;
+        }
+    }
+    ensureAtMostOneSuperObjectType() {
+        if (this.parentObjectTypes.length > 1) {
+            throw new RangeError(`object type '${this.name}' has multiple super object types`);
+        }
+    }
+}
+__decorate([
+    Memoize()
+], ObjectType.prototype, "ancestorObjectTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "descendantObjectTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "hashFunctionName", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "parentObjectTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "properties", null);
+(function (ObjectType) {
+    ObjectType.IdentifierProperty = _ObjectType.IdentifierProperty;
+    ObjectType.Property = _ObjectType.Property;
+    ObjectType.ShaclProperty = _ObjectType.ShaclProperty;
+    ObjectType.TypeDiscriminatorProperty = _ObjectType.TypeDiscriminatorProperty;
+})(ObjectType || (ObjectType = {}));
+//# sourceMappingURL=ObjectType.js.map

package/generators/ts/OptionType.d.ts

@@ -0,0 +1,17 @@
+import { Type } from "./Type.js";
+export declare class OptionType extends Type {
+    readonly itemType: Type;
+    readonly kind = "OptionType";
+    constructor({ itemType, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
+        itemType: Type;
+    });
+    get conversions(): readonly Type.Conversion[];
+    get name(): string;
+    chainSparqlGraphPatternExpression(parameters: Parameters<Type["chainSparqlGraphPatternExpression"]>[0]): ReturnType<Type["chainSparqlGraphPatternExpression"]>;
+    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;
+    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+}
+//# sourceMappingURL=OptionType.d.ts.map

package/generators/ts/OptionType.js

@@ -0,0 +1,83 @@
+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 { Memoize } from "typescript-memoize";
+import { Type } from "./Type.js";
+export class OptionType extends Type {
+    constructor({ itemType, ...superParameters }) {
+        super(superParameters);
+        this.kind = "OptionType";
+        this.itemType = itemType;
+    }
+    get conversions() {
+        const conversions = [];
+        conversions.push({
+            conversionExpression: (value) => value,
+            sourceTypeCheckExpression: (value) => `purify.Maybe.isMaybe(${value})`,
+            sourceTypeName: this.name,
+        });
+        for (const itemTypeConversion of this.itemType.conversions) {
+            conversions.push({
+                ...itemTypeConversion,
+                conversionExpression: (value) => `purify.Maybe.of(${itemTypeConversion.conversionExpression(value)})`,
+            });
+        }
+        if (!conversions.some((conversion) => conversion.sourceTypeName === "undefined")) {
+            conversions.push({
+                conversionExpression: () => "purify.Maybe.empty()",
+                sourceTypeName: "undefined",
+            });
+        }
+        return conversions;
+    }
+    get name() {
+        return `purify.Maybe<${this.itemType.name}>`;
+    }
+    chainSparqlGraphPatternExpression(parameters) {
+        return this.itemType.chainSparqlGraphPatternExpression(parameters);
+    }
+    equalsFunction() {
+        const itemTypeEqualsFunction = this.itemType.equalsFunction();
+        if (itemTypeEqualsFunction === "purifyHelpers.Equatable.equals") {
+            return "purifyHelpers.Equatable.maybeEquals";
+        }
+        if (itemTypeEqualsFunction === "purifyHelpers.Equatable.strictEquals") {
+            return "purifyHelpers.Equatable.booleanEquals"; // Use Maybe.equals
+        }
+        return `(left, right) => purifyHelpers.Maybes.equals(left, right, ${itemTypeEqualsFunction})`;
+    }
+    fromRdfExpression(parameters) {
+        return `purify.Either.of(${this.itemType.fromRdfExpression(parameters)}.toMaybe())`;
+    }
+    hashStatements({ variables, }) {
+        return [
+            `${variables.value}.ifJust((value) => { ${this.itemType
+                .hashStatements({
+                variables: {
+                    hasher: variables.hasher,
+                    value: "value",
+                },
+            })
+                .join("\n")} })`,
+        ];
+    }
+    propertySparqlGraphPatternExpression(parameters) {
+        return new Type.SparqlGraphPatternExpression(`sparqlBuilder.GraphPattern.optional(${this.itemType.propertySparqlGraphPatternExpression(parameters).toSparqlGraphPatternExpression()})`);
+    }
+    toRdfExpression({ variables, }) {
+        const itemTypeToRdfExpression = this.itemType.toRdfExpression({
+            variables: { ...variables, value: "value" },
+        });
+        if (itemTypeToRdfExpression === "value") {
+            return variables.value;
+        }
+        return `${variables.value}.map((value) => ${itemTypeToRdfExpression})`;
+    }
+}
+__decorate([
+    Memoize()
+], OptionType.prototype, "name", null);
+//# sourceMappingURL=OptionType.js.map

package/generators/ts/PrimitiveType.d.ts

@@ -0,0 +1,11 @@
+import { Maybe } from "purify-ts";
+import { LiteralType } from "./LiteralType.js";
+import type { Type } from "./Type.js";
+export declare abstract class PrimitiveType extends LiteralType {
+    get conversions(): readonly Type.Conversion[];
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get importStatements(): readonly string[];
+    equalsFunction(): string;
+    toRdfExpression({ variables, }: Parameters<LiteralType["toRdfExpression"]>[0]): string;
+}
+//# sourceMappingURL=PrimitiveType.d.ts.map

package/generators/ts/PrimitiveType.js

@@ -0,0 +1,41 @@
+import { Maybe } from "purify-ts";
+import { fromRdf } from "rdf-literal";
+import { LiteralType } from "./LiteralType.js";
+export class PrimitiveType extends LiteralType {
+    get conversions() {
+        const conversions = [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeName: this.name,
+            },
+        ];
+        this.defaultValue.ifJust((defaultValue) => {
+            conversions.push({
+                conversionExpression: () => fromRdf(defaultValue, true),
+                sourceTypeName: "undefined",
+            });
+        });
+        return conversions;
+    }
+    get discriminatorProperty() {
+        return Maybe.empty();
+    }
+    get importStatements() {
+        return [];
+    }
+    equalsFunction() {
+        return "purifyHelpers.Equatable.strictEquals";
+    }
+    toRdfExpression({ variables, }) {
+        return this.defaultValue
+            .map((defaultValue) => {
+            let primitiveDefaultValue = fromRdf(defaultValue, true);
+            if (typeof primitiveDefaultValue === "string") {
+                primitiveDefaultValue = `"${primitiveDefaultValue}"`;
+            }
+            return `${variables.value} !== ${primitiveDefaultValue} ? ${variables.value} : undefined`;
+        })
+            .orDefault(variables.value);
+    }
+}
+//# sourceMappingURL=PrimitiveType.js.map

package/generators/ts/RdfjsTermType.d.ts

@@ -0,0 +1,25 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+import { Type } from "./Type.js";
+/**
+ * Abstract base class for IdentifierType and LiteralType.
+ */
+export declare abstract class RdfjsTermType<RdfjsTermT extends BlankNode | Literal | NamedNode> extends Type {
+    readonly defaultValue: Maybe<RdfjsTermT>;
+    readonly hasValue: Maybe<RdfjsTermT>;
+    abstract readonly kind: "IdentifierType" | "LiteralType";
+    constructor({ defaultValue, hasValue, ...superParameters }: {
+        defaultValue: Maybe<RdfjsTermT>;
+        hasValue: Maybe<RdfjsTermT>;
+    } & ConstructorParameters<typeof Type>[0]);
+    equalsFunction(): string;
+    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    propertySparqlGraphPatternExpression({ variables, }: Parameters<Type["propertySparqlGraphPatternExpression"]>[0]): Type.SparqlGraphPatternExpression;
+    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    protected abstract fromRdfResourceValueExpression({ variables, }: {
+        variables: {
+            resourceValue: string;
+        };
+    }): string;
+}
+//# sourceMappingURL=RdfjsTermType.d.ts.map