@shaclmate/compiler 4.0.50 → 4.0.51

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

@@ -0,0 +1,205 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { NodeKind } from "@shaclmate/shacl-ast";
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { arrayOf, code, joinCode, literalOf, } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export class IdentifierProperty extends AbstractProperty {
+    kind = "Identifier";
+    mutable = false;
+    recursive = false;
+    get constructorParameter() {
+        let hasQuestionToken = false;
+        const typeExpressions = [code `(() => ${this.typeExpression})`];
+        for (const type of this.type.conversionFunction.unsafeCoerce()
+            .sourceTypes) {
+            if (type.jsType.typeof === "undefined") {
+                hasQuestionToken = true;
+            }
+            else {
+                typeExpressions.push(code `${type.expression}`);
+            }
+        }
+        return Maybe.of({
+            hasQuestionToken,
+            signature: code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`,
+        });
+    }
+    get declaration() {
+        return code `readonly ${this.name}: () => ${this.typeExpression};`;
+    }
+    get filterProperty() {
+        return Maybe.of({
+            name: this.name,
+            type: this.type.filterType,
+        });
+    }
+    get graphqlField() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        invariant(this.name.startsWith(syntheticNamePrefix));
+        return Maybe.of({
+            args: Maybe.empty(),
+            description: Maybe.empty(),
+            name: `_${this.name.substring(syntheticNamePrefix.length)}`,
+            resolve: code `(source) => ${this.type.stringifyFunction}(${this.accessExpression({ variables: { object: code `source` } })})`,
+            type: this.type.graphqlType.expression,
+        });
+    }
+    get hashFunctionParameter() {
+        return code `readonly ${this.name}?: () => ${this.typeExpression};`;
+    }
+    get jsonSchema() {
+        let schema;
+        if (this.type.in_.length > 0 && this.type.kind === "Iri") {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            schema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.type.in_.map((iri) => iri.value))})`;
+        }
+        else {
+            schema = code `${this.reusables.imports.z}.string().min(1)`;
+        }
+        return Maybe.of({
+            key: "@id",
+            schema,
+        });
+    }
+    get jsonSignature() {
+        if (this.type.in_.length > 0) {
+            return Maybe.of(code `readonly "@id": ${this.type.in_.map((iri) => `"${iri.value}"`).join(" | ")}`);
+        }
+        return Maybe.of(code `readonly "@id": string`);
+    }
+    get schema() {
+        return Maybe.of(code `{ ${joinCode([code `kind: ${literalOf(this.kind)}`, code `type: ${this.type.schema}`], { on: ", " })} }`);
+    }
+    get schemaType() {
+        return Maybe.of(code `{ ${joinCode([
+            code `readonly kind: ${literalOf(this.kind)}`,
+            code `readonly type: ${this.type.schemaType}`,
+        ], { on: ", " })} }`);
+    }
+    get typeExpression() {
+        return this.objectType.name
+            .map((objectTypeAlias) => code `${objectTypeAlias}.Identifier`)
+            .orDefault(this.type.expression);
+    }
+    get typeSchemaVariable() {
+        return this.objectType.name
+            .map((name) => code `${name}.schema.properties.${this.name}.type`)
+            .orDefaultLazy(() => this.type.schema);
+    }
+    accessExpression({ variables, }) {
+        return code `${variables.object}.${this.name}()`;
+    }
+    constructorInitializer({ variables, }) {
+        const nodeKinds = this.type.nodeKinds;
+        let conversionFunction;
+        if (nodeKinds.size === 2) {
+            conversionFunction = code `${this.reusables.snippets.convertToIdentifierProperty}`;
+        }
+        else {
+            invariant(nodeKinds.size === 1);
+            if (nodeKinds.has("BlankNode")) {
+                conversionFunction = code `${this.reusables.snippets.convertToBlankNodeIdentifierProperty}`;
+            }
+            else {
+                conversionFunction = code `${this.reusables.snippets.convertToIriIdentifierProperty}<${this.type.in_.length > 0
+                    ? joinCode(this.type.in_.map((in_) => code `${literalOf(in_.value)}`), { on: " | " })
+                    : "string"}>`;
+            }
+        }
+        return Maybe.of(code `${this.name}: ${conversionFunction}(${variables.parameters}.${this.name})`);
+    }
+    fromJsonInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: ${this.type.fromJsonExpression({
+            variables: { value: variables.jsonObject },
+        })}`);
+    }
+    fromRdfResourceValuesInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: ${this.type.fromRdfResourceValuesFunction}(
+          ${this.reusables.snippets.rdfResourceIdentifierValues}(${variables.focusResource}),
+          { ...${variables.options}, focusResource: ${variables.focusResource}, propertyPath: ${this.rdfjsTermExpression(rdf.subject)}, schema: ${this.typeSchemaVariable} }
+        ).chain(values => values.head())`);
+    }
+    hashStatements({ variables, }) {
+        return [
+            code `if (${variables.value}) { ${variables.hasher}.update(${variables.value}().value); }`,
+        ];
+    }
+    jsonUiSchemaElement({ variables, }) {
+        return Maybe.of(code `{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/@id\`, type: "Control" }`);
+    }
+    sparqlConstructTriplesExpression() {
+        return Maybe.empty();
+    }
+    sparqlWherePatternsExpression({ variables, }) {
+        return Maybe.of({
+            condition: code `${variables.focusIdentifier}.termType === "Variable"`,
+            patterns: code `${this.type.valueSparqlWherePatternsFunction}(${{
+                filter: code `${variables.filter}?.${this.name}`,
+                ignoreRdfType: true, // Unused
+                preferredLanguages: variables.preferredLanguages,
+                propertyPatterns: code `[]`,
+                schema: this.typeSchemaVariable,
+                valueVariable: variables.focusIdentifier,
+                variablePrefix: variables.variablePrefix, // Unused
+            }})`,
+        });
+    }
+    toJsonInitializer({ variables, }) {
+        const nodeKinds = [...this.type.nodeKinds];
+        const valueToNodeKinds = nodeKinds.map((nodeKind) => {
+            switch (nodeKind) {
+                case "BlankNode":
+                    return code `\`_:\${${variables.value}.value}\``;
+                case "IRI":
+                    return code `${variables.value}.value`;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+        });
+        if (valueToNodeKinds.length === 1) {
+            return Maybe.of(code `"@id": ${valueToNodeKinds[0]}`);
+        }
+        invariant(valueToNodeKinds.length === 2);
+        return Maybe.of(code `"@id": ${variables.value}.termType === "${NodeKind.toTermType(nodeKinds[0])}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
+    }
+    toRdfRdfResourceValuesStatements() {
+        return [];
+    }
+    toStringInitializer(parameters) {
+        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toStringExpression(parameters)}`);
+    }
+}
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "constructorParameter", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "filterProperty", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "graphqlField", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "hashFunctionParameter", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "jsonSchema", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "jsonSignature", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "typeExpression", null);
+//# sourceMappingURL=IdentifierProperty.js.map

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

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

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

@@ -0,0 +1,28 @@
+import { invariant } from "ts-invariant";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_createFunctionExpression() {
+    const parametersVariable = code `parameters${this.constructorParameters.hasQuestionToken ? "?" : ""}`;
+    const propertyInitializers = this.properties.flatMap((property) => property
+        .constructorInitializer({
+        variables: { parameters: parametersVariable },
+    })
+        .toList());
+    invariant(propertyInitializers.length > 0);
+    let returnExpression = code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`;
+    this.discriminantProperty.ifJust((discriminantProperty) => {
+        returnExpression = code `${returnExpression}.map(properties => ({ ...properties, ${discriminantProperty.name}: ${literalOf(discriminantProperty.value)} as const }))`;
+    });
+    const monkeyPatchMethods = {};
+    if (this.configuration.features.has("Object.toJson")) {
+        monkeyPatchMethods["toJson"] = this.toJsonFunction;
+    }
+    if (this.configuration.features.has("Object.toString")) {
+        monkeyPatchMethods[`${this.configuration.syntheticNamePrefix}toString`] =
+            this.toStringFunction;
+    }
+    if (Object.keys(monkeyPatchMethods).length > 0) {
+        returnExpression = code `${returnExpression}.map(object => ${this.reusables.snippets.monkeyPatchObject}(object, ${monkeyPatchMethods}))`;
+    }
+    return code `((parameters${this.name.map(() => code ``).orDefaultLazy(() => code `: ${this.constructorParameters.type.expression}`)}) => ${returnExpression})`;
+}
+//# sourceMappingURL=ObjectType_createFunctionExpression.js.map

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

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

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

@@ -0,0 +1,19 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_equalsFunctionExpression() {
+    const chain = [];
+    for (const property of this.properties) {
+        if (property.kind === "Discriminant") {
+            continue;
+        }
+        chain.push(code `${this.reusables.snippets.propertyEquals}(
+        { equalsFunction: ${property.type.equalsFunction}, name: ${literalOf(property.name)} },
+        [left, ${property.accessExpression({ variables: { object: code `left` } })}],
+        [right, ${property.accessExpression({ variables: { object: code `right` } })}],
+      )`);
+    }
+    return code `\
+((left, right) =>
+  ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
+)`;
+}
+//# sourceMappingURL=ObjectType_equalsFunctionExpression.js.map

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

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

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

@@ -0,0 +1,12 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_filterFunctionExpression() {
+    const statements = [];
+    for (const property of this.properties) {
+        property.filterProperty.ifJust(({ name }) => {
+            statements.push(code `if (filter.${name} !== undefined && !${property.type.filterFunction}(filter.${name}, ${property.accessExpression({ variables: { object: code `value` } })})) { return false; }`);
+        });
+    }
+    statements.push(code `return true;`);
+    return code `((filter, value) => { ${joinCode(statements)} })`;
+}
+//# sourceMappingURL=ObjectType_filterFunctionExpression.js.map

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

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

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

@@ -0,0 +1,20 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_filterTypeExpression() {
+    const members = [];
+    if (this.properties.length > 0) {
+        const filterProperties = {};
+        for (const property of this.properties) {
+            property.filterProperty.ifJust(({ name, type }) => {
+                filterProperties[name] = type;
+            });
+        }
+        if (Object.entries(filterProperties).length > 0) {
+            members.push(code `{ ${joinCode(Object.entries(filterProperties).map(([name, type]) => code `readonly ${name}?: ${type}`), { on: ";" })} }`);
+        }
+    }
+    if (members.length > 0) {
+        return joinCode(members, { on: " & " });
+    }
+    return code `object`;
+}
+//# sourceMappingURL=ObjectType_filterTypeExpression.js.map

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

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

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

@@ -0,0 +1,46 @@
+import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+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_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 = [];
+    if (this.fromRdfType.isJust()) {
+        statements.push(code `\
+if (!parameters?.ignoreRdfType) {
+  triples.push(
+    { subject: ${variables.focusIdentifier}, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
+    { subject: ${rdfTypeVariable}, predicate: ${this.rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
+  );
+}`);
+    }
+    for (const property of this.properties) {
+        if (property.recursive) {
+            continue;
+        }
+        property
+            .sparqlConstructTriplesExpression({
+            variables,
+        })
+            .ifJust((propertyTriples) => {
+            statements.push(code `triples = triples.concat(${propertyTriples});`);
+            triplesVariableDeclarationKeyword = "let";
+        });
+    }
+    return code `\
+((${statements.length === 0 ? "_" : ""}parameters) => {
+${statements.length > 0
+        ? joinCode([
+            code `${triplesVariableDeclarationKeyword} triples: ${this.reusables.imports.sparqljs}.Triple[] = [];`,
+            ...statements,
+            code `return triples;`,
+        ])
+        : "return [];"}
+})`;
+}
+//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionExpression.js.map

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

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

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

@@ -0,0 +1,79 @@
+import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const variables = {
+    filter: code `parameters.filter`,
+    preferredLanguages: code `parameters.preferredLanguages`,
+    focusIdentifier: code `parameters.focusIdentifier`,
+    variablePrefix: code `parameters.variablePrefix`,
+};
+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 = [];
+    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
+        statements.push(code `const rdfTypeVariable = ${rdfTypeVariable};`, code `\
+if (!parameters?.ignoreRdfType) {
+  patterns.push(
+    ${code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariable}, subject: ${variables.focusIdentifier} }),`}
+    {
+      triples: [
+        {
+          subject: ${variables.focusIdentifier},
+          predicate: ${this.rdfjsTermExpression(rdf.type)},
+          object: rdfTypeVariable
+        }
+      ],
+      type: "bgp" as const
+    },
+    {
+      patterns: [
+        {
+          triples: [
+            {
+              subject: rdfTypeVariable,
+              predicate: {
+                items: [${this.rdfjsTermExpression(rdfs.subClassOf)}],
+                pathType: "+" as const,
+                type: "path" as const
+              },
+              object: ${rdfClassVariable}
+            }
+          ],
+          type: "bgp" as const
+        }
+      ],
+      type: "optional" as const
+    }
+  );
+}`);
+    });
+    for (const property of this.properties) {
+        if (property.recursive) {
+            continue;
+        }
+        property
+            .sparqlWherePatternsExpression({ variables })
+            .ifJust(({ condition, patterns }) => {
+            const concatStatement = code `patterns = patterns.concat(${patterns});`;
+            if (condition) {
+                statements.push(code `if (${condition}) { ${concatStatement} }`);
+            }
+            else {
+                statements.push(concatStatement);
+            }
+            patternsVariableDeclarationKeyword = "let";
+        });
+    }
+    return code `\
+((${statements.length === 0 ? "_" : ""}parameters) => {
+${statements.length > 0
+        ? joinCode([
+            code `${patternsVariableDeclarationKeyword} patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
+            ...statements,
+            code `return patterns;`,
+        ])
+        : "return [];"}
+})`;
+}
+//# 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,38 @@
+import { invariant } from "ts-invariant";
+import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_fromRdfResourceFunctionExpression() {
+    const optionsVariable = code `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 `resource`,
+    };
+    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: {
+            focusResource: variables.resource,
+            options: optionsVariable,
+        },
+    })
+        .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_graphqlTypeExpression.js

@@ -0,0 +1,26 @@
+import { code } from "../ts-poet-wrapper.js";
+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) => {
+                fields[field.name] = {
+                    args: field.args
+                        .map((args) => Object.entries(args).reduce((argObjects, [argName, arg]) => {
+                        argObjects[argName] = arg;
+                        return argObjects;
+                    }, {}))
+                        .extract(),
+                    description: field.description.extract(),
+                    name: field.name,
+                    resolve: field.resolve,
+                    type: field.type,
+                };
+            });
+            return fields;
+        }, {})})`,
+        name: this.name.orDefault(this.shapeIdentifier.value),
+    }})`;
+}
+//# 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.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_isTypeFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_isTypeFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,20 @@
+import { Maybe } from "purify-ts";
+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${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

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

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

@@ -0,0 +1,10 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonParseFunctionDeclaration() {
+    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