@shaclmate/compiler 4.0.6 → 4.0.7

package/dist/generators/ts/ObjectType.js

@@ -16,17 +16,26 @@ import { ObjectType_createFunctionDeclaration } from "./_ObjectType/ObjectType_c
 import { ObjectType_equalsFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_equalsFunctionOrMethodDeclaration.js";
 import { ObjectType_filterFunctionDeclaration } from "./_ObjectType/ObjectType_filterFunctionDeclaration.js";
 import { ObjectType_filterTypeDeclaration } from "./_ObjectType/ObjectType_filterTypeDeclaration.js";
+import { ObjectType_fromJsonFunctionDeclarations } from "./_ObjectType/ObjectType_fromJsonFunctionDeclarations.js";
+import { ObjectType_fromRdfFunctionDeclaration } from "./_ObjectType/ObjectType_fromRdfFunctionDeclaration.js";
 import { ObjectType_fromRdfTypeVariableStatement } from "./_ObjectType/ObjectType_fromRdfTypeVariableStatement.js";
 import { ObjectType_graphqlTypeVariableStatement } from "./_ObjectType/ObjectType_graphqlTypeVariableStatement.js";
 import { ObjectType_hashFunctionOrMethodDeclarations } from "./_ObjectType/ObjectType_hashFunctionOrMethodDeclarations.js";
 import { ObjectType_interfaceDeclaration } from "./_ObjectType/ObjectType_interfaceDeclaration.js";
 import { ObjectType_isTypeFunctionDeclaration } from "./_ObjectType/ObjectType_isTypeFunctionDeclaration.js";
-import { ObjectType_jsonFunctionDeclarations } from "./_ObjectType/ObjectType_jsonFunctionDeclarations.js";
+import { ObjectType_jsonSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.js";
 import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
+import { ObjectType_jsonUiSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.js";
+import { ObjectType_jsonZodSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
-import { ObjectType_rdfFunctionDeclarations } from "./_ObjectType/ObjectType_rdfFunctionDeclarations.js";
+import { ObjectType_propertiesFromRdfFunctionDeclaration } from "./_ObjectType/ObjectType_propertiesFromRdfFunctionDeclaration.js";
 import { ObjectType_schemaVariableStatement } from "./_ObjectType/ObjectType_schemaVariableStatement.js";
-import { ObjectType_sparqlFunctionDeclarations } from "./_ObjectType/ObjectType_sparqlFunctionDeclarations.js";
+import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
+import { ObjectType_sparqlConstructTriplesFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructTriplesFunctionDeclaration.js";
+import { ObjectType_sparqlWherePatternsFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlWherePatternsFunctionDeclarations.js";
+import { ObjectType_toJsonFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_toJsonFunctionOrMethodDeclaration.js";
+import { ObjectType_toRdfFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_toRdfFunctionOrMethodDeclaration.js";
 import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
 import { TypeDiscriminantProperty as _TypeDiscriminantProperty } from "./_ObjectType/TypeDiscriminantProperty.js";
 import { AbstractDeclaredType } from "./AbstractDeclaredType.js";
@@ -108,7 +117,11 @@ export class ObjectType extends AbstractDeclaredType {
                     break;
                 }
             }
-            staticModuleDeclarations.push(ObjectType_filterFunctionDeclaration.bind(this)(), ObjectType_filterTypeDeclaration.bind(this)(), ...ObjectType_fromRdfTypeVariableStatement.bind(this)().toList(), ...ObjectType_graphqlTypeVariableStatement.bind(this)().toList(), ...identifierTypeDeclarations.bind(this)(), ...ObjectType_jsonFunctionDeclarations.bind(this)(), ...ObjectType_jsonTypeAliasDeclaration.bind(this)().toList(), ObjectType_isTypeFunctionDeclaration.bind(this)(), ...ObjectType_rdfFunctionDeclarations.bind(this)(), ObjectType_schemaVariableStatement.bind(this)(), ...ObjectType_sparqlFunctionDeclarations.bind(this)());
+            staticModuleDeclarations.push(...ObjectType_graphqlTypeVariableStatement.bind(this)().toList(), ...identifierTypeDeclarations.bind(this)(), ...ObjectType_jsonTypeAliasDeclaration.bind(this)().toList(), ObjectType_filterFunctionDeclaration.bind(this)(), ObjectType_filterTypeDeclaration.bind(this)(), ...ObjectType_fromJsonFunctionDeclarations.bind(this)(), ...ObjectType_fromRdfFunctionDeclaration.bind(this)().toList(), ...ObjectType_fromRdfTypeVariableStatement.bind(this)().toList(), ObjectType_isTypeFunctionDeclaration.bind(this)(), ...ObjectType_jsonSchemaFunctionDeclaration.bind(this)().toList(), ...ObjectType_jsonUiSchemaFunctionDeclaration.bind(this)().toList(), ...ObjectType_jsonZodSchemaFunctionDeclaration.bind(this)().toList(), ...ObjectType_propertiesFromRdfFunctionDeclaration.bind(this)().toList(), ObjectType_schemaVariableStatement.bind(this)(), ...ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...(this.declarationType === "interface"
+                ? ObjectType_toJsonFunctionOrMethodDeclaration.bind(this)().toList()
+                : []), ...(this.declarationType === "interface"
+                ? ObjectType_toRdfFunctionOrMethodDeclaration.bind(this)().toList()
+                : []));
             if (staticModuleDeclarations.length > 0) {
                 declarations.push(code `\
 export namespace ${def(this.staticModuleName)} {

package/dist/generators/ts/ObjectUnionType.js

@@ -9,19 +9,25 @@ import { Maybe, NonEmptyList } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
 import { MemberType } from "./_ObjectUnionType/MemberType.js";
 import { ObjectUnionType_equalsFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_equalsFunctionDeclaration.js";
 import { ObjectUnionType_filterFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_filterFunctionDeclaration.js";
 import { ObjectUnionType_filterTypeDeclaration } from "./_ObjectUnionType/ObjectUnionType_filterTypeDeclaration.js";
+import { ObjectUnionType_fromJsonFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_fromJsonFunctionDeclaration.js";
+import { ObjectUnionType_fromRdfFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_fromRdfFunctionDeclarations.js";
 import { ObjectUnionType_graphqlTypeVariableStatement } from "./_ObjectUnionType/ObjectUnionType_graphqlTypeVariableStatement.js";
 import { ObjectUnionType_hashFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_hashFunctionDeclaration.js";
 import { ObjectUnionType_identifierTypeDeclarations } from "./_ObjectUnionType/ObjectUnionType_identifierTypeDeclarations.js";
 import { ObjectUnionType_isTypeFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_isTypeFunctionDeclaration.js";
-import { jsonFunctionDeclarations } from "./_ObjectUnionType/ObjectUnionType_jsonFunctionDeclarations.js";
 import { ObjectUnionType_jsonTypeAliasDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonTypeAliasDeclaration.js";
-import { rdfFunctionDeclarations } from "./_ObjectUnionType/ObjectUnionType_rdfFunctionDeclarations.js";
+import { ObjectUnionType_jsonZodSchemaFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.js";
 import { ObjectUnionType_schemaVariableStatement } from "./_ObjectUnionType/ObjectUnionType_schemaVariableStatement.js";
-import { ObjectUnionType_sparqlFunctionDeclarations } from "./_ObjectUnionType/ObjectUnionType_sparqlFunctionDeclarations.js";
+import { ObjectUnionType_sparqlConstructTriplesFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.js";
+import { ObjectUnionType_sparqlWherePatternsFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_sparqlWherePatternsFunctionDeclaration.js";
+import { ObjectUnionType_toJsonFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_toJsonFunctionDeclaration.js";
+import { ObjectUnionType_toRdfFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_toRdfFunctionDeclarations.js";
 import { ObjectUnionType_typeAliasDeclaration } from "./_ObjectUnionType/ObjectUnionType_typeAliasDeclaration.js";
 import { AbstractDeclaredType } from "./AbstractDeclaredType.js";
 import { imports } from "./imports.js";
@@ -68,18 +74,24 @@ export class ObjectUnionType extends AbstractDeclaredType {
             ObjectUnionType_typeAliasDeclaration.bind(this)(),
         ];
         const staticModuleDeclarations = [
+            ...ObjectUnionType_graphqlTypeVariableStatement.bind(this)().toList(),
+            ...ObjectUnionType_identifierTypeDeclarations.bind(this)(),
+            ...ObjectUnionType_jsonTypeAliasDeclaration.bind(this)().toList(),
             ...ObjectUnionType_equalsFunctionDeclaration.bind(this)().toList(),
             ObjectUnionType_filterFunctionDeclaration.bind(this)(),
             ObjectUnionType_filterTypeDeclaration.bind(this)(),
-            ...ObjectUnionType_graphqlTypeVariableStatement.bind(this)().toList(),
             ...ObjectUnionType_hashFunctionDeclaration.bind(this)().toList(),
-            ...ObjectUnionType_identifierTypeDeclarations.bind(this)(),
-            ...jsonFunctionDeclarations.bind(this)(),
-            ...ObjectUnionType_jsonTypeAliasDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_fromJsonFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_fromRdfFunctionDeclaration.bind(this)().toList(),
             ...ObjectUnionType_isTypeFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_jsonZodSchemaFunctionDeclaration.bind(this)().toList(),
             ObjectUnionType_schemaVariableStatement.bind(this)(),
-            ...rdfFunctionDeclarations.bind(this)(),
-            ...ObjectUnionType_sparqlFunctionDeclarations.bind(this)(),
+            ...ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(),
+            ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_sparqlWherePatternsFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_toJsonFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_toRdfFunctionDeclaration.bind(this)().toList(),
         ];
         if (staticModuleDeclarations.length > 0) {
             declarations.push(code `\

package/dist/generators/ts/ZodGenerator.d.ts

@@ -0,0 +1,7 @@
+import * as ast from "../../ast/index.js";
+import type { Generator } from "../Generator.js";
+export declare class ZodGenerator implements Generator {
+    private readonly typeFactory;
+    generate(ast_: ast.Ast): string;
+}
+//# sourceMappingURL=ZodGenerator.d.ts.map

package/dist/generators/ts/ZodGenerator.js

@@ -0,0 +1,37 @@
+import * as ast from "../../ast/index.js";
+import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
+import { ObjectType_jsonZodSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.js";
+import { ObjectUnionType_jsonTypeAliasDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonTypeAliasDeclaration.js";
+import { ObjectUnionType_jsonZodSchemaFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.js";
+import { snippets } from "./snippets.js";
+import { TypeFactory } from "./TypeFactory.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class ZodGenerator {
+    typeFactory = new TypeFactory();
+    generate(ast_) {
+        const declarations = [];
+        for (const objectType of ast.ObjectType.toposort(ast_.objectTypes).map((astObjectType) => this.typeFactory.createObjectType(astObjectType))) {
+            declarations.push(code `\
+export namespace ${objectType.staticModuleName} {
+${joinCode([
+                ...ObjectType_jsonTypeAliasDeclaration.bind(objectType)().toList(),
+                ...ObjectType_jsonZodSchemaFunctionDeclaration.bind(objectType)().toList(),
+            ], { on: "\n\n" })}
+}`);
+        }
+        for (const objectUnionType of ast_.objectUnionTypes.map((astObjectUnionType) => this.typeFactory.createObjectUnionType(astObjectUnionType))) {
+            declarations.push(code `\
+export namespace ${objectUnionType.staticModuleName} {
+${joinCode([
+                ...ObjectUnionType_jsonTypeAliasDeclaration.bind(objectUnionType)().toList(),
+                ...ObjectUnionType_jsonZodSchemaFunctionDeclaration.bind(objectUnionType)().toList(),
+            ], { on: "\n\n" })}
+}`);
+        }
+        declarations.splice(0, 0, joinCode(Object.values(snippets)
+            .sort((left, right) => left.usageSiteName.localeCompare(right.usageSiteName))
+            .map((snippet) => code `${snippet.ifUsed}`), { on: "\n\n" }));
+        return joinCode(declarations, { on: "\n\n" }).toString({});
+    }
+}
+//# sourceMappingURL=ZodGenerator.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromJsonFunctionDeclarations.d.ts

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

package/dist/generators/ts/_ObjectType/{ObjectType_jsonFunctionDeclarations.js → ObjectType_fromJsonFunctionDeclarations.js}

@@ -1,10 +1,14 @@
-import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-import { ObjectType_toJsonFunctionOrMethodDeclaration } from "./ObjectType_toJsonFunctionOrMethodDeclaration.js";
-function ObjectType_fromJsonFunctionDeclarations() {
+const variables = {
+    jsonObject: code `${syntheticNamePrefix}jsonObject`,
+};
+export function ObjectType_fromJsonFunctionDeclarations() {
+    if (!this.features.has("json")) {
+        return [];
+    }
     const initializers = [];
     const propertiesFromJsonReturnType = [];
     const propertiesFromJsonStatements = [];
@@ -59,64 +63,4 @@ export function ${syntheticNamePrefix}fromJson(json: unknown): ${imports.Either}
 }`);
     return functionDeclarations;
 }
-function ObjectType_jsonSchemaFunctionDeclaration() {
-    return code `\
-export function ${syntheticNamePrefix}jsonSchema() {
-  return ${imports.z}.toJSONSchema(${syntheticNamePrefix}jsonZodSchema());
-}`;
-}
-function ObjectType_jsonUiSchemaFunctionDeclaration() {
-    const variables = { scopePrefix: code `scopePrefix` };
-    const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix })`)
-        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
-    return code `\
-export function ${syntheticNamePrefix}jsonUiSchema(parameters?: { scopePrefix?: string }): any {
-  const scopePrefix = parameters?.scopePrefix ?? "#";
-  return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.name)}", type: "Group" };
-}`;
-}
-function ObjectType_jsonZodSchemaFunctionDeclaration() {
-    const mergeZodObjectSchemas = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        mergeZodObjectSchemas.push(parentObjectType.jsonZodSchema({ context: "type" }));
-    }
-    if (this.properties.length > 0) {
-        mergeZodObjectSchemas.push(code `${imports.z}.object({ ${joinCode(this.properties
-            .flatMap((property) => property.jsonZodSchema.toList())
-            .map(({ key, schema }) => code `"${key}": ${schema}`), { on: "," })} })`);
-    }
-    return code `\
-export function ${syntheticNamePrefix}jsonZodSchema() {
-  return ${mergeZodObjectSchemas.length > 0
-        ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
-            if (merged === null) {
-                return zodObjectSchema;
-            }
-            return code `${merged}.merge(${zodObjectSchema})`;
-        }, null)
-        : `${imports.z}.object()`} satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
-}`;
-}
-function ObjectType_toJsonFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    return ObjectType_toJsonFunctionOrMethodDeclaration.bind(this)();
-}
-export function ObjectType_jsonFunctionDeclarations() {
-    if (!this.features.has("json")) {
-        return [];
-    }
-    return [
-        ...ObjectType_fromJsonFunctionDeclarations.bind(this)(),
-        ObjectType_jsonSchemaFunctionDeclaration.bind(this)(),
-        ObjectType_jsonUiSchemaFunctionDeclaration.bind(this)(),
-        ...ObjectType_toJsonFunctionDeclaration.bind(this)().toList(),
-        ObjectType_jsonZodSchemaFunctionDeclaration.bind(this)(),
-    ];
-}
-const variables = {
-    jsonObject: code `${syntheticNamePrefix}jsonObject`,
-};
-//# sourceMappingURL=ObjectType_jsonFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectType_fromJsonFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfFunctionDeclaration.js

@@ -0,0 +1,27 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_fromRdfFunctionDeclaration() {
+    if (!this.features.has("rdf")) {
+        return Maybe.empty();
+    }
+    if (this.abstract) {
+        return Maybe.empty();
+    }
+    const statements = [
+        code `let { context, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
+        code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
+    ];
+    let propertiesFromRdfExpression = code `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ context, ignoreRdfType, objectSet, preferredLanguages, resource })`;
+    if (this.declarationType === "class") {
+        propertiesFromRdfExpression = code `${propertiesFromRdfExpression}.map(properties => new ${this.name}(properties))`;
+    }
+    statements.push(code `return ${propertiesFromRdfExpression};`);
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
+${joinCode(statements)}
+}`);
+}
+//# sourceMappingURL=ObjectType_fromRdfFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.js

@@ -0,0 +1,14 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonSchemaFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}jsonSchema() {
+  return ${imports.z}.toJSONSchema(${syntheticNamePrefix}jsonZodSchema());
+}`);
+}
+//# sourceMappingURL=ObjectType_jsonSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.js

@@ -0,0 +1,18 @@
+import { Maybe } from "purify-ts";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonUiSchemaFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    const variables = { scopePrefix: code `scopePrefix` };
+    const elements = this.parentObjectTypes
+        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix })`)
+        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}jsonUiSchema(parameters?: { scopePrefix?: string }): any {
+  const scopePrefix = parameters?.scopePrefix ?? "#";
+  return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.name)}", type: "Group" };
+}`);
+}
+//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.js

@@ -0,0 +1,30 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonZodSchemaFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    const mergeZodObjectSchemas = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        mergeZodObjectSchemas.push(parentObjectType.jsonZodSchema({ context: "type" }));
+    }
+    if (this.properties.length > 0) {
+        mergeZodObjectSchemas.push(code `${imports.z}.object({ ${joinCode(this.properties
+            .flatMap((property) => property.jsonZodSchema.toList())
+            .map(({ key, schema }) => code `"${key}": ${schema}`), { on: "," })} })`);
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}jsonZodSchema() {
+  return ${mergeZodObjectSchemas.length > 0
+        ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
+            if (merged === null) {
+                return zodObjectSchema;
+            }
+            return code `${merged}.merge(${zodObjectSchema})`;
+        }, null)
+        : `${imports.z}.object()`} satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
+}`);
+}
+//# sourceMappingURL=ObjectType_jsonZodSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_propertiesFromRdfFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectType/{ObjectType_rdfFunctionDeclarations.js → ObjectType_propertiesFromRdfFunctionDeclaration.js}

@@ -5,26 +5,10 @@ import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-import { ObjectType_toRdfFunctionOrMethodDeclaration } from "./ObjectType_toRdfFunctionOrMethodDeclaration.js";
-function ObjectType_fromRdfFunctionDeclaration() {
-    if (this.abstract) {
+export function ObjectType_propertiesFromRdfFunctionDeclaration() {
+    if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
-    const statements = [
-        code `let { context, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
-        code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
-    ];
-    let propertiesFromRdfExpression = code `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ context, ignoreRdfType, objectSet, preferredLanguages, resource })`;
-    if (this.declarationType === "class") {
-        propertiesFromRdfExpression = code `${propertiesFromRdfExpression}.map(properties => new ${this.name}(properties))`;
-    }
-    statements.push(code `return ${propertiesFromRdfExpression};`);
-    return Maybe.of(code `\
-export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
-${joinCode(statements)}
-}`);
-}
-function ObjectType_propertiesFromRdfFunctionDeclaration() {
     const chains = [];
     const initializers = [];
     const propertySignatures = [];
@@ -108,25 +92,9 @@ function ObjectType_propertiesFromRdfFunctionDeclaration() {
     if (propertySignatures.length > 0) {
         returnType.splice(0, 0, code `{ ${joinCode(propertySignatures, { on: " " })} }`);
     }
-    return code `\
+    return Maybe.of(code `\
 export function ${syntheticNamePrefix}propertiesFromRdf(${syntheticNamePrefix}parameters: ${snippets.PropertiesFromRdfParameters}): ${imports.Either}<Error, ${joinCode(returnType, { on: " & " })}> {
 ${joinCode(statements)}
-}`;
-}
-export function ObjectType_rdfFunctionDeclarations() {
-    if (!this.features.has("rdf")) {
-        return [];
-    }
-    return [
-        ...ObjectType_fromRdfFunctionDeclaration.bind(this)().toList(),
-        ObjectType_propertiesFromRdfFunctionDeclaration.bind(this)(),
-        ...ObjectType_toRdfFunctionDeclaration.bind(this)().toList(),
-    ];
-}
-function ObjectType_toRdfFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    return ObjectType_toRdfFunctionOrMethodDeclaration.bind(this)();
+}`);
 }
-//# sourceMappingURL=ObjectType_rdfFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectType_propertiesFromRdfFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts

@@ -1,7 +1,10 @@
+import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../../enums/TsFeature.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function ObjectType_sparqlConstructQueryFunctionDeclaration(this: {
+    readonly features: ReadonlySet<TsFeature>;
     readonly filterType: Code;
     readonly name: string;
     readonly staticModuleName: string;
-}): Code;
+}): Maybe<Code>;
 //# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js

@@ -1,10 +1,14 @@
 import { camelCase } from "change-case";
+import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function ObjectType_sparqlConstructQueryFunctionDeclaration() {
-    return code `\
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
 export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages, prefixes, subject, ...queryParameters }: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject: ${imports.NamedNode} | ${imports.Variable} } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${imports.sparqljs}.ConstructQuery {
   const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.name)}";
 
@@ -33,6 +37,6 @@ export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfTy
       )
     )
   };
-}`;
+}`);
 }
 //# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts

@@ -1,6 +1,9 @@
+import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../../enums/TsFeature.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function ObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
+    readonly features: ReadonlySet<TsFeature>;
     readonly filterType: Code;
     readonly staticModuleName: string;
-}): Code;
+}): Maybe<Code>;
 //# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js

@@ -1,10 +1,14 @@
+import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function ObjectType_sparqlConstructQueryStringFunctionDeclaration() {
-    return code `\
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
 export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters: Parameters<typeof ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery>[0] & ${imports.sparqljs}.GeneratorOptions): string {
   return new ${imports.sparqljs}.Generator(parameters).stringify(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery(parameters));
-}`;
+}`);
 }
 //# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructTriplesFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructTriplesFunctionDeclaration.js

@@ -0,0 +1,57 @@
+import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const variables = {
+    filter: code `parameters.filter`,
+    focusIdentifier: code `parameters.focusIdentifier`,
+    variablePrefix: code `parameters.variablePrefix`,
+};
+export function ObjectType_sparqlConstructTriplesFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    let triplesVariableDeclarationKeyword = "const";
+    const statements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        statements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        triplesVariableDeclarationKeyword = "let";
+    }
+    if (this.fromRdfType.isJust()) {
+        statements.push(code `\
+if (!parameters?.ignoreRdfType) {
+  triples.push(
+    { subject: ${variables.focusIdentifier}, predicate: ${rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
+    { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
+  );
+}`);
+    }
+    for (const property of this.ownProperties) {
+        if (property.recursive) {
+            continue;
+        }
+        property
+            .sparqlConstructTriplesExpression({
+            variables,
+        })
+            .ifJust((propertyTriples) => {
+            statements.push(code `triples = triples.concat(${propertyTriples});`);
+            triplesVariableDeclarationKeyword = "let";
+        });
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlConstructTriples(${statements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean;  variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
+${statements.length > 0
+        ? joinCode([
+            code `${triplesVariableDeclarationKeyword} triples: ${imports.sparqljs}.Triple[] = [];`,
+            ...statements,
+            code `return triples;`,
+        ])
+        : "return [];"}
+}`);
+}
+//# sourceMappingURL=ObjectType_sparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlWherePatternsFunctionDeclarations.d.ts

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