@shaclmate/compiler 2.0.13 → 2.0.15

package/generators/ts/_ObjectType/ShaclProperty.js

@@ -7,13 +7,30 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { pascalCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
+import { tsComment } from "../tsComment.js";
 import { Property } from "./Property.js";
 export class ShaclProperty extends Property {
-    constructor({ path, ...superParameters }) {
+    constructor({ comment, description, label, mutable, path, ...superParameters }) {
         super(superParameters);
+        this.comment = comment;
+        this.description = description;
+        this.label = label;
+        this.mutable = mutable;
         this.path = path;
     }
-    get classConstructorParametersPropertySignature() {
+    get classGetAccessorDeclaration() {
+        return Maybe.empty();
+    }
+    get classPropertyDeclaration() {
+        return Maybe.of({
+            isReadonly: !this.mutable,
+            leadingTrivia: this.declarationComment,
+            name: this.name,
+            scope: Property.visibilityToScope(this.visibility),
+            type: this.type.name,
+        });
+    }
+    get constructorParametersPropertySignature() {
         let hasQuestionToken = false;
         const typeNames = new Set(); // Remove duplicates with a set
         for (const conversion of this.type.conversions) {
@@ -27,35 +44,44 @@ export class ShaclProperty extends Property {
         return Maybe.of({
             hasQuestionToken,
             isReadonly: true,
+            leadingTrivia: this.declarationComment,
             name: this.name,
             type: [...typeNames].sort().join(" | "),
         });
     }
-    get classGetAccessorDeclaration() {
-        return Maybe.empty();
+    get declarationImports() {
+        return this.type.useImports(this.objectType.features);
     }
-    get classPropertyDeclaration() {
+    get equalsFunction() {
+        return this.type.equalsFunction;
+    }
+    get interfacePropertySignature() {
         return {
-            isReadonly: true,
+            isReadonly: !this.mutable,
+            leadingTrivia: this.declarationComment,
             name: this.name,
             type: this.type.name,
         };
     }
-    get equalsFunction() {
-        return this.type.equalsFunction();
-    }
-    get importStatements() {
-        return this.type.importStatements;
-    }
-    get interfacePropertySignature() {
+    get jsonPropertySignature() {
         return {
             isReadonly: true,
             name: this.name,
-            type: this.type.name,
+            type: this.type.jsonName,
         };
     }
+    get snippetDeclarations() {
+        return this.type.snippetDeclarations(this.objectType.features);
+    }
+    get declarationComment() {
+        return this.comment
+            .alt(this.description)
+            .alt(this.label)
+            .map(tsComment)
+            .extract();
+    }
     get pathExpression() {
-        return `${this.configuration.dataFactoryVariable}.namedNode("${this.path.value}")`;
+        return `${this.dataFactoryVariable}.namedNode("${this.path.value}")`;
     }
     classConstructorStatements({ variables, }) {
         const typeConversions = this.type.conversions;
@@ -64,12 +90,17 @@ export class ShaclProperty extends Property {
         }
         const statements = [];
         for (const conversion of this.type.conversions) {
-            statements.push(`if (${conversion.sourceTypeCheckExpression ? conversion.sourceTypeCheckExpression(variables.parameter) : `typeof ${variables.parameter} === "${conversion.sourceTypeName}"`}) { this.${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+            statements.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { this.${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
         }
         // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-        statements.push(`{ this.${this.name} = ${variables.parameter}; // never\n }`);
+        statements.push(`{ this.${this.name} =( ${variables.parameter}) as never;\n }`);
         return [statements.join(" else ")];
     }
+    fromJsonStatements({ variables, }) {
+        return [
+            `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: `${variables.jsonObject}["${this.name}"]` } })};`,
+        ];
+    }
     fromRdfStatements({ variables, }) {
         return [
             `const _${this.name}Either: purify.Either<rdfjsResource.Resource.ValueError, ${this.type.name}> = ${this.type.fromRdfExpression({ variables: { ...variables, predicate: this.pathExpression, resourceValues: `${variables.resource}.values(${this.pathExpression}, { unique: true })` } })};`,
@@ -80,17 +111,63 @@ export class ShaclProperty extends Property {
     hashStatements(parameters) {
         return this.type.hashStatements(parameters);
     }
-    sparqlGraphPatternExpression() {
-        return Maybe.of(this.type
-            .propertySparqlGraphPatternExpression({
+    interfaceConstructorStatements({ variables, }) {
+        const typeConversions = this.type.conversions;
+        if (typeConversions.length === 1) {
+            return [`const ${this.name} = ${variables.parameter};`];
+        }
+        const statements = [`let ${this.name}: ${this.type.name};`];
+        const conversionBranches = [];
+        for (const conversion of this.type.conversions) {
+            conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+        }
+        // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
+        conversionBranches.push(`{ ${this.name} =( ${variables.parameter}) as never;\n }`);
+        statements.push(conversionBranches.join(" else "));
+        return statements;
+    }
+    jsonUiSchemaElement({ variables, }) {
+        const scope = `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
+        return this.type
+            .jsonUiSchemaElement({ variables: { scopePrefix: scope } })
+            .altLazy(() => Maybe.of(`{ ${this.label.isJust() ? `label: "${this.label.unsafeCoerce()}", ` : ""}scope: ${scope}, type: "Control" }`));
+    }
+    jsonZodSchema(parameters) {
+        let schema = this.type.jsonZodSchema(parameters);
+        this.comment.alt(this.description).ifJust((description) => {
+            schema = `${schema}.describe(${JSON.stringify(description)})`;
+        });
+        return {
+            key: this.name,
+            schema,
+        };
+    }
+    sparqlConstructTemplateTriples({ variables, }) {
+        const objectString = `\`\${${variables.variablePrefix}}${pascalCase(this.name)}\``;
+        return this.type.sparqlConstructTemplateTriples({
+            context: "property",
             variables: {
-                object: `this.variable("${pascalCase(this.name)}")`,
-                predicate: this.pathExpression,
-                subject: "this.subject",
+                object: `${this.dataFactoryVariable}.variable!(${objectString})`,
+                predicate: this.rdfjsTermExpression(this.path),
+                subject: variables.subject,
+                variablePrefix: objectString,
             },
-        })
-            .toSparqlGraphPatternExpression()
-            .toString());
+        });
+    }
+    sparqlWherePatterns({ variables, }) {
+        const objectString = `\`\${${variables.variablePrefix}}${pascalCase(this.name)}\``;
+        return this.type.sparqlWherePatterns({
+            context: "property",
+            variables: {
+                object: `${this.dataFactoryVariable}.variable!(${objectString})`,
+                predicate: this.rdfjsTermExpression(this.path),
+                subject: variables.subject,
+                variablePrefix: objectString,
+            },
+        });
+    }
+    toJsonObjectMember(parameters) {
+        return `${this.name}: ${this.type.toJsonExpression(parameters)}`;
     }
     toRdfStatements({ variables, }) {
         return [

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

@@ -2,28 +2,44 @@ 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 equalsFunction = "strictEquals";
+    readonly mutable = false;
     readonly value: string;
     private readonly abstract;
     private readonly override;
-    constructor({ abstract, override, value, ...superParameters }: {
+    constructor({ abstract, override, type, value, ...superParameters }: {
         abstract: boolean;
         override: boolean;
+        type: TypeDiscriminatorProperty.Type;
         value: string;
     } & ConstructorParameters<typeof Property>[0]);
-    get classConstructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    get classPropertyDeclaration(): OptionalKind<PropertyDeclarationStructure>;
+    get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get snippetDeclarations(): readonly string[];
     classConstructorStatements(): readonly string[];
+    fromJsonStatements(): readonly string[];
     fromRdfStatements(): readonly string[];
     hashStatements(): readonly string[];
-    sparqlGraphPatternExpression(): Maybe<string>;
+    interfaceConstructorStatements(): readonly string[];
+    jsonUiSchemaElement({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<string>;
+    jsonZodSchema({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["jsonZodSchema"]>[0]): ReturnType<Property<TypeDiscriminatorProperty.Type>["jsonZodSchema"]>;
+    sparqlConstructTemplateTriples(): readonly string[];
+    sparqlWherePatterns(): readonly string[];
+    toJsonObjectMember({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["toJsonObjectMember"]>[0]): string;
     toRdfStatements(): readonly string[];
 }
 export declare namespace TypeDiscriminatorProperty {
-    interface Type {
-        readonly name: string;
+    class Type {
+        readonly mutable: boolean;
+        readonly values: readonly string[];
+        constructor({ mutable, values, }: {
+            mutable: boolean;
+            values: readonly string[];
+        });
+        get name(): string;
     }
 }
 //# sourceMappingURL=TypeDiscriminatorProperty.d.ts.map

package/generators/ts/_ObjectType/TypeDiscriminatorProperty.js

@@ -1,53 +1,122 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { Property } from "./Property.js";
 export class TypeDiscriminatorProperty extends Property {
-    constructor({ abstract, override, value, ...superParameters }) {
-        super(superParameters);
-        this.equalsFunction = "purifyHelpers.Equatable.strictEquals";
+    constructor({ abstract, override, type, value, ...superParameters }) {
+        super({ ...superParameters, type });
+        this.equalsFunction = "strictEquals";
+        this.mutable = false;
+        invariant(this.visibility === "public");
         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,
+        return Maybe.of({
+            // Work around a ts-morph bug that puts the override keyword before the abstract keyword
+            isAbstract: this.abstract && this.override ? undefined : this.abstract,
+            hasOverrideKeyword: this.abstract && this.override ? undefined : this.override,
             initializer: !this.abstract ? `"${this.value}"` : undefined,
+            isReadonly: true,
+            leadingTrivia: this.abstract && this.override ? "abstract override " : undefined,
+            name: this.name,
+            type: !this.abstract && this.type.name === `"${this.value}"`
+                ? undefined
+                : this.type.name,
+        });
+    }
+    get constructorParametersPropertySignature() {
+        return Maybe.empty();
+    }
+    get interfacePropertySignature() {
+        return {
             isReadonly: true,
             name: this.name,
             type: this.type.name,
         };
     }
-    get interfacePropertySignature() {
+    get jsonPropertySignature() {
         return {
             isReadonly: true,
             name: this.name,
             type: this.type.name,
         };
     }
+    get snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.strictEquals);
+        }
+        return snippetDeclarations;
+    }
     classConstructorStatements() {
         return [];
     }
+    fromJsonStatements() {
+        return this.fromRdfStatements();
+    }
     fromRdfStatements() {
-        return !this.abstract &&
-            this.configuration.objectTypeDeclarationType === "interface"
+        return !this.abstract && this.objectType.declarationType === "interface"
             ? [`const ${this.name} = "${this.value}" as const`]
             : [];
     }
     hashStatements() {
         return [];
     }
-    sparqlGraphPatternExpression() {
-        return Maybe.empty();
+    interfaceConstructorStatements() {
+        return !this.abstract
+            ? [`const ${this.name} = "${this.value}" as const`]
+            : [];
+    }
+    jsonUiSchemaElement({ variables, }) {
+        const scope = `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
+        return Maybe.of(`{ rule: { condition: { schema: { const: "${this.value}" }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
+    }
+    jsonZodSchema({ variables, }) {
+        return {
+            key: this.name,
+            schema: this.type.values.length > 1
+                ? `${variables.zod}.enum(${JSON.stringify(this.type.values)})`
+                : `${variables.zod}.literal("${this.type.values[0]}")`,
+        };
+    }
+    sparqlConstructTemplateTriples() {
+        return [];
+    }
+    sparqlWherePatterns() {
+        return [];
+    }
+    toJsonObjectMember({ variables, }) {
+        return `${this.name}: ${variables.value}`;
     }
     toRdfStatements() {
         return [];
     }
 }
+(function (TypeDiscriminatorProperty) {
+    class Type {
+        constructor({ mutable, values, }) {
+            this.mutable = mutable;
+            this.values = values;
+        }
+        get name() {
+            return this.values.map((name) => `"${name}"`).join(" | ");
+        }
+    }
+    __decorate([
+        Memoize()
+    ], Type.prototype, "name", null);
+    TypeDiscriminatorProperty.Type = Type;
+})(TypeDiscriminatorProperty || (TypeDiscriminatorProperty = {}));
 //# sourceMappingURL=TypeDiscriminatorProperty.js.map

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

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

package/generators/ts/_ObjectType/classDeclaration.js

@@ -1,154 +1,122 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { StructureKind, } from "ts-morph";
-import { hasherTypeConstraint } from "./hashFunctionDeclaration.js";
+import { tsComment } from "../tsComment.js";
+import { equalsFunctionOrMethodDeclaration } from "./equalsFunctionOrMethodDeclaration.js";
+import { hashFunctionOrMethodDeclaration } from "./hashFunctionOrMethodDeclaration.js";
+import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
+import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
 function constructorDeclaration() {
-    if (this.properties.length === 0) {
-        return null;
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature
+        .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+        .toList());
+    let parametersType;
+    if (parametersPropertySignatures.length > 0) {
+        parametersType = `{ ${parametersPropertySignatures.join(", ")} }`;
+    }
+    else {
+        parametersType = "";
     }
-    const statements = [];
     if (this.parentObjectTypes.length > 0) {
-        statements.push("super(parameters);");
+        // Pass up parameters
+        parametersType = `${parametersType}${parametersType.length > 0 ? " & " : ""}ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`;
     }
-    for (const property of this.properties) {
-        for (const statement of property.classConstructorStatements({
-            variables: { parameter: `parameters.${property.name}` },
-        })) {
-            statements.push(statement);
-        }
+    if (parametersType.length === 0) {
+        parametersType = "object";
     }
-    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(", ")} }`;
+    const statements = [];
     if (this.parentObjectTypes.length > 0) {
-        constructorParametersType = `${constructorParametersType} & ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`;
+        // An ancestor object type may be extern so we always have a constructor and always pass up parameters instead
+        // of trying to sense whether we need to or not.
+        statements.push("super(parameters);");
     }
+    const propertyStatements = this.properties.flatMap((property) => property.classConstructorStatements({
+        variables: { parameter: `parameters.${property.name}` },
+    }));
+    statements.push(...propertyStatements);
     return {
+        leadingTrivia: propertyStatements.length === 0
+            ? "// biome-ignore lint/complexity/noUselessConstructor: Always have a constructor\n"
+            : undefined,
         parameters: [
             {
-                name: "parameters",
-                type: constructorParametersType,
+                name: statements.length > 0 ? "parameters" : "_parameters",
+                type: parametersType,
             },
         ],
         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.declarationType !== "class") {
+        return Maybe.empty();
     }
-    if (this.configuration.features.has("toRdf")) {
-        methods.push(toRdfMethodDeclaration.bind(this)());
+    if (this.extern) {
+        return Maybe.empty();
     }
+    this.ensureAtMostOneSuperObjectType();
     const getAccessors = [];
     const properties = [];
     for (const property of this.properties) {
-        properties.push(property.classPropertyDeclaration);
+        property.classPropertyDeclaration.ifJust((propertyDeclaration) => properties.push(propertyDeclaration));
         property.classGetAccessorDeclaration.ifJust((getAccessor) => getAccessors.push(getAccessor));
     }
-    return {
-        ctors: constructorDeclaration_ !== null ? [constructorDeclaration_] : undefined,
+    return Maybe.of({
+        ctors: [constructorDeclaration.bind(this)()],
         extends: this.parentObjectTypes.length > 0
             ? this.parentObjectTypes[0].name
             : undefined,
         getAccessors,
         isAbstract: this.abstract,
+        isExported: this.export,
         kind: StructureKind.Class,
-        isExported: this.export_,
-        methods,
+        leadingTrivia: this.comment.alt(this.label).map(tsComment).extract(),
+        methods: [
+            ...equalsMethodDeclaration.bind(this)().toList(),
+            ...hashMethodDeclaration.bind(this)().toList(),
+            ...toJsonMethodDeclaration.bind(this)().toList(),
+            ...toRdfMethodDeclaration.bind(this)().toList(),
+            ...toStringMethodDeclaration.bind(this)().toList(),
+        ],
         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",
-    };
+    return equalsFunctionOrMethodDeclaration.bind(this)();
 }
 function hashMethodDeclaration() {
-    return {
-        hasOverrideKeyword: this.parentObjectTypes.length > 0,
+    return hashFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((hashFunctionOrMethodDeclaration) => ({
+        ...hashFunctionOrMethodDeclaration,
         name: "hash",
-        parameters: [
-            {
-                name: "hasher",
-                type: "HasherT",
-            },
-        ],
-        returnType: "HasherT",
-        statements: [`return ${this.name}.${this.hashFunctionName}(this, hasher);`],
-        typeParameters: [
-            {
-                name: "HasherT",
-                constraint: hasherTypeConstraint,
-            },
-        ],
-    };
+    }));
+}
+function toJsonMethodDeclaration() {
+    return toJsonFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((toJsonFunctionOrMethodDeclaration) => ({
+        ...toJsonFunctionOrMethodDeclaration,
+        hasOverrideKeyword: this.parentObjectTypes.length > 0,
+    }));
 }
 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}` },
-        }));
+    return toRdfFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((toRdfFunctionOrMethodDeclaration) => ({
+        ...toRdfFunctionOrMethodDeclaration,
+        hasOverrideKeyword: this.parentObjectTypes.length > 0,
+    }));
+}
+function toStringMethodDeclaration() {
+    if (!this.features.has("toJson")) {
+        return Maybe.empty();
     }
-    statements.push(`return ${variables.resource};`);
-    return {
+    return Maybe.of({
         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,
-    };
+        name: "toString",
+        returnType: "string",
+        statements: ["return JSON.stringify(this.toJson());"],
+    });
 }
 //# sourceMappingURL=classDeclaration.js.map

package/generators/ts/_ObjectType/createFunctionDeclaration.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 createFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
+//# sourceMappingURL=createFunctionDeclaration.d.ts.map