@shaclmate/compiler 2.0.13 → 2.0.15

package/generators/ts/_ObjectType/jsonUiSchemaFunctionDeclaration.js

@@ -0,0 +1,31 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+export function jsonUiSchemaFunctionDeclaration() {
+    if (!this.features.has("jsonUiSchema")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    const variables = { scopePrefix: "scopePrefix" };
+    const elements = this.parentObjectTypes
+        .map((parentObjectType) => `${parentObjectType.name}.${parentObjectType.jsonUiSchemaFunctionName}({ scopePrefix })`)
+        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: this.jsonUiSchemaFunctionName,
+        parameters: [
+            {
+                hasQuestionToken: true,
+                name: "parameters",
+                type: "{ scopePrefix?: string }",
+            },
+        ],
+        statements: [
+            'const scopePrefix = parameters?.scopePrefix ?? "#";',
+            `return { "elements": [ ${elements.join(", ")} ], label: "${this.label.orDefault(this.name)}", type: "Group" }`,
+        ],
+    });
+}
+//# sourceMappingURL=jsonUiSchemaFunctionDeclaration.js.map

package/generators/ts/_ObjectType/jsonZodSchemaFunctionDeclaration.d.ts

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

package/generators/ts/_ObjectType/jsonZodSchemaFunctionDeclaration.js

@@ -0,0 +1,37 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+export function jsonZodSchemaFunctionDeclaration() {
+    if (!this.features.has("fromJson") && !this.features.has("jsonSchema")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    const variables = { zod: "zod" };
+    const mergeZodObjectSchemas = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        mergeZodObjectSchemas.push(`${parentObjectType.jsonZodSchema({ variables })}`);
+    }
+    if (this.properties.length > 0) {
+        mergeZodObjectSchemas.push(`${variables.zod}.object({ ${this.properties
+            .map((property) => property.jsonZodSchema({ variables }))
+            .map(({ key, schema }) => `"${key}": ${schema}`)
+            .join(",")} })`);
+    }
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: this.jsonZodSchemaFunctionName,
+        statements: [
+            `return ${mergeZodObjectSchemas.length > 0
+                ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
+                    if (merged.length === 0) {
+                        return zodObjectSchema;
+                    }
+                    return `${merged}.merge(${zodObjectSchema})`;
+                }, "")
+                : `${variables.zod}.object()`};`,
+        ],
+    });
+}
+//# sourceMappingURL=jsonZodSchemaFunctionDeclaration.js.map

package/generators/ts/_ObjectType/rdfjsTermExpression.d.ts

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

package/generators/ts/{rdfjsTermExpression.js → _ObjectType/rdfjsTermExpression.js}

@@ -1,5 +1,5 @@
 import { xsd } from "@tpluscode/rdf-ns-builders";
-export function rdfjsTermExpression(rdfjsTerm, { dataFactoryVariable }) {
+export function rdfjsTermExpression({ dataFactoryVariable, rdfjsTerm, }) {
     switch (rdfjsTerm.termType) {
         case "BlankNode":
             return `${dataFactoryVariable}.blankNode("${rdfjsTerm.value}")`;
@@ -10,6 +10,8 @@ export function rdfjsTermExpression(rdfjsTerm, { dataFactoryVariable }) {
             return `${dataFactoryVariable}.literal("${rdfjsTerm.value}", ${dataFactoryVariable}.namedNode("${rdfjsTerm.datatype.value}"))`;
         case "NamedNode":
             return `${dataFactoryVariable}.namedNode("${rdfjsTerm.value}")`;
+        case "Variable":
+            return `${dataFactoryVariable}.variable!("${rdfjsTerm.value}")`;
     }
 }
 //# sourceMappingURL=rdfjsTermExpression.js.map

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.d.ts

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

package/generators/ts/_ObjectType/sparqlFunctionDeclarations.js

@@ -0,0 +1,78 @@
+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 [];
+    }
+    if (this.extern) {
+        return [];
+    }
+    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 [
+        sparqlConstructQueryFunctionDeclaration.bind(this)(),
+        sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
+        {
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "sparqlConstructTemplateTriples",
+            parameters: [
+                {
+                    hasQuestionToken: true,
+                    name: `${sparqlConstructTemplateTriples.length === 0 ? "_" : ""}parameters`,
+                    type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                },
+            ],
+            returnType: "readonly sparqljs.Triple[]",
+            statements: [
+                ...(sparqlConstructTemplateTriples.length > 0
+                    ? preambleStatements
+                    : []),
+                `return [${sparqlConstructTemplateTriples.join(", ")}];`,
+            ],
+        },
+        {
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "sparqlWherePatterns",
+            parameters: [
+                {
+                    name: `${sparqlWherePatterns.length === 0 ? "_" : ""}parameters`,
+                    type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                },
+            ],
+            returnType: "readonly sparqljs.Pattern[]",
+            statements: [
+                ...(sparqlWherePatterns.length > 0 ? preambleStatements : []),
+                `return [${sparqlWherePatterns.join(", ")}];`,
+            ],
+        },
+    ];
+}
+//# sourceMappingURL=sparqlFunctionDeclarations.js.map

package/generators/ts/_ObjectType/toJsonFunctionDeclaration.d.ts

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

package/generators/ts/_ObjectType/toJsonFunctionDeclaration.js

@@ -0,0 +1,19 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
+export function toJsonFunctionDeclaration() {
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    return toJsonFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((toJsonFunctionOrMethodDeclaration) => ({
+        ...toJsonFunctionOrMethodDeclaration,
+        isExported: true,
+        kind: StructureKind.Function,
+    }));
+}
+//# sourceMappingURL=toJsonFunctionDeclaration.js.map

package/generators/ts/_ObjectType/toJsonFunctionOrMethodDeclaration.d.ts

@@ -0,0 +1,10 @@
+import { Maybe } from "purify-ts";
+import type { OptionalKind, ParameterDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function toJsonFunctionOrMethodDeclaration(this: ObjectType): Maybe<{
+    name: string;
+    parameters: OptionalKind<ParameterDeclarationStructure>[];
+    returnType: string;
+    statements: string[];
+}>;
+//# sourceMappingURL=toJsonFunctionOrMethodDeclaration.d.ts.map

package/generators/ts/_ObjectType/toJsonFunctionOrMethodDeclaration.js

@@ -0,0 +1,59 @@
+import { Maybe } from "purify-ts";
+import { toJsonReturnType } from "./toJsonReturnType.js";
+export function toJsonFunctionOrMethodDeclaration() {
+    if (!this.features.has("toJson")) {
+        return Maybe.empty();
+    }
+    if (this.declarationType === "class" &&
+        this.ownProperties.length === 0 &&
+        this.parentObjectTypes.length > 0) {
+        return Maybe.empty();
+    }
+    const jsonObjectMembers = [];
+    const parameters = [];
+    switch (this.declarationType) {
+        case "class":
+            if (this.parentObjectTypes.length > 0) {
+                jsonObjectMembers.push("...super.toJson()");
+            }
+            break;
+        case "interface":
+            for (const parentObjectType of this.parentObjectTypes) {
+                jsonObjectMembers.push(`...${parentObjectType.name}.toJson(${this.thisVariable})`);
+            }
+            parameters.push({
+                name: this.thisVariable,
+                type: this.name,
+            });
+            break;
+    }
+    if (this.ownProperties.length > 0) {
+        for (const property of this.ownProperties) {
+            jsonObjectMembers.push(property.toJsonObjectMember({
+                variables: { value: `${this.thisVariable}.${property.name}` },
+            }));
+        }
+    }
+    // 20241220: don't add @type until we're doing JSON-LD
+    // switch (this.toRdfTypes.length) {
+    //   case 0:
+    //     break;
+    //   case 1:
+    //     jsonObjectMembers.push(`"@type": "${this.toRdfTypes[0].value}"`);
+    //     break;
+    //   default:
+    //     jsonObjectMembers.push(
+    //       `"@type": ${JSON.stringify(this.toRdfTypes.map((rdfType) => rdfType.value))}`,
+    //     );
+    //     break;
+    // }
+    return Maybe.of({
+        name: "toJson",
+        parameters,
+        returnType: toJsonReturnType.bind(this)(),
+        statements: [
+            `return JSON.parse(JSON.stringify({ ${jsonObjectMembers.join(",")} } satisfies ${this.jsonName}));`,
+        ],
+    });
+}
+//# sourceMappingURL=toJsonFunctionOrMethodDeclaration.js.map

package/generators/ts/_ObjectType/toJsonReturnType.d.ts

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

package/generators/ts/_ObjectType/toJsonReturnType.js

@@ -0,0 +1,19 @@
+export function toJsonReturnType() {
+    const typeMembers = [];
+    if (this.ownProperties.length > 0) {
+        typeMembers.push(`{ ${this.ownProperties
+            .map((property) => {
+            const propertySignature = property.jsonPropertySignature;
+            return `readonly "${propertySignature.name}": ${propertySignature.type}`;
+        })
+            .join("; ")} }`);
+    }
+    for (const parentObjectType of this.parentObjectTypes) {
+        typeMembers.push(parentObjectType.jsonName);
+    }
+    if (typeMembers.length === 0) {
+        return "object";
+    }
+    return typeMembers.join(" & ");
+}
+//# sourceMappingURL=toJsonReturnType.js.map

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

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

package/generators/ts/_ObjectType/toRdfFunctionDeclaration.js

@@ -1,53 +1,19 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
-import { camelCase } from "change-case";
+import { Maybe } from "purify-ts";
 import { StructureKind } from "ts-morph";
-const variables = {
-    ignoreRdfType: "ignoreRdfType",
-    mutateGraph: "mutateGraph",
-    resource: "resource",
-    resourceSet: "resourceSet",
-};
+import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
 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;
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
     }
-    else if (this.identifierType.isNamedNodeKind) {
-        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableNamedResource({ identifier: ${thisVariable}.${this.configuration.objectTypeIdentifierPropertyName}, ${variables.mutateGraph} });`);
+    if (this.extern) {
+        return Maybe.empty();
     }
-    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 {
+    return toRdfFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((toRdfFunctionOrMethodDeclaration) => ({
+        ...toRdfFunctionOrMethodDeclaration,
         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/_ObjectType/toRdfFunctionOrMethodDeclaration.d.ts

@@ -0,0 +1,10 @@
+import { Maybe } from "purify-ts";
+import type { OptionalKind, ParameterDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function toRdfFunctionOrMethodDeclaration(this: ObjectType): Maybe<{
+    name: string;
+    parameters: OptionalKind<ParameterDeclarationStructure>[];
+    returnType: string;
+    statements: string[];
+}>;
+//# sourceMappingURL=toRdfFunctionOrMethodDeclaration.d.ts.map

package/generators/ts/_ObjectType/toRdfFunctionOrMethodDeclaration.js

@@ -0,0 +1,67 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+const variables = {
+    ignoreRdfType: "ignoreRdfType",
+    mutateGraph: "mutateGraph",
+    resource: "_resource",
+    resourceSet: "resourceSet",
+};
+export function toRdfFunctionOrMethodDeclaration() {
+    if (!this.features.has("toRdf")) {
+        return Maybe.empty();
+    }
+    this.ensureAtMostOneSuperObjectType();
+    let usedIgnoreRdfTypeVariable = false;
+    const statements = [];
+    if (this.parentObjectTypes.length > 0) {
+        const superToRdfOptions = `{ ${variables.ignoreRdfType}: true, ${variables.mutateGraph}, ${variables.resourceSet} }`;
+        let superToRdfCall;
+        switch (this.declarationType) {
+            case "class":
+                superToRdfCall = `super.toRdf(${superToRdfOptions})`;
+                break;
+            case "interface":
+                superToRdfCall = `${this.parentObjectTypes[0].name}.toRdf(${this.thisVariable}, ${superToRdfOptions})`;
+                break;
+        }
+        statements.push(`const ${variables.resource} = ${superToRdfCall};`);
+        usedIgnoreRdfTypeVariable = !this.parentObjectTypes[0].abstract;
+    }
+    else if (this.identifierType.isNamedNodeKind) {
+        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableNamedResource({ identifier: ${this.thisVariable}.${this.identifierProperty.name}, ${variables.mutateGraph} });`);
+    }
+    else {
+        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableResource({ identifier: ${this.thisVariable}.${this.identifierProperty.name}, ${variables.mutateGraph} });`);
+    }
+    if (this.toRdfTypes.length > 0) {
+        statements.push(`if (!${variables.ignoreRdfType}) { ${this.toRdfTypes.map((toRdfType) => `${variables.resource}.add(${variables.resource}.dataFactory.namedNode("${rdf.type.value}"), ${variables.resource}.dataFactory.namedNode("${toRdfType.value}"));`).join(" ")} }`);
+        usedIgnoreRdfTypeVariable = true;
+    }
+    for (const property of this.properties) {
+        statements.push(...property.toRdfStatements({
+            variables: {
+                ...variables,
+                value: `${this.thisVariable}.${property.name}`,
+            },
+        }));
+    }
+    statements.push(`return ${variables.resource};`);
+    const parameters = [];
+    if (this.declarationType === "interface") {
+        parameters.push({
+            name: this.thisVariable,
+            type: this.name,
+        });
+    }
+    parameters.push({
+        name: `{ ${usedIgnoreRdfTypeVariable ? `${variables.ignoreRdfType}, ` : ""}${variables.mutateGraph}, ${variables.resourceSet} }`,
+        type: `{ ${variables.ignoreRdfType}?: boolean; ${variables.mutateGraph}: rdfjsResource.MutableResource.MutateGraph, ${variables.resourceSet}: rdfjsResource.MutableResourceSet }`,
+    });
+    return Maybe.of({
+        name: "toRdf",
+        parameters,
+        returnType: this.rdfjsResourceType({ mutable: true }).name,
+        statements,
+    });
+}
+//# sourceMappingURL=toRdfFunctionOrMethodDeclaration.js.map

package/generators/ts/objectInitializer.d.ts

@@ -0,0 +1,2 @@
+export declare function objectInitializer(properties: Record<string, boolean | number | string | undefined>): string;
+//# sourceMappingURL=objectInitializer.d.ts.map

package/generators/ts/objectInitializer.js

@@ -0,0 +1,14 @@
+export function objectInitializer(properties) {
+    return `{ ${Object.entries(properties)
+        .flatMap(([propertyName, propertyValue]) => {
+        if (typeof propertyValue === "undefined") {
+            return [];
+        }
+        if (typeof propertyValue === "string" && propertyName === propertyValue) {
+            return [propertyName];
+        }
+        return [`${propertyName}: ${propertyValue}`];
+    })
+        .join(", ")} }`;
+}
+//# sourceMappingURL=objectInitializer.js.map

package/generators/ts/tsComment.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Prefix a comment with multiline comment delimiters.
+ */
+export declare function tsComment(comment: string): string;
+//# sourceMappingURL=tsComment.d.ts.map

package/generators/ts/tsComment.js

@@ -0,0 +1,11 @@
+/**
+ * Prefix a comment with multiline comment delimiters.
+ */
+export function tsComment(comment) {
+    return `/**\n${comment
+        .trim()
+        .split(/\r?\n|\r|\n/g)
+        .map((line) => ` * ${line}`)
+        .join("\n")}\n */\n`;
+}
+//# sourceMappingURL=tsComment.js.map

package/generators/ts/tsName.d.ts

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

package/generators/ts/tsName.js

@@ -4,6 +4,7 @@ export function tsName(astName) {
     for (const tsNameAlternative of [
         astName.shaclmateName.extract(),
         astName.shName.extract()?.replace(" ", "_"),
+        astName.label.extract()?.replace(" ", "_"),
         astName.curie.map((curie) => curie.replace(":", "_")).extract(),
         astName.propertyPath
             .chain((propertyPath) => propertyPath.curie.map((curie) => curie.replace(":", "_")))

package/index.d.ts

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

package/index.js

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

package/input/NodeShape.d.ts

@@ -0,0 +1,46 @@
+import type { NamedNode } from "@rdfjs/types";
+import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+import type { MintingStrategy, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type { Shape } from "./Shape.js";
+import type * as generated from "./generated.js";
+import type { Ontology, PropertyGroup, PropertyShape, ShapesGraph } from "./index.js";
+export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, PropertyGroup, PropertyShape, Shape> {
+    readonly isClass: boolean;
+    readonly isList: boolean;
+    private readonly ancestorClassIris;
+    private readonly childClassIris;
+    private readonly descendantClassIris;
+    private readonly generatedShaclmateNodeShape;
+    private readonly parentClassIris;
+    constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }: {
+        ancestorClassIris: readonly NamedNode[];
+        generatedShaclmateNodeShape: generated.ShaclmateNodeShape;
+        childClassIris: readonly NamedNode[];
+        descendantClassIris: readonly NamedNode[];
+        isClass: boolean;
+        isList: boolean;
+        parentClassIris: readonly NamedNode[];
+        shapesGraph: ShapesGraph;
+    });
+    get abstract(): Maybe<boolean>;
+    get ancestorNodeShapes(): readonly NodeShape[];
+    get childNodeShapes(): readonly NodeShape[];
+    get descendantNodeShapes(): readonly NodeShape[];
+    get export(): Maybe<boolean>;
+    get extern(): Maybe<boolean>;
+    get fromRdfType(): Maybe<NamedNode>;
+    get mintingStrategy(): Maybe<MintingStrategy>;
+    get mutable(): Maybe<boolean>;
+    get nodeKinds(): Set<"BlankNode" | "NamedNode">;
+    get parentNodeShapes(): readonly NodeShape[];
+    get shaclmateName(): Maybe<string>;
+    get toRdfTypes(): readonly NamedNode[];
+    get tsFeatures(): Maybe<Set<TsFeature>>;
+    get tsImports(): readonly string[];
+    get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
+    get tsObjectIdentifierPropertyName(): Maybe<string>;
+    get tsObjectTypeDiscriminatorPropertyName(): Maybe<string>;
+    private get _mintingStrategy();
+}
+//# sourceMappingURL=NodeShape.d.ts.map