@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/generators/ts/_ObjectType/{ObjectType_filterTypeDeclaration.js → ObjectType_filterTypeExpression.js}

@@ -1,9 +1,5 @@
-import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_filterTypeDeclaration() {
-    if (!this.configuration.features.has("Object.filter")) {
-        return Maybe.empty();
-    }
+export function ObjectType_filterTypeExpression() {
     const members = [];
     if (this.properties.length > 0) {
         const filterProperties = {};
@@ -16,10 +12,9 @@ export function ObjectType_filterTypeDeclaration() {
             members.push(code `{ ${joinCode(Object.entries(filterProperties).map(([name, type]) => code `readonly ${name}?: ${type}`), { on: ";" })} }`);
         }
     }
-    for (const parentObjectType of this.parentObjectTypes) {
-        members.push(code `${parentObjectType.alias.unsafeCoerce()}.Filter`);
+    if (members.length > 0) {
+        return joinCode(members, { on: " & " });
     }
-    return Maybe.of(code `\
-export type Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
+    return code `object`;
 }
-//# sourceMappingURL=ObjectType_filterTypeDeclaration.js.map
+//# sourceMappingURL=ObjectType_filterTypeExpression.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlConstructTriplesFunctionDeclaration.d.ts → ObjectType_focusSparqlConstructTriplesFunctionExpression.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_focusSparqlConstructTriplesFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionDeclaration.d.ts.map
+export declare function ObjectType_focusSparqlConstructTriplesFunctionExpression(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionExpression.d.ts.map

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js → ObjectType_focusSparqlConstructTriplesFunctionExpression.js}

@@ -1,23 +1,15 @@
 import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
 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_focusSparqlConstructTriplesFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return Maybe.empty();
-    }
+export function ObjectType_focusSparqlConstructTriplesFunctionExpression() {
     const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
     const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `triples = triples.concat(${parentObjectType.alias.unsafeCoerce()}.focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
-        triplesVariableDeclarationKeyword = "let";
-    }
     if (this.fromRdfType.isJust()) {
         statements.push(code `\
 if (!parameters?.ignoreRdfType) {
@@ -40,8 +32,8 @@ if (!parameters?.ignoreRdfType) {
             triplesVariableDeclarationKeyword = "let";
         });
     }
-    return Maybe.of(code `\
-export const focusSparqlConstructTriples: ${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
+    return code `\
+((${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
             code `${triplesVariableDeclarationKeyword} triples: ${this.reusables.imports.sparqljs}.Triple[] = [];`,
@@ -49,6 +41,6 @@ ${statements.length > 0
             code `return triples;`,
         ])
         : "return [];"}
-};`);
+})`;
 }
-//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionExpression.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlWherePatternsFunctionDeclaration.d.ts → ObjectType_focusSparqlWherePatternsFunctionExpression.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_focusSparqlWherePatternsFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionDeclaration.d.ts.map
+export declare function ObjectType_focusSparqlWherePatternsFunctionExpression(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionExpression.d.ts.map

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlWherePatternsFunctionDeclaration.js → ObjectType_focusSparqlWherePatternsFunctionExpression.js}

@@ -1,5 +1,4 @@
 import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const variables = {
     filter: code `parameters.filter`,
@@ -7,38 +6,16 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function ObjectType_focusSparqlWherePatternsFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return Maybe.empty();
-    }
+export function ObjectType_focusSparqlWherePatternsFunctionExpression() {
     const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
     const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let patternsVariableDeclarationKeyword = "const";
     const statements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `\
-patterns = patterns.concat(${parentObjectType.alias.unsafeCoerce()}.focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
-        patternsVariableDeclarationKeyword = "let";
-    }
-    if (this.fromRdfType.isJust()) {
-        const fromRdfTypeVariables = this.fromRdfTypeVariable
-            .toList()
-            .concat(this.descendantFromRdfTypeVariables);
+    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
         statements.push(code `const rdfTypeVariable = ${rdfTypeVariable};`, code `\
 if (!parameters?.ignoreRdfType) {
   patterns.push(
-    ${fromRdfTypeVariables.length > 1
-            ? code `\
-    {
-      type: "values" as const,
-      values: [${joinCode(fromRdfTypeVariables, { on: "," })}].map((identifier) => {
-        const valuePatternRow: ${this.reusables.imports.sparqljs}.ValuePatternRow = {};
-        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${this.reusables.imports.NamedNode};
-        return valuePatternRow;
-      }),
-    },
-    ${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
-            : code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
+    ${code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariable}, subject: ${variables.focusIdentifier} }),`}
     {
       triples: [
         {
@@ -70,7 +47,7 @@ if (!parameters?.ignoreRdfType) {
     }
   );
 }`);
-    }
+    });
     for (const property of this.properties) {
         if (property.recursive) {
             continue;
@@ -88,8 +65,8 @@ if (!parameters?.ignoreRdfType) {
             patternsVariableDeclarationKeyword = "let";
         });
     }
-    return Maybe.of(code `\
-export const focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
+    return code `\
+((${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
             code `${patternsVariableDeclarationKeyword} patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
@@ -97,6 +74,6 @@ ${statements.length > 0
             code `return patterns;`,
         ])
         : "return [];"}
-};`);
+})`;
 }
-//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionExpression.js.map

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_fromRdfResourceFunctionExpression.js

@@ -0,0 +1,43 @@
+import { invariant } from "ts-invariant";
+import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_fromRdfResourceFunctionExpression() {
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+    const optionsVariable = `_${syntheticNamePrefix}options`;
+    const variables = {
+        context: code `${optionsVariable}.context`,
+        graph: code `${optionsVariable}.graph`,
+        ignoreRdfType: code `${optionsVariable}.ignoreRdfType`,
+        objectSet: code `${optionsVariable}.objectSet`,
+        preferredLanguages: code `${optionsVariable}.preferredLanguages`,
+        resource: code `${syntheticNamePrefix}resource`,
+    };
+    const propertyFromRdfResourceValuesVariables = {
+        context: variables.context,
+        focusResource: variables.resource,
+        graph: variables.graph,
+        objectSet: variables.objectSet,
+        preferredLanguages: variables.preferredLanguages,
+    };
+    const chains = [];
+    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
+        chains.push({
+            expression: code `!${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.resource}, ${arrayOf(fromRdfTypeVariable)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`,
+            variable: `_rdfTypeCheck`,
+        });
+    });
+    const propertyFromRdfResourceValuesInitializers = this.properties.flatMap((property) => property
+        .fromRdfResourceValuesInitializer({
+        variables: propertyFromRdfResourceValuesVariables,
+    })
+        .toList());
+    invariant(Object.keys(propertyFromRdfResourceValuesInitializers).length > 0);
+    chains.push({
+        expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyFromRdfResourceValuesInitializers, { on: ", " })} })`,
+        variable: "properties",
+    });
+    return code `\
+((${variables.resource}, ${optionsVariable}) => ${chains
+        .reverse()
+        .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(${this.createFunction}(properties))`)})`;
+}
+//# 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/ObjectType_identifierTypeDeclarations.js

@@ -0,0 +1,13 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_identifierTypeDeclarations() {
+    // Bespoke identifier type and associated functions
+    return [
+        code `export type Identifier = ${this.identifierType.expression};`,
+        code `\
+export namespace Identifier {
+  export const parse = ${this.identifierType.parseFunction};
+  export const stringify = ${this.identifierType.stringifyFunction};
+}`,
+    ];
+}
+//# sourceMappingURL=ObjectType_identifierTypeDeclarations.js.map

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

@@ -1,17 +1,20 @@
 import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
+import { code, literalOf } from "../ts-poet-wrapper.js";
 export function ObjectType_isTypeFunctionDeclaration() {
     if (!this.configuration.features.has("Object.type")) {
         return Maybe.empty();
     }
+    if (this.synthetic) {
+        return Maybe.empty();
+    }
+    const name = this.name.extract();
+    const discriminantProperty = this.discriminantProperty.extract();
+    if (!name || !discriminantProperty) {
+        return Maybe.empty();
+    }
     return Maybe.of(code `\
-export function is${this.alias.unsafeCoerce()}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.alias.unsafeCoerce()} {
-  switch (object.${this._discriminantProperty.name}) {
-    ${this._discriminantProperty.type.descendantValues
-        .concat(this._discriminantProperty.type.ownValues)
-        .map((value) => `case "${value}":`)
-        .join("\n")} return true; default: return false;
-  }
+export function is${name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${name} {
+  return object.${discriminantProperty.name} === ${literalOf(discriminantProperty.value)};
 }`);
 }
 //# sourceMappingURL=ObjectType_isTypeFunctionDeclaration.js.map

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_jsonSchemaExpression.js

@@ -0,0 +1,18 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonSchemaExpression() {
+    const properties = this.properties
+        .flatMap((property) => property.jsonSchema.toList())
+        .map(({ key, schema }) => code `"${key}": ${schema}`);
+    const meta = {
+    // id: this.name,
+    };
+    this.comment.ifJust((description) => {
+        meta["description"] = description;
+    });
+    this.label.ifJust((label) => {
+        meta["title"] = label;
+    });
+    // ${this.properties.every((property) => !property.mutable) ? `.readonly()` : ""}
+    return code `${this.reusables.imports.z}.object({${joinCode(properties, { on: "," })}}).meta(${meta})`;
+}
+//# 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