@shaclmate/compiler 2.0.12 → 2.0.14

package/generators/ts/_ObjectType/sparqlFunctionDeclarations.js

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

package/input/NodeShape.js

@@ -0,0 +1,165 @@
+import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+import { tsFeatures } from "./tsFeatures.js";
+export class NodeShape extends ShaclCoreNodeShape {
+    constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }) {
+        super(generatedShaclmateNodeShape, shapesGraph);
+        this.ancestorClassIris = ancestorClassIris;
+        this.childClassIris = childClassIris;
+        this.descendantClassIris = descendantClassIris;
+        this.generatedShaclmateNodeShape = generatedShaclmateNodeShape;
+        this.isClass = isClass;
+        this.isList = isList;
+        this.parentClassIris = parentClassIris;
+    }
+    get abstract() {
+        return this.generatedShaclmateNodeShape.abstract;
+    }
+    get ancestorNodeShapes() {
+        return this.isClass
+            ? this.ancestorClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
+            : [];
+    }
+    get childNodeShapes() {
+        return this.isClass
+            ? this.childClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
+            : [];
+    }
+    get descendantNodeShapes() {
+        return this.isClass
+            ? this.descendantClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
+            : [];
+    }
+    get export() {
+        return this.generatedShaclmateNodeShape.export_;
+    }
+    get extern() {
+        return this.generatedShaclmateNodeShape.extern;
+    }
+    get fromRdfType() {
+        // Check for an explicit shaclmate:fromRdfType
+        const fromRdfType = this.generatedShaclmateNodeShape.fromRdfType;
+        if (fromRdfType.isJust()) {
+            return fromRdfType;
+        }
+        // No explicit shaclmate:fromRdfType
+        // If the shape is a class, not abstract, and identified by an IRI then use the shape IRI as the fromRdfType.
+        if (!this.abstract.orDefault(false) &&
+            this.isClass &&
+            this.identifier.termType === "NamedNode") {
+            return Maybe.of(this.identifier);
+        }
+        return Maybe.empty();
+    }
+    get mintingStrategy() {
+        const thisMintingStrategy = this._mintingStrategy;
+        if (thisMintingStrategy.isNothing()) {
+            for (const ancestorNodeShape of this.ancestorNodeShapes) {
+                const ancestorMintingStrategy = ancestorNodeShape._mintingStrategy;
+                if (ancestorMintingStrategy.isJust()) {
+                    return ancestorMintingStrategy;
+                }
+            }
+        }
+        return thisMintingStrategy;
+    }
+    get mutable() {
+        return this.generatedShaclmateNodeShape.mutable;
+    }
+    get nodeKinds() {
+        const thisNodeKinds = new Set([...this.constraints.nodeKinds.orDefault(new Set())].filter((nodeKind) => nodeKind !== "Literal"));
+        const parentNodeKinds = new Set();
+        for (const parentNodeShape of this.parentNodeShapes) {
+            for (const parentNodeKind of parentNodeShape.nodeKinds) {
+                parentNodeKinds.add(parentNodeKind);
+            }
+        }
+        if (thisNodeKinds.size === 0 && parentNodeKinds.size > 0) {
+            // No node kinds on this shape, use the parent's
+            return parentNodeKinds;
+        }
+        if (thisNodeKinds.size > 0 && parentNodeKinds.size > 0) {
+            // Node kinds on this shape and the parent's shape
+            // This node kinds must be a subset of parent node kinds.
+            for (const thisNodeKind of thisNodeKinds) {
+                if (!parentNodeKinds.has(thisNodeKind)) {
+                    throw new Error(`${this} has a nodeKind ${thisNodeKind} that is not in its parent's node kinds`);
+                }
+            }
+        }
+        if (thisNodeKinds.size === 0) {
+            // Default: both node kinds
+            thisNodeKinds.add("BlankNode");
+            thisNodeKinds.add("NamedNode");
+        }
+        return thisNodeKinds;
+    }
+    get parentNodeShapes() {
+        return this.isClass
+            ? this.parentClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
+            : [];
+    }
+    get shaclmateName() {
+        return this.generatedShaclmateNodeShape.name;
+    }
+    get toRdfTypes() {
+        // Look for one or more explicit shaclmate:toRdfType's
+        const toRdfTypes = this.generatedShaclmateNodeShape.toRdfTypes.concat();
+        // Ensure the toRdfTypes includes the fromRdfType if there is one
+        this.fromRdfType.ifJust((fromRdfType) => {
+            if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
+                toRdfTypes.push(fromRdfType);
+            }
+        });
+        if (toRdfTypes.length === 0) {
+            // No explicit shaclmate:toRdfType's
+            // If the shape is a class, not abstract, and identified by an IRI then use the shape IRI as the fromRdfType.
+            if (!this.abstract.orDefault(false) &&
+                this.isClass &&
+                this.identifier.termType === "NamedNode") {
+                toRdfTypes.push(this.identifier);
+            }
+        }
+        return toRdfTypes;
+    }
+    get tsFeatures() {
+        return tsFeatures(this.generatedShaclmateNodeShape).altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsFeatures));
+    }
+    get tsImports() {
+        return this.generatedShaclmateNodeShape.tsImports;
+    }
+    get tsObjectDeclarationType() {
+        return this.generatedShaclmateNodeShape.tsObjectDeclarationType
+            .map((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class":
+                    return "class";
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface":
+                    return "interface";
+                default:
+                    throw new RangeError(iri.value);
+            }
+        })
+            .altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectDeclarationType));
+    }
+    get tsObjectIdentifierPropertyName() {
+        return this.generatedShaclmateNodeShape.tsObjectIdentifierPropertyName;
+    }
+    get tsObjectTypeDiscriminatorPropertyName() {
+        return this.generatedShaclmateNodeShape
+            .tsObjectTypeDiscriminatorPropertyName;
+    }
+    get _mintingStrategy() {
+        return this.generatedShaclmateNodeShape.mintingStrategy.map((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256":
+                    return "sha256";
+                case "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4":
+                    return "uuidv4";
+                default:
+                    throw new RangeError(iri.value);
+            }
+        });
+    }
+}
+//# sourceMappingURL=NodeShape.js.map