@shaclmate/compiler 4.0.41 → 4.0.43

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

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

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

@@ -0,0 +1,12 @@
+import { invariant } from "ts-invariant";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_fromJsonFunctionExpression() {
+    const variables = {
+        jsonObject: code `${this.configuration.syntheticNamePrefix}json`,
+    };
+    const propertyInitializers = this.properties.flatMap((property) => property.fromJsonInitializer({ variables }).toList());
+    invariant(propertyInitializers.length > 0);
+    return code `\
+((${variables.jsonObject}) => ${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} }).chain(${this.createFunction}))`;
+}
+//# sourceMappingURL=ObjectType_fromJsonFunctionExpression.js.map

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

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

package/dist/generators/ts/_ObjectType/{ObjectType_fromRdfResourceFunctionDeclaration.js → ObjectType_fromRdfResourceFunctionExpression.js}

@@ -1,10 +1,6 @@
-import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_fromRdfResourceFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.fromRdf")) {
-        return Maybe.empty();
-    }
+export function ObjectType_fromRdfResourceFunctionExpression() {
     const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     const optionsVariable = `_${syntheticNamePrefix}options`;
     const variables = {
@@ -15,12 +11,12 @@ export function ObjectType_fromRdfResourceFunctionDeclaration() {
         preferredLanguages: code `${optionsVariable}.preferredLanguages`,
         resource: code `${syntheticNamePrefix}resource`,
     };
-    const propertyFromRdfResourceValuesExpressionVariable = {
+    const propertyFromRdfResourceValuesVariables = {
         context: variables.context,
+        focusResource: variables.resource,
         graph: variables.graph,
         objectSet: variables.objectSet,
         preferredLanguages: variables.preferredLanguages,
-        resource: variables.resource,
     };
     const chains = [];
     this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
@@ -31,7 +27,7 @@ export function ObjectType_fromRdfResourceFunctionDeclaration() {
     });
     const propertyFromRdfResourceValuesInitializers = this.properties.flatMap((property) => property
         .fromRdfResourceValuesInitializer({
-        variables: propertyFromRdfResourceValuesExpressionVariable,
+        variables: propertyFromRdfResourceValuesVariables,
     })
         .toList());
     invariant(Object.keys(propertyFromRdfResourceValuesInitializers).length > 0);
@@ -39,13 +35,9 @@ export function ObjectType_fromRdfResourceFunctionDeclaration() {
         expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyFromRdfResourceValuesInitializers, { on: ", " })} })`,
         variable: "properties",
     });
-    return Maybe.of(code `\
-export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.expression}> = (${variables.resource}, ${optionsVariable}) => {
-  return ${chains
+    return code `\
+((${variables.resource}, ${optionsVariable}) => ${chains
         .reverse()
-        .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(create(properties))`)};
+        .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(${this.createFunction}(properties))`)})`;
 }
-
-export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`);
-}
-//# sourceMappingURL=ObjectType_fromRdfResourceFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_fromRdfResourceFunctionExpression.js.map

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

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

package/dist/generators/ts/_ObjectType/{ObjectType_graphqlTypeVariableStatement.js → ObjectType_graphqlTypeExpression.js}

@@ -1,14 +1,7 @@
-import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_graphqlTypeVariableStatement() {
-    if (!this.configuration.features.has("GraphQL")) {
-        return Maybe.empty();
-    }
-    if (this.synthetic) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export const GraphQL = new ${this.reusables.imports.GraphQLObjectType}<${this.expression}, { objectSet: ${this.configuration.syntheticNamePrefix}ObjectSet }>(${{
+export function ObjectType_graphqlTypeExpression() {
+    return code `\
+new ${this.reusables.imports.GraphQLObjectType}<${this.expression}, { objectSet: ${this.configuration.syntheticNamePrefix}ObjectSet }>(${{
         description: this.comment.extract(),
         fields: code `() => (${this.properties.reduce((fields, property) => {
             property.graphqlField.ifJust((field) => {
@@ -27,7 +20,7 @@ export const GraphQL = new ${this.reusables.imports.GraphQLObjectType}<${this.ex
             });
             return fields;
         }, {})})`,
-        name: this.alias.unsafeCoerce(),
-    }});`);
+        name: this.name.orDefault(this.shapeIdentifier.value),
+    }})`;
 }
-//# sourceMappingURL=ObjectType_graphqlTypeVariableStatement.js.map
+//# sourceMappingURL=ObjectType_graphqlTypeExpression.js.map

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

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

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

@@ -0,0 +1,30 @@
+import { codeEquals } from "../codeEquals.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+const hasherVariable = code `hasher`;
+export function ObjectType_hashFunctionExpression() {
+    let statements = [];
+    const replacePropertyDeclarations = {};
+    for (const property of this.properties) {
+        const propertyHashStatements = property.hashStatements({
+            variables: {
+                hasher: hasherVariable,
+                value: code `${this.thisVariable}.${property.name}`,
+            },
+        });
+        if (propertyHashStatements.length === 0) {
+            continue;
+        }
+        statements = statements.concat(propertyHashStatements);
+        if (!codeEquals(property.hashFunctionParameter, property.declaration)) {
+            replacePropertyDeclarations[property.name] =
+                code `${property.hashFunctionParameter}`;
+        }
+    }
+    statements.push(code `return ${hasherVariable};`);
+    let thisTypeExpression = this.expression;
+    if (Object.keys(replacePropertyDeclarations).length > 0) {
+        thisTypeExpression = code `Omit<${thisTypeExpression}, ${joinCode(Object.keys(replacePropertyDeclarations).map((propertyName) => code `${literalOf(propertyName)}`), { on: " | " })}> & { ${joinCode(Object.values(replacePropertyDeclarations))} }`;
+    }
+    return code `<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${thisTypeExpression}): HasherT => { ${joinCode(statements)} }`;
+}
+//# sourceMappingURL=ObjectType_hashFunctionExpression.js.map

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

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

package/dist/generators/ts/_ObjectType/{identifierTypeDeclarations.js → ObjectType_identifierTypeDeclarations.js}

@@ -1,8 +1,5 @@
 import { code } from "../ts-poet-wrapper.js";
-export function identifierTypeDeclarations() {
-    if (!this.configuration.features.has("Object.type")) {
-        return [];
-    }
+export function ObjectType_identifierTypeDeclarations() {
     // Bespoke identifier type and associated functions
     return [
         code `export type Identifier = ${this.identifierType.expression};`,
@@ -13,4 +10,4 @@ export namespace Identifier {
 }`,
     ];
 }
-//# sourceMappingURL=identifierTypeDeclarations.js.map
+//# sourceMappingURL=ObjectType_identifierTypeDeclarations.js.map

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

@@ -7,13 +7,13 @@ export function ObjectType_isTypeFunctionDeclaration() {
     if (this.synthetic) {
         return Maybe.empty();
     }
-    const alias = this.alias.extract();
+    const name = this.name.extract();
     const discriminantProperty = this.discriminantProperty.extract();
-    if (!alias || !discriminantProperty) {
+    if (!name || !discriminantProperty) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export function is${alias}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${alias} {
+export function is${name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${name} {
   return object.${discriminantProperty.name} === ${literalOf(discriminantProperty.value)};
 }`);
 }

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

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

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

@@ -1,14 +1,10 @@
-import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function ObjectType_jsonParseFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.JSON.parse")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
+    return code `\
 export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Json> {
   const jsonSafeParseResult = schema().safeParse(json);
   if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
   return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
-}`);
+}`;
 }
 //# sourceMappingURL=ObjectType_jsonParseFunctionDeclaration.js.map

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

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

package/dist/generators/ts/_ObjectType/{ObjectType_jsonSchemaFunctionDeclaration.js → ObjectType_jsonSchemaExpression.js}

@@ -1,9 +1,5 @@
-import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonSchemaFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.JSON.schema")) {
-        return Maybe.empty();
-    }
+export function ObjectType_jsonSchemaExpression() {
     const properties = this.properties
         .flatMap((property) => property.jsonSchema.toList())
         .map(({ key, schema }) => code `"${key}": ${schema}`);
@@ -17,9 +13,6 @@ export function ObjectType_jsonSchemaFunctionDeclaration() {
         meta["title"] = label;
     });
     // ${this.properties.every((property) => !property.mutable) ? `.readonly()` : ""}
-    return Maybe.of(code `\
-export function schema() {
-  return ${this.reusables.imports.z}.object({${joinCode(properties, { on: "," })}}).meta(${meta}) satisfies ${this.reusables.imports.z}.ZodType<Json>;
-}`);
+    return code `${this.reusables.imports.z}.object({${joinCode(properties, { on: "," })}}).meta(${meta})`;
 }
-//# sourceMappingURL=ObjectType_jsonSchemaFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_jsonSchemaExpression.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonTypeExpression() {
+    return code `{ ${joinCode(this.properties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`;
+}
+//# sourceMappingURL=ObjectType_jsonTypeExpression.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonUiSchemaFunctionExpression() {
+    const variables = { scopePrefix: code `scopePrefix` };
+    const uiSchema = {
+        elements: code `${arrayOf(...this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()))}`,
+        type: "Group",
+    };
+    this.name.ifJust((name) => {
+        uiSchema["label"] = code `${literalOf(name)}`;
+    });
+    return code `\
+((parameters?: { scopePrefix?: string }): any => {
+  const scopePrefix = parameters?.scopePrefix ?? "#";
+  return ${uiSchema};
+})`;
+}
+//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionExpression.js.map

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

@@ -1,6 +1,6 @@
 import type { TsGenerator } from "../TsGenerator.js";
 export declare function ObjectType_objectSetMethodNames(this: {
-    readonly alias: string;
+    readonly name: string;
     readonly configuration: TsGenerator.Configuration;
 }): {
     object: string;

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

@@ -2,10 +2,10 @@ import { camelCase, trainCase } from "change-case";
 import plur from "plur";
 export function ObjectType_objectSetMethodNames() {
     const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    const prefixSingular = camelCase(this.alias, {
+    const prefixSingular = camelCase(this.name, {
         prefixCharacters: syntheticNamePrefix,
     });
-    const thisNameParts = trainCase(this.alias, {
+    const thisNameParts = trainCase(this.name, {
         prefixCharacters: syntheticNamePrefix,
     }).split("-");
     let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`, { prefixCharacters: syntheticNamePrefix });

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

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

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

@@ -0,0 +1,18 @@
+import { invariant } from "ts-invariant";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_schemaExpression() {
+    const schema = {};
+    this.fromRdfType.ifJust((fromRdfType) => {
+        schema["fromRdfType"] = this.rdfjsTermExpression(fromRdfType);
+    });
+    const properties = {};
+    for (const property of this.properties) {
+        property.schema.ifJust((propertySchema) => {
+            properties[property.name] = propertySchema;
+        });
+    }
+    invariant(Object.keys(properties).length > 0);
+    schema["properties"] = properties;
+    return code `${schema} as const`;
+}
+//# sourceMappingURL=ObjectType_schemaExpression.js.map

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

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

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

@@ -0,0 +1,18 @@
+import { invariant } from "ts-invariant";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_schemaTypeExpression() {
+    const schemaType = {};
+    this.fromRdfType.ifJust(() => {
+        schemaType["fromRdfType"] = code `${this.reusables.imports.NamedNode}`;
+    });
+    const properties = {};
+    for (const property of this.properties) {
+        property.schemaType.ifJust((propertySchemaType) => {
+            properties[property.name] = propertySchemaType;
+        });
+    }
+    invariant(Object.keys(properties).length > 0);
+    schemaType["properties"] = properties;
+    return code `${schemaType}`;
+}
+//# sourceMappingURL=ObjectType_schemaTypeExpression.js.map

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

@@ -1,11 +1,10 @@
-import { Maybe } from "purify-ts";
 import type { Reusables } from "../Reusables.js";
 import type { TsGenerator } from "../TsGenerator.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function ObjectType_sparqlConstructQueryFunctionDeclaration(this: {
-    readonly alias: string;
+    readonly name: string;
     readonly configuration: TsGenerator.Configuration;
     readonly filterType: Code;
     readonly reusables: Reusables;
-}): Maybe<Code>;
+}): Code;
 //# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map

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

@@ -1,20 +1,16 @@
 import { camelCase } from "change-case";
-import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function ObjectType_sparqlConstructQueryFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
+    return code `\
 export function sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages, prefixes, subject, ...queryParameters }: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable} } & Omit<${this.reusables.imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${this.reusables.imports.sparqljs}.ConstructQuery {
-  const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.alias)}";
+  const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.name)}";
 
   return {
     ...queryParameters,
     prefixes: prefixes ?? {},
     queryType: "CONSTRUCT",
     template: (queryParameters.template ?? []).concat(
-      ${this.alias}.focusSparqlConstructTriples({
+      ${this.name}.focusSparqlConstructTriples({
         filter,
         focusIdentifier: subject,
         ignoreRdfType: !!ignoreRdfType,
@@ -24,7 +20,7 @@ export function sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages
     type: "query",
     where: (queryParameters.where ?? []).concat(
       ${this.reusables.snippets.normalizeSparqlWherePatterns}(
-        ${this.alias}.focusSparqlWherePatterns({
+        ${this.name}.focusSparqlWherePatterns({
           filter,
           focusIdentifier: subject,
           ignoreRdfType: !!ignoreRdfType,
@@ -34,6 +30,6 @@ export function sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages
       )
     )
   };
-}`);
+}`;
 }
 //# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.js.map

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

@@ -1,11 +1,10 @@
-import { Maybe } from "purify-ts";
 import type { Reusables } from "../Reusables.js";
 import type { TsGenerator } from "../TsGenerator.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function ObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
-    readonly alias: string;
+    readonly name: string;
     readonly configuration: TsGenerator.Configuration;
     readonly filterType: Code;
     readonly reusables: Reusables;
-}): Maybe<Code>;
+}): Code;
 //# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_toJsonFunctionExpression() {
+    return code `\
+((${this.thisVariable}) => JSON.parse(JSON.stringify({ ${joinCode(this.properties.flatMap((property) => property
+        .toJsonInitializer({
+        variables: {
+            value: property.accessExpression({
+                variables: { object: this.thisVariable },
+            }),
+        },
+    })
+        .toList()), { on: "," })} } satisfies ${this.jsonType().expression})))`;
+}
+//# sourceMappingURL=ObjectType_toJsonFunctionExpression.js.map

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

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

package/dist/generators/ts/_ObjectType/{ObjectType_toRdfResourceFunctionDeclaration.js → ObjectType_toRdfResourceFunctionExpression.js}

@@ -1,10 +1,6 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toRdfResourceFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.toRdf")) {
-        return Maybe.empty();
-    }
+export function ObjectType_toRdfResourceFunctionExpression() {
     const statements = [];
     if (this.toRdfTypes.length > 0) {
         statements.push(code `if (!${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${toRdfType.value}"), ${variables.graph});`), { on: " " })} }`);
@@ -22,12 +18,10 @@ export function ObjectType_toRdfResourceFunctionDeclaration() {
         }));
     }
     statements.push(code `return ${variables.resource};`);
-    return Maybe.of(code `\
-export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.expression}> = (parameters) => {
-${joinCode(statements)}
-}
-
-export const toRdfResource = ${this.reusables.snippets.wrap_ToRdfResourceFunction}(_toRdfResource);`);
+    return code `\
+((parameters) => {
+  ${joinCode(statements)}
+})`;
 }
 const variables = {
     ignoreRdfType: code `parameters.ignoreRdfType`,
@@ -36,4 +30,4 @@ const variables = {
     resource: code `parameters.resource`,
     resourceSet: code `parameters.resourceSet`,
 };
-//# sourceMappingURL=ObjectType_toRdfResourceFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_toRdfResourceFunctionExpression.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_toStringFunctionExpression() {
+    return this.name
+        .map((name) => code `((${this.thisVariable}) => \`${name}(\${JSON.stringify(toStringRecord(${this.thisVariable}))})\`)`)
+        .orDefault(code `((${this.thisVariable}) => JSON.stringify(${this.toStringRecordExpression({ variables: { value: this.thisVariable } })}))`);
+}
+//# sourceMappingURL=ObjectType_toStringFunctionExpression.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_toStringRecordFunctionExpression() {
+    return code `((${this.thisVariable}) => ${this.toStringRecordExpression({ variables: { value: this.thisVariable } })})`;
+}
+//# sourceMappingURL=ObjectType_toStringRecordFunctionExpression.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_valueSparqlConstructTriplesFunctionDeclaration.d.ts → ObjectType_valueSparqlConstructTriplesFunctionExpression.d.ts}

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

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

@@ -0,0 +1,8 @@
+import { code } from "../ts-poet-wrapper.js";
+import { ObjectType_focusSparqlConstructTriplesFunctionExpression } from "./ObjectType_focusSparqlConstructTriplesFunctionExpression.js";
+export function ObjectType_valueSparqlConstructTriplesFunctionExpression() {
+    return code `\
+(({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
+  ${this.name.map((name) => code `${name}.focusSparqlConstructTriples`).orDefaultLazy(() => ObjectType_focusSparqlConstructTriplesFunctionExpression.call(this))}({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix }))`;
+}
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionExpression.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_valueSparqlWherePatternsFunctionDeclaration.d.ts → ObjectType_valueSparqlWherePatternsFunctionExpression.d.ts}

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

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

@@ -0,0 +1,10 @@
+import { code } from "../ts-poet-wrapper.js";
+import { ObjectType_focusSparqlWherePatternsFunctionExpression } from "./ObjectType_focusSparqlWherePatternsFunctionExpression.js";
+export function ObjectType_valueSparqlWherePatternsFunctionExpression() {
+    return code `\
+(({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
+  (propertyPatterns as readonly ${this.reusables.snippets.SparqlPattern}[]).concat(
+    ${this.name.map((name) => code `${name}.focusSparqlWherePatterns`).orDefaultLazy(() => ObjectType_focusSparqlWherePatternsFunctionExpression.call(this))}({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
+))`;
+}
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionExpression.js.map

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

@@ -21,16 +21,23 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
         path: PropertyPath;
         recursive: boolean;
     } & ConstructorParameters<typeof AbstractProperty<TypeT>>[0]);
-    get constructorParameter(): Maybe<Code>;
+    get constructorParameter(): Maybe<{
+        hasQuestionToken: boolean;
+        signature: Code;
+    }>;
     get declaration(): Code;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
     get graphqlField(): AbstractProperty<TypeT>["graphqlField"];
+    get hashFunctionParameter(): Code;
     get jsonSchema(): AbstractProperty<TypeT>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): Maybe<Code>;
+    get schemaType(): Maybe<Code>;
+    private get schemaVariable();
+    private get typeSchemaVariable();
     constructorInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["constructorInitializer"]>[0]): Maybe<Code>;
     fromJsonInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonInitializer"]>[0]): Maybe<Code>;
     fromRdfResourceValuesInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;