@shaclmate/compiler 2.0.12

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

@@ -0,0 +1,29 @@
+import { Maybe } from "purify-ts";
+import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
+import { Property } from "./Property.js";
+export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminatorProperty.Type> {
+    readonly equalsFunction = "purifyHelpers.Equatable.strictEquals";
+    readonly value: string;
+    private readonly abstract;
+    private readonly override;
+    constructor({ abstract, override, value, ...superParameters }: {
+        abstract: boolean;
+        override: boolean;
+        value: string;
+    } & ConstructorParameters<typeof Property>[0]);
+    get classConstructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
+    get classPropertyDeclaration(): OptionalKind<PropertyDeclarationStructure>;
+    get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
+    classConstructorStatements(): readonly string[];
+    fromRdfStatements(): readonly string[];
+    hashStatements(): readonly string[];
+    sparqlGraphPatternExpression(): Maybe<string>;
+    toRdfStatements(): readonly string[];
+}
+export declare namespace TypeDiscriminatorProperty {
+    interface Type {
+        readonly name: string;
+    }
+}
+//# sourceMappingURL=TypeDiscriminatorProperty.d.ts.map

package/generators/ts/_ObjectType/TypeDiscriminatorProperty.js

@@ -0,0 +1,53 @@
+import { Maybe } from "purify-ts";
+import { Property } from "./Property.js";
+export class TypeDiscriminatorProperty extends Property {
+    constructor({ abstract, override, value, ...superParameters }) {
+        super(superParameters);
+        this.equalsFunction = "purifyHelpers.Equatable.strictEquals";
+        this.abstract = abstract;
+        this.override = override;
+        this.value = value;
+    }
+    get classConstructorParametersPropertySignature() {
+        return Maybe.empty();
+    }
+    get classGetAccessorDeclaration() {
+        return Maybe.empty();
+    }
+    get classPropertyDeclaration() {
+        return {
+            isAbstract: this.abstract,
+            hasOverrideKeyword: this.override,
+            initializer: !this.abstract ? `"${this.value}"` : undefined,
+            isReadonly: true,
+            name: this.name,
+            type: this.type.name,
+        };
+    }
+    get interfacePropertySignature() {
+        return {
+            isReadonly: true,
+            name: this.name,
+            type: this.type.name,
+        };
+    }
+    classConstructorStatements() {
+        return [];
+    }
+    fromRdfStatements() {
+        return !this.abstract &&
+            this.configuration.objectTypeDeclarationType === "interface"
+            ? [`const ${this.name} = "${this.value}" as const`]
+            : [];
+    }
+    hashStatements() {
+        return [];
+    }
+    sparqlGraphPatternExpression() {
+        return Maybe.empty();
+    }
+    toRdfStatements() {
+        return [];
+    }
+}
+//# sourceMappingURL=TypeDiscriminatorProperty.js.map

package/generators/ts/_ObjectType/classDeclaration.d.ts

@@ -0,0 +1,4 @@
+import { type ClassDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function classDeclaration(this: ObjectType): ClassDeclarationStructure;
+//# sourceMappingURL=classDeclaration.d.ts.map

package/generators/ts/_ObjectType/classDeclaration.js

@@ -0,0 +1,154 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { StructureKind, } from "ts-morph";
+import { hasherTypeConstraint } from "./hashFunctionDeclaration.js";
+function constructorDeclaration() {
+    if (this.properties.length === 0) {
+        return null;
+    }
+    const statements = [];
+    if (this.parentObjectTypes.length > 0) {
+        statements.push("super(parameters);");
+    }
+    for (const property of this.properties) {
+        for (const statement of property.classConstructorStatements({
+            variables: { parameter: `parameters.${property.name}` },
+        })) {
+            statements.push(statement);
+        }
+    }
+    const constructorParameterPropertySignatures = this.properties.flatMap((property) => property.classConstructorParametersPropertySignature
+        .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+        .toList());
+    if (constructorParameterPropertySignatures.length === 0) {
+        return null;
+    }
+    let constructorParametersType = `{ ${constructorParameterPropertySignatures.join(", ")} }`;
+    if (this.parentObjectTypes.length > 0) {
+        constructorParametersType = `${constructorParametersType} & ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`;
+    }
+    return {
+        parameters: [
+            {
+                name: "parameters",
+                type: constructorParametersType,
+            },
+        ],
+        statements,
+    };
+}
+export function classDeclaration() {
+    this.ensureAtMostOneSuperObjectType();
+    const constructorDeclaration_ = constructorDeclaration.bind(this)();
+    const methods = [];
+    if (this.configuration.features.has("equals")) {
+        methods.push(equalsMethodDeclaration.bind(this)());
+    }
+    if (this.configuration.features.has("hash")) {
+        methods.push(hashMethodDeclaration.bind(this)());
+    }
+    if (this.configuration.features.has("toRdf")) {
+        methods.push(toRdfMethodDeclaration.bind(this)());
+    }
+    const getAccessors = [];
+    const properties = [];
+    for (const property of this.properties) {
+        properties.push(property.classPropertyDeclaration);
+        property.classGetAccessorDeclaration.ifJust((getAccessor) => getAccessors.push(getAccessor));
+    }
+    return {
+        ctors: constructorDeclaration_ !== null ? [constructorDeclaration_] : undefined,
+        extends: this.parentObjectTypes.length > 0
+            ? this.parentObjectTypes[0].name
+            : undefined,
+        getAccessors,
+        isAbstract: this.abstract,
+        kind: StructureKind.Class,
+        isExported: this.export_,
+        methods,
+        name: this.name,
+        properties,
+    };
+}
+function equalsMethodDeclaration() {
+    let expression = `purifyHelpers.Equatable.objectEquals(this, other, { ${this.properties
+        .map((property) => `${property.name}: ${property.equalsFunction}`)
+        .join()} })`;
+    if (this.parentObjectTypes.length > 0) {
+        expression = `super.equals(other).chain(() => ${expression})`;
+    }
+    return {
+        hasOverrideKeyword: this.parentObjectTypes.length > 0,
+        name: "equals",
+        parameters: [
+            {
+                name: "other",
+                type: this.name,
+            },
+        ],
+        statements: [`return ${expression};`],
+        returnType: "purifyHelpers.Equatable.EqualsResult",
+    };
+}
+function hashMethodDeclaration() {
+    return {
+        hasOverrideKeyword: this.parentObjectTypes.length > 0,
+        name: "hash",
+        parameters: [
+            {
+                name: "hasher",
+                type: "HasherT",
+            },
+        ],
+        returnType: "HasherT",
+        statements: [`return ${this.name}.${this.hashFunctionName}(this, hasher);`],
+        typeParameters: [
+            {
+                name: "HasherT",
+                constraint: hasherTypeConstraint,
+            },
+        ],
+    };
+}
+function toRdfMethodDeclaration() {
+    const variables = {
+        ignoreRdfType: "ignoreRdfType",
+        mutateGraph: "mutateGraph",
+        resource: "resource",
+        resourceSet: "resourceSet",
+    };
+    let usedIgnoreRdfTypeVariable = false;
+    const statements = [];
+    if (this.parentObjectTypes.length > 0) {
+        statements.push(`const ${variables.resource} = super.toRdf({ ${variables.mutateGraph}, ${variables.ignoreRdfType}: true, ${variables.resourceSet} });`);
+        usedIgnoreRdfTypeVariable = true;
+    }
+    else if (this.identifierType.isNamedNodeKind) {
+        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableNamedResource({ identifier: this.${this.configuration.objectTypeIdentifierPropertyName}, ${variables.mutateGraph} });`);
+    }
+    else {
+        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableResource({ identifier: this.${this.configuration.objectTypeIdentifierPropertyName}, ${variables.mutateGraph} });`);
+    }
+    this.rdfType.ifJust((rdfType) => {
+        statements.push(`if (!${variables.ignoreRdfType}) { ${variables.resource}.add(${variables.resource}.dataFactory.namedNode("${rdf.type.value}"), ${variables.resource}.dataFactory.namedNode("${rdfType.value}")); }`);
+        usedIgnoreRdfTypeVariable = true;
+    });
+    for (const property of this.properties) {
+        statements.push(...property.toRdfStatements({
+            variables: { ...variables, value: `this.${property.name}` },
+        }));
+    }
+    statements.push(`return ${variables.resource};`);
+    return {
+        hasOverrideKeyword: this.parentObjectTypes.length > 0,
+        name: "toRdf",
+        parameters: [
+            {
+                name: `{ ${usedIgnoreRdfTypeVariable ? `${variables.ignoreRdfType},` : ""} ${variables.mutateGraph}, ${variables.resourceSet} }`,
+                type: `{ ${variables.ignoreRdfType}?: boolean; ${variables.mutateGraph}: rdfjsResource.MutableResource.MutateGraph, ${variables.resourceSet}: rdfjsResource.MutableResourceSet }`,
+            },
+        ],
+        returnType: this.rdfjsResourceType({ mutable: true }).name,
+        statements,
+    };
+}
+//# sourceMappingURL=classDeclaration.js.map

package/generators/ts/_ObjectType/equalsFunctionDeclaration.d.ts

@@ -0,0 +1,4 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function equalsFunctionDeclaration(this: ObjectType): FunctionDeclarationStructure;
+//# sourceMappingURL=equalsFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/equalsFunctionDeclaration.js

@@ -0,0 +1,27 @@
+import { StructureKind } from "ts-morph";
+export function equalsFunctionDeclaration() {
+    let expression = `purifyHelpers.Equatable.objectEquals(left, right, { ${this.properties
+        .map((property) => `${property.name}: ${property.equalsFunction}`)
+        .join()} })`;
+    for (const parentObjectType of this.parentObjectTypes) {
+        expression = `${parentObjectType.name}.equals(left, right).chain(() => ${expression})`;
+    }
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "equals",
+        parameters: [
+            {
+                name: "left",
+                type: this.name,
+            },
+            {
+                name: "right",
+                type: this.name,
+            },
+        ],
+        statements: [`return ${expression};`],
+        returnType: "purifyHelpers.Equatable.EqualsResult",
+    };
+}
+//# sourceMappingURL=equalsFunctionDeclaration.js.map

package/generators/ts/_ObjectType/fromRdfFunctionDeclaration.d.ts

@@ -0,0 +1,4 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function fromRdfFunctionDeclaration(this: ObjectType): FunctionDeclarationStructure;
+//# sourceMappingURL=fromRdfFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/fromRdfFunctionDeclaration.js

@@ -0,0 +1,72 @@
+import { StructureKind } from "ts-morph";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+const variables = {
+    ignoreRdfType: "ignoreRdfType",
+    options: "_options",
+    resource: "resource",
+};
+export function fromRdfFunctionDeclaration() {
+    this.ensureAtMostOneSuperObjectType();
+    const propertiesByName = {};
+    let statements = [];
+    this.rdfType.ifJust((rdfType) => {
+        statements.push(`if (!${variables.options}?.${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${rdfjsTermExpression(rdfType, this.configuration)})) { return purify.Left(new rdfjsResource.Resource.ValueError({ focusResource: ${variables.resource}, message: \`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type\`, predicate: ${rdfjsTermExpression(rdfType, this.configuration)} })); }`);
+    });
+    for (const ancestorObjectType of this.ancestorObjectTypes) {
+        for (const property of ancestorObjectType.properties) {
+            if (property.fromRdfStatements({ variables }).length > 0) {
+                propertiesByName[property.name] = {
+                    initializer: `_super.${property.name}`,
+                    type: property.type.name,
+                };
+            }
+        }
+    }
+    for (const property of this.properties) {
+        const propertyFromRdfStatements = property.fromRdfStatements({
+            variables,
+        });
+        if (propertyFromRdfStatements.length > 0) {
+            propertiesByName[property.name] = {
+                type: property.type.name,
+            };
+            statements.push(...propertyFromRdfStatements);
+        }
+    }
+    let construction = `{ ${Object.entries(propertiesByName)
+        .map(([name, { initializer }]) => initializer ? `${name}: ${initializer}` : name)
+        .join(", ")} }`;
+    let returnType = `{ ${Object.entries(propertiesByName)
+        .map(([name, { type }]) => `${name}: ${type}`)
+        .join(", ")} }`;
+    if (this.configuration.objectTypeDeclarationType === "class" &&
+        !this.abstract) {
+        construction = `new ${this.name}(${construction})`;
+        returnType = this.name;
+    }
+    statements.push(`return purify.Either.of(${construction})`);
+    if (this.parentObjectTypes.length > 0) {
+        statements = [
+            `return ${this.parentObjectTypes[0].name}.fromRdf(${variables.resource}, { ${variables.ignoreRdfType}: true }).chain(_super => { ${statements.join("\n")} })`,
+        ];
+    }
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "fromRdf",
+        parameters: [
+            {
+                name: variables.resource,
+                type: this.rdfjsResourceType().name,
+            },
+            {
+                hasQuestionToken: true,
+                name: variables.options,
+                type: `{ ${variables.ignoreRdfType}?: boolean }`,
+            },
+        ],
+        returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${returnType}>`,
+        statements,
+    };
+}
+//# sourceMappingURL=fromRdfFunctionDeclaration.js.map

package/generators/ts/_ObjectType/hashFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType";
+export declare const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
+export declare function hashFunctionDeclaration(this: ObjectType): FunctionDeclarationStructure;
+//# sourceMappingURL=hashFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/hashFunctionDeclaration.js

@@ -0,0 +1,64 @@
+import { camelCase } from "change-case";
+import { StructureKind } from "ts-morph";
+const hasherVariable = "hasher";
+export const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
+export function hashFunctionDeclaration() {
+    const thisVariable = camelCase(this.name);
+    const omitPropertyNamesSet = new Set();
+    omitPropertyNamesSet.add(this.configuration.objectTypeIdentifierPropertyName);
+    omitPropertyNamesSet.add(this.configuration.objectTypeDiscriminatorPropertyName);
+    if (this.configuration.objectTypeDeclarationType === "class") {
+        omitPropertyNamesSet.add("equals");
+        omitPropertyNamesSet.add("hash");
+        omitPropertyNamesSet.add("toRdf");
+    }
+    const statements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        statements.push(`${parentObjectType.name}.${parentObjectType.hashFunctionName}(${thisVariable}, ${hasherVariable})`);
+    }
+    for (const property of this.properties) {
+        const propertyValueVariable = `${thisVariable}.${property.name}`;
+        const propertyHashStatements = property.hashStatements({
+            variables: {
+                hasher: hasherVariable,
+                value: propertyValueVariable,
+            },
+        });
+        if (propertyHashStatements.length === 0) {
+            omitPropertyNamesSet.add(property.name);
+            continue;
+        }
+        if (property.name === this.configuration.objectTypeIdentifierPropertyName) {
+            // Don't hash the identifier since we may be using hash to calculate the identifier, leading to infinite recursion
+            continue;
+        }
+        statements.push(...propertyHashStatements);
+    }
+    const omitPropertyNames = [...omitPropertyNamesSet];
+    omitPropertyNames.sort();
+    statements.push(`return ${hasherVariable};`);
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: this.hashFunctionName,
+        parameters: [
+            {
+                name: thisVariable,
+                type: `Omit<${this.name}, ${omitPropertyNames.map((propertyName) => `"${propertyName}"`).join(" | ")}>`,
+            },
+            {
+                name: hasherVariable,
+                type: "HasherT",
+            },
+        ],
+        returnType: "HasherT",
+        statements,
+        typeParameters: [
+            {
+                name: "HasherT",
+                constraint: hasherTypeConstraint,
+            },
+        ],
+    };
+}
+//# sourceMappingURL=hashFunctionDeclaration.js.map

package/generators/ts/_ObjectType/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./classDeclaration.js";
+export * from "./equalsFunctionDeclaration.js";
+export * from "./fromRdfFunctionDeclaration.js";
+export * from "./hashFunctionDeclaration.js";
+export * from "./IdentifierProperty.js";
+export * from "./interfaceDeclaration.js";
+export * from "./Property.js";
+export * from "./ShaclProperty.js";
+export * from "./sparqlGraphPatternsClassDeclaration.js";
+export * from "./toRdfFunctionDeclaration.js";
+export * from "./TypeDiscriminatorProperty.js";
+//# sourceMappingURL=index.d.ts.map

package/generators/ts/_ObjectType/index.js

@@ -0,0 +1,12 @@
+export * from "./classDeclaration.js";
+export * from "./equalsFunctionDeclaration.js";
+export * from "./fromRdfFunctionDeclaration.js";
+export * from "./hashFunctionDeclaration.js";
+export * from "./IdentifierProperty.js";
+export * from "./interfaceDeclaration.js";
+export * from "./Property.js";
+export * from "./ShaclProperty.js";
+export * from "./sparqlGraphPatternsClassDeclaration.js";
+export * from "./toRdfFunctionDeclaration.js";
+export * from "./TypeDiscriminatorProperty.js";
+//# sourceMappingURL=index.js.map

package/generators/ts/_ObjectType/interfaceDeclaration.d.ts

@@ -0,0 +1,4 @@
+import { type InterfaceDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType";
+export declare function interfaceDeclaration(this: ObjectType): InterfaceDeclarationStructure;
+//# sourceMappingURL=interfaceDeclaration.d.ts.map

package/generators/ts/_ObjectType/interfaceDeclaration.js

@@ -0,0 +1,12 @@
+import { StructureKind, } from "ts-morph";
+export function interfaceDeclaration() {
+    const properties = this.properties.map((property) => property.interfacePropertySignature);
+    return {
+        extends: this.parentObjectTypes.map((parentObjectType) => parentObjectType.name),
+        isExported: true,
+        kind: StructureKind.Interface,
+        name: this.name,
+        properties,
+    };
+}
+//# sourceMappingURL=interfaceDeclaration.js.map

package/generators/ts/_ObjectType/sparqlGraphPatternsClassDeclaration.d.ts

@@ -0,0 +1,4 @@
+import { type ClassDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function sparqlGraphPatternsClassDeclaration(this: ObjectType): ClassDeclarationStructure;
+//# sourceMappingURL=sparqlGraphPatternsClassDeclaration.d.ts.map

package/generators/ts/_ObjectType/sparqlGraphPatternsClassDeclaration.js

@@ -0,0 +1,46 @@
+import { StructureKind } from "ts-morph";
+import { rdfjsTermExpression } from "../rdfjsTermExpression";
+const ignoreRdfTypeVariable = "ignoreRdfType";
+const optionsVariable = "_options";
+const subjectVariable = "subject";
+export function sparqlGraphPatternsClassDeclaration() {
+    this.ensureAtMostOneSuperObjectType();
+    const constructorStatements = [];
+    if (this.parentObjectTypes.length > 0) {
+        constructorStatements.push(`super(${subjectVariable}, { ignoreRdfType: true });`);
+    }
+    else {
+        constructorStatements.push(`super(${subjectVariable});`);
+    }
+    this.rdfType.ifJust((rdfType) => constructorStatements.push(`if (!${optionsVariable}?.${ignoreRdfTypeVariable}) { this.add(...new sparqlBuilder.RdfTypeGraphPatterns(${subjectVariable}, ${rdfjsTermExpression(rdfType, this.configuration)})); }`));
+    for (const property of this.properties) {
+        property
+            .sparqlGraphPatternExpression()
+            .ifJust((sparqlGraphPattern) => constructorStatements.push(`this.add(${sparqlGraphPattern});`));
+    }
+    return {
+        ctors: [
+            {
+                parameters: [
+                    {
+                        name: subjectVariable,
+                        type: "sparqlBuilder.ResourceGraphPatterns.SubjectParameter",
+                    },
+                    {
+                        hasQuestionToken: true,
+                        name: optionsVariable,
+                        type: `{ ${ignoreRdfTypeVariable}?: boolean }`,
+                    },
+                ],
+                statements: constructorStatements,
+            },
+        ],
+        extends: this.parentObjectTypes.length > 0
+            ? `${this.parentObjectTypes[0].name}.SparqlGraphPatterns`
+            : "sparqlBuilder.ResourceGraphPatterns",
+        isExported: true,
+        kind: StructureKind.Class,
+        name: "SparqlGraphPatterns",
+    };
+}
+//# sourceMappingURL=sparqlGraphPatternsClassDeclaration.js.map

package/generators/ts/_ObjectType/toRdfFunctionDeclaration.d.ts

@@ -0,0 +1,4 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType";
+export declare function toRdfFunctionDeclaration(this: ObjectType): FunctionDeclarationStructure;
+//# sourceMappingURL=toRdfFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/toRdfFunctionDeclaration.js

@@ -0,0 +1,53 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { camelCase } from "change-case";
+import { StructureKind } from "ts-morph";
+const variables = {
+    ignoreRdfType: "ignoreRdfType",
+    mutateGraph: "mutateGraph",
+    resource: "resource",
+    resourceSet: "resourceSet",
+};
+export function toRdfFunctionDeclaration() {
+    this.ensureAtMostOneSuperObjectType();
+    let usedIgnoreRdfTypeVariable = false;
+    const thisVariable = camelCase(this.name);
+    const statements = [];
+    if (this.parentObjectTypes.length > 0) {
+        statements.push(`const ${variables.resource} = ${this.parentObjectTypes[0].name}.toRdf(${thisVariable}, { ${variables.mutateGraph}, ${variables.ignoreRdfType}: true, ${variables.resourceSet} });`);
+        usedIgnoreRdfTypeVariable = true;
+    }
+    else if (this.identifierType.isNamedNodeKind) {
+        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableNamedResource({ identifier: ${thisVariable}.${this.configuration.objectTypeIdentifierPropertyName}, ${variables.mutateGraph} });`);
+    }
+    else {
+        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableResource({ identifier: ${thisVariable}.${this.configuration.objectTypeIdentifierPropertyName}, ${variables.mutateGraph} });`);
+    }
+    this.rdfType.ifJust((rdfType) => {
+        statements.push(`if (!${variables.ignoreRdfType}) { ${variables.resource}.add(${variables.resource}.dataFactory.namedNode("${rdf.type.value}"), ${variables.resource}.dataFactory.namedNode("${rdfType.value}")); }`);
+        usedIgnoreRdfTypeVariable = true;
+    });
+    for (const property of this.properties) {
+        statements.push(...property.toRdfStatements({
+            variables: { ...variables, value: `${thisVariable}.${property.name}` },
+        }));
+    }
+    statements.push(`return ${variables.resource};`);
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "toRdf",
+        parameters: [
+            {
+                name: thisVariable,
+                type: this.name,
+            },
+            {
+                name: `{ ${usedIgnoreRdfTypeVariable ? `${variables.ignoreRdfType},` : ""} ${variables.mutateGraph}, ${variables.resourceSet} }`,
+                type: `{ ${variables.ignoreRdfType}?: boolean; ${variables.mutateGraph}: rdfjsResource.MutableResource.MutateGraph, ${variables.resourceSet}: rdfjsResource.MutableResourceSet }`,
+            },
+        ],
+        returnType: this.rdfjsResourceType({ mutable: true }).name,
+        statements,
+    };
+}
+//# sourceMappingURL=toRdfFunctionDeclaration.js.map

package/generators/ts/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./TsGenerator.js";
+//# sourceMappingURL=index.d.ts.map

package/generators/ts/index.js

@@ -0,0 +1,2 @@
+export * from "./TsGenerator.js";
+//# sourceMappingURL=index.js.map

package/generators/ts/rdfjsTermExpression.d.ts

@@ -0,0 +1,5 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+export declare function rdfjsTermExpression(rdfjsTerm: BlankNode | Literal | NamedNode, { dataFactoryVariable }: {
+    dataFactoryVariable: string;
+}): string;
+//# sourceMappingURL=rdfjsTermExpression.d.ts.map

package/generators/ts/rdfjsTermExpression.js

@@ -0,0 +1,15 @@
+import { xsd } from "@tpluscode/rdf-ns-builders";
+export function rdfjsTermExpression(rdfjsTerm, { dataFactoryVariable }) {
+    switch (rdfjsTerm.termType) {
+        case "BlankNode":
+            return `${dataFactoryVariable}.blankNode("${rdfjsTerm.value}")`;
+        case "Literal":
+            if (rdfjsTerm.datatype.equals(xsd.string)) {
+                return `${dataFactoryVariable}.literal("${rdfjsTerm.value}", "${rdfjsTerm.language}")`;
+            }
+            return `${dataFactoryVariable}.literal("${rdfjsTerm.value}", ${dataFactoryVariable}.namedNode("${rdfjsTerm.datatype.value}"))`;
+        case "NamedNode":
+            return `${dataFactoryVariable}.namedNode("${rdfjsTerm.value}")`;
+    }
+}
+//# sourceMappingURL=rdfjsTermExpression.js.map

package/generators/ts/stringToValidTsIdentifier.d.ts

@@ -0,0 +1,2 @@
+export declare function stringToValidTsIdentifier(value: string): string;
+//# sourceMappingURL=stringToValidTsIdentifier.d.ts.map

package/generators/ts/stringToValidTsIdentifier.js

@@ -0,0 +1,14 @@
+import base62 from "@sindresorhus/base62";
+import reservedTsIdentifiers_ from "reserved-identifiers";
+const reservedTsIdentifiers = reservedTsIdentifiers_({
+    includeGlobalProperties: true,
+});
+// Adapted from https://github.com/sindresorhus/to-valid-identifier , MIT license
+export function stringToValidTsIdentifier(value) {
+    if (reservedTsIdentifiers.has(value)) {
+        // We prefix with underscore to avoid any potential conflicts with the Base62 encoded string.
+        return `$_${value}$`;
+    }
+    return value.replaceAll(/\P{ID_Continue}/gu, (x) => `$${base62.encodeInteger(x.codePointAt(0))}$`);
+}
+//# sourceMappingURL=stringToValidTsIdentifier.js.map

package/generators/ts/tsName.d.ts

@@ -0,0 +1,3 @@
+import type * as ast from "../../ast";
+export declare function tsName(astName: ast.Name): string;
+//# sourceMappingURL=tsName.d.ts.map