@shaclmate/compiler 2.0.13 → 2.0.15

package/generators/ts/_ObjectType/createFunctionDeclaration.js

@@ -0,0 +1,60 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { StructureKind } from "ts-morph";
+export function createFunctionDeclaration() {
+    if (!this.features.has("create")) {
+        return Maybe.empty();
+    }
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature
+        .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+        .toList());
+    // Should always have at least an identifier
+    invariant(parametersPropertySignatures.length > 0);
+    const parametersType = [`{ ${parametersPropertySignatures.join(", ")} }`]
+        .concat(this.parentObjectTypes.map((parentObjectType) => `Parameters<typeof ${parentObjectType.name}.create>[0]`))
+        .join(" & ");
+    const propertyInitializers = [];
+    const omitPropertyNames = [];
+    const propertyStatements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        propertyInitializers.push(`...${parentObjectType.name}.create(parameters)`);
+    }
+    for (const property of this.properties) {
+        const thisPropertyStatements = property.interfaceConstructorStatements({
+            variables: { parameter: `parameters.${property.name}` },
+        });
+        if (thisPropertyStatements.length > 0) {
+            propertyInitializers.push(property.name);
+            propertyStatements.push(...thisPropertyStatements);
+        }
+        else {
+            omitPropertyNames.push(property.name);
+        }
+    }
+    invariant(propertyInitializers.length > 0);
+    invariant(propertyStatements.length > 0);
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "create",
+        parameters: [
+            {
+                name: "parameters",
+                type: parametersType,
+            },
+        ],
+        returnType: omitPropertyNames.length === 0
+            ? this.name
+            : `Omit<${this.name}, ${omitPropertyNames.map((omitPropertyName) => `"${omitPropertyName}"`).join(" | ")}>`,
+        statements: propertyStatements.concat([
+            `return { ${propertyInitializers.join(", ")} }`,
+        ]),
+    });
+}
+//# sourceMappingURL=createFunctionDeclaration.js.map

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

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

package/generators/ts/_ObjectType/equalsFunctionDeclaration.js

@@ -1,27 +1,19 @@
+import { Maybe } from "purify-ts";
 import { StructureKind } from "ts-morph";
+import { equalsFunctionOrMethodDeclaration } from "./equalsFunctionOrMethodDeclaration.js";
 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})`;
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
     }
-    return {
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    return equalsFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((equalsFunctionOrMethodDeclaration) => ({
+        ...equalsFunctionOrMethodDeclaration,
         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/equalsFunctionOrMethodDeclaration.d.ts

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

package/generators/ts/_ObjectType/equalsFunctionOrMethodDeclaration.js

@@ -0,0 +1,70 @@
+import { Maybe } from "purify-ts";
+export function equalsFunctionOrMethodDeclaration() {
+    if (!this.features.has("equals")) {
+        return Maybe.empty();
+    }
+    if (this.declarationType === "class" && this.ownProperties.length === 0) {
+        // If there's a parent class and no properties in this class, can skip overriding equals
+        return Maybe.empty();
+    }
+    let leftVariable;
+    let rightVariable;
+    switch (this.declarationType) {
+        case "class":
+            leftVariable = "this";
+            rightVariable = "other";
+            break;
+        case "interface":
+            leftVariable = "left";
+            rightVariable = "right";
+    }
+    const chain = [];
+    let hasOverrideKeyword = false;
+    if (this.parentObjectTypes.length > 0) {
+        switch (this.declarationType) {
+            case "class": {
+                chain.push("super.equals(other)");
+                hasOverrideKeyword = true;
+                break;
+            }
+            case "interface": {
+                // For every parent, find the nearest equals implementation
+                for (const parentObjectType of this.parentObjectTypes) {
+                    chain.push(`${parentObjectType.name}.equals(left, right)`);
+                }
+                break;
+            }
+        }
+    }
+    for (const property of this.ownProperties) {
+        chain.push(`(${property.equalsFunction})(${leftVariable}.${property.name}, ${rightVariable}.${property.name}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "Property" as const }))`);
+    }
+    return Maybe.of({
+        hasOverrideKeyword,
+        name: "equals",
+        parameters: this.declarationType === "interface"
+            ? [
+                {
+                    name: "left",
+                    type: this.name,
+                },
+                {
+                    name: "right",
+                    type: this.name,
+                },
+            ]
+            : [
+                {
+                    name: "other",
+                    type: this.name,
+                },
+            ],
+        returnType: "EqualsResult",
+        statements: [
+            `return ${chain
+                .map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : `chain(() => ${chainPart})`)
+                .join(".")};`,
+        ],
+    });
+}
+//# sourceMappingURL=equalsFunctionOrMethodDeclaration.js.map

package/generators/ts/_ObjectType/fromJsonFunctionDeclarations.d.ts

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

package/generators/ts/_ObjectType/fromJsonFunctionDeclarations.js

@@ -0,0 +1,78 @@
+import { StructureKind } from "ts-morph";
+const variables = {
+    jsonObject: "_jsonObject",
+};
+export function fromJsonFunctionDeclarations() {
+    if (!this.features.has("fromJson")) {
+        return [];
+    }
+    if (this.extern) {
+        return [];
+    }
+    const initializers = [];
+    const propertyReturnTypeSignatures = [];
+    const propertiesFromJsonFunctionReturnType = [];
+    const propertiesFromJsonFunctionStatements = [];
+    propertiesFromJsonFunctionStatements.push(`const _jsonSafeParseResult = ${this.jsonZodSchemaFunctionName}().safeParse(_json);`, "if (!_jsonSafeParseResult.success) { return purify.Left(_jsonSafeParseResult.error); }", `const ${variables.jsonObject} = _jsonSafeParseResult.data;`);
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        propertiesFromJsonFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}.propertiesFromJson(${variables.jsonObject});`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
+        initializers.push(`..._super${parentObjectTypeI}`);
+        propertiesFromJsonFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromJson>>`);
+    });
+    for (const property of this.properties) {
+        const propertyFromJsonStatements = property.fromJsonStatements({
+            variables,
+        });
+        if (propertyFromJsonStatements.length > 0) {
+            propertiesFromJsonFunctionStatements.push(...propertyFromJsonStatements);
+            initializers.push(property.name);
+            propertyReturnTypeSignatures.push(`${property.name}: ${property.type.name};`);
+        }
+    }
+    propertiesFromJsonFunctionStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
+    if (propertyReturnTypeSignatures.length > 0) {
+        propertiesFromJsonFunctionReturnType.splice(0, 0, `{ ${propertyReturnTypeSignatures.join(" ")} }`);
+    }
+    const fromJsonFunctionDeclarations = [];
+    fromJsonFunctionDeclarations.push({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "propertiesFromJson",
+        parameters: [
+            {
+                name: "_json",
+                type: "unknown",
+            },
+        ],
+        returnType: `purify.Either<zod.ZodError, ${propertiesFromJsonFunctionReturnType.join(" & ")}>`,
+        statements: propertiesFromJsonFunctionStatements,
+    });
+    if (!this.abstract) {
+        let fromJsonStatements;
+        switch (this.declarationType) {
+            case "class":
+                fromJsonStatements = [
+                    `return ${this.name}.propertiesFromJson(json).map(properties => new ${this.name}(properties));`,
+                ];
+                break;
+            case "interface":
+                fromJsonStatements = [`return ${this.name}.propertiesFromJson(json);`];
+                break;
+        }
+        fromJsonFunctionDeclarations.push({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "fromJson",
+            parameters: [
+                {
+                    name: "json",
+                    type: "unknown",
+                },
+            ],
+            returnType: `purify.Either<zod.ZodError, ${this.name}>`,
+            statements: fromJsonStatements,
+        });
+    }
+    return fromJsonFunctionDeclarations;
+}
+//# sourceMappingURL=fromJsonFunctionDeclarations.js.map

package/generators/ts/_ObjectType/fromRdfFunctionDeclarations.d.ts

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

package/generators/ts/_ObjectType/fromRdfFunctionDeclarations.js

@@ -0,0 +1,91 @@
+import { StructureKind } from "ts-morph";
+import { objectInitializer } from "../objectInitializer.js";
+const variables = {
+    context: "_context",
+    ignoreRdfType: "_ignoreRdfType",
+    languageIn: "_languageIn",
+    resource: "_resource",
+};
+export function fromRdfFunctionDeclarations() {
+    if (!this.features.has("fromRdf")) {
+        return [];
+    }
+    if (this.extern) {
+        return [];
+    }
+    const initializers = [];
+    const propertySignatures = [];
+    const propertiesFromRdfFunctionReturnType = [];
+    const propertiesFromRdfFunctionStatements = [];
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        propertiesFromRdfFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}.propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, resource: ${variables.resource} });`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
+        initializers.push(`..._super${parentObjectTypeI}`);
+        propertiesFromRdfFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromRdf>>`);
+    });
+    this.fromRdfType.ifJust((rdfType) => {
+        propertiesFromRdfFunctionStatements.push(`if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${this.rdfjsTermExpression(rdfType)})) { return purify.Left(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type\``, predicate: this.rdfjsTermExpression(rdfType) })})); }`);
+    });
+    const propertyFromRdfVariables = {
+        context: variables.context,
+        languageIn: variables.languageIn,
+        resource: variables.resource,
+    };
+    for (const property of this.properties) {
+        const propertyFromRdfStatements = property.fromRdfStatements({
+            variables: propertyFromRdfVariables,
+        });
+        if (propertyFromRdfStatements.length > 0) {
+            propertiesFromRdfFunctionStatements.push(...propertyFromRdfStatements);
+            initializers.push(property.name);
+            propertySignatures.push(`${property.name}: ${property.type.name};`);
+        }
+    }
+    propertiesFromRdfFunctionStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
+    if (propertySignatures.length > 0) {
+        propertiesFromRdfFunctionReturnType.splice(0, 0, `{ ${propertySignatures.join(" ")} }`);
+    }
+    const fromRdfFunctionDeclarations = [];
+    fromRdfFunctionDeclarations.push({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "propertiesFromRdf",
+        parameters: [
+            {
+                name: `{ ignoreRdfType: ${variables.ignoreRdfType}, languageIn: ${variables.languageIn}, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
+                type: `{ [_index: string]: any; ignoreRdfType?: boolean; languageIn?: readonly string[]; resource: ${this.rdfjsResourceType().name}; }`,
+            },
+        ],
+        returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${propertiesFromRdfFunctionReturnType.join(" & ")}>`,
+        statements: propertiesFromRdfFunctionStatements,
+    });
+    if (!this.abstract) {
+        let fromRdfStatements;
+        switch (this.declarationType) {
+            case "class":
+                fromRdfStatements = [
+                    `return ${this.name}.propertiesFromRdf(parameters).map(properties => new ${this.name}(properties));`,
+                ];
+                break;
+            case "interface":
+                fromRdfStatements = [
+                    `return ${this.name}.propertiesFromRdf(parameters);`,
+                ];
+                break;
+        }
+        fromRdfFunctionDeclarations.push({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "fromRdf",
+            parameters: [
+                {
+                    name: "parameters",
+                    type: `Parameters<typeof ${this.name}.propertiesFromRdf>[0]`,
+                },
+            ],
+            returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>`,
+            statements: fromRdfStatements,
+        });
+    }
+    return fromRdfFunctionDeclarations;
+}
+//# sourceMappingURL=fromRdfFunctionDeclarations.js.map

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

@@ -1,5 +1,5 @@
+import { Maybe } from "purify-ts";
 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;
+import type { ObjectType } from "../ObjectType.js";
+export declare function hashFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
 //# sourceMappingURL=hashFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/hashFunctionDeclaration.js

@@ -1,64 +1,20 @@
-import { camelCase } from "change-case";
+import { Maybe } from "purify-ts";
 import { StructureKind } from "ts-morph";
-const hasherVariable = "hasher";
-export const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
+import { hashFunctionOrMethodDeclaration } from "./hashFunctionOrMethodDeclaration.js";
 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");
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
     }
-    const statements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(`${parentObjectType.name}.${parentObjectType.hashFunctionName}(${thisVariable}, ${hasherVariable})`);
+    if (this.extern) {
+        return Maybe.empty();
     }
-    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 {
+    return hashFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((hashFunctionOrMethodDeclaration) => ({
+        ...hashFunctionOrMethodDeclaration,
         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/hashFunctionOrMethodDeclaration.d.ts

@@ -0,0 +1,11 @@
+import { Maybe } from "purify-ts";
+import type { OptionalKind, ParameterDeclarationStructure, TypeParameterDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
+export declare function hashFunctionOrMethodDeclaration(this: ObjectType): Maybe<{
+    parameters: OptionalKind<ParameterDeclarationStructure>[];
+    returnType: string;
+    statements: string[];
+    typeParameters: OptionalKind<TypeParameterDeclarationStructure>[];
+}>;
+//# sourceMappingURL=hashFunctionOrMethodDeclaration.d.ts.map

package/generators/ts/_ObjectType/hashFunctionOrMethodDeclaration.js

@@ -0,0 +1,64 @@
+import { Maybe } from "purify-ts";
+const hasherVariable = "_hasher";
+export const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
+export function hashFunctionOrMethodDeclaration() {
+    if (!this.features.has("hash")) {
+        return Maybe.empty();
+    }
+    const propertyHashStatements = this.properties.flatMap((property) => property.hashStatements({
+        depth: 0,
+        variables: {
+            hasher: hasherVariable,
+            value: `${this.thisVariable}.${property.name}`,
+        },
+    }));
+    if (this.declarationType === "class" &&
+        this.parentObjectTypes.length > 0 &&
+        propertyHashStatements.length === 0) {
+        // If there's a parent class and no hash statements in this class, can skip overriding hash
+        return Maybe.empty();
+    }
+    const parameters = [];
+    if (this.declarationType === "interface") {
+        parameters.push({
+            name: this.thisVariable,
+            type: this.name,
+        });
+    }
+    parameters.push({
+        name: hasherVariable,
+        type: "HasherT",
+    });
+    const statements = [];
+    let hasOverrideKeyword = false;
+    if (this.parentObjectTypes.length > 0) {
+        switch (this.declarationType) {
+            case "class": {
+                statements.push(`super.hash(${hasherVariable});`);
+                hasOverrideKeyword = true;
+                break;
+            }
+            case "interface": {
+                for (const parentObjectType of this.parentObjectTypes) {
+                    statements.push(`${parentObjectType.name}.${parentObjectType.hashFunctionName}(${this.thisVariable}, ${hasherVariable});`);
+                }
+                break;
+            }
+        }
+    }
+    statements.push(...propertyHashStatements);
+    statements.push(`return ${hasherVariable};`);
+    return Maybe.of({
+        hasOverrideKeyword,
+        parameters,
+        returnType: "HasherT",
+        statements,
+        typeParameters: [
+            {
+                name: "HasherT",
+                constraint: hasherTypeConstraint,
+            },
+        ],
+    });
+}
+//# sourceMappingURL=hashFunctionOrMethodDeclaration.js.map

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

@@ -1,12 +1,18 @@
 export * from "./classDeclaration.js";
+export * from "./createFunctionDeclaration.js";
 export * from "./equalsFunctionDeclaration.js";
-export * from "./fromRdfFunctionDeclaration.js";
+export * from "./fromJsonFunctionDeclarations.js";
+export * from "./fromRdfFunctionDeclarations.js";
 export * from "./hashFunctionDeclaration.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";
+export * from "./jsonSchemaFunctionDeclaration.js";
+export * from "./jsonUiSchemaFunctionDeclaration.js";
+export * from "./jsonZodSchemaFunctionDeclaration.js";
 export * from "./Property.js";
 export * from "./ShaclProperty.js";
-export * from "./sparqlGraphPatternsClassDeclaration.js";
+export * from "./sparqlFunctionDeclarations.js";
+export * from "./toJsonFunctionDeclaration.js";
 export * from "./toRdfFunctionDeclaration.js";
 export * from "./TypeDiscriminatorProperty.js";
 //# sourceMappingURL=index.d.ts.map

package/generators/ts/_ObjectType/index.js

@@ -1,12 +1,18 @@
 export * from "./classDeclaration.js";
+export * from "./createFunctionDeclaration.js";
 export * from "./equalsFunctionDeclaration.js";
-export * from "./fromRdfFunctionDeclaration.js";
+export * from "./fromJsonFunctionDeclarations.js";
+export * from "./fromRdfFunctionDeclarations.js";
 export * from "./hashFunctionDeclaration.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";
+export * from "./jsonSchemaFunctionDeclaration.js";
+export * from "./jsonUiSchemaFunctionDeclaration.js";
+export * from "./jsonZodSchemaFunctionDeclaration.js";
 export * from "./Property.js";
 export * from "./ShaclProperty.js";
-export * from "./sparqlGraphPatternsClassDeclaration.js";
+export * from "./sparqlFunctionDeclarations.js";
+export * from "./toJsonFunctionDeclaration.js";
 export * from "./toRdfFunctionDeclaration.js";
 export * from "./TypeDiscriminatorProperty.js";
 //# sourceMappingURL=index.js.map

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

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

package/generators/ts/_ObjectType/interfaceDeclaration.js

@@ -1,12 +1,21 @@
+import { Maybe } from "purify-ts";
 import { StructureKind, } from "ts-morph";
+import { tsComment } from "../tsComment.js";
 export function interfaceDeclaration() {
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
     const properties = this.properties.map((property) => property.interfacePropertySignature);
-    return {
+    return Maybe.of({
         extends: this.parentObjectTypes.map((parentObjectType) => parentObjectType.name),
         isExported: true,
         kind: StructureKind.Interface,
+        leadingTrivia: this.comment.alt(this.label).map(tsComment).extract(),
         name: this.name,
         properties,
-    };
+    });
 }
 //# sourceMappingURL=interfaceDeclaration.js.map

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

package/generators/ts/_ObjectType/jsonSchemaFunctionDeclaration.js

@@ -0,0 +1,19 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+export function jsonSchemaFunctionDeclaration() {
+    if (!this.features.has("jsonSchema")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "jsonSchema",
+        statements: [
+            `return zodToJsonSchema(${this.jsonZodSchemaFunctionName}());`,
+        ],
+    });
+}
+//# sourceMappingURL=jsonSchemaFunctionDeclaration.js.map

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