@shaclmate/compiler 4.0.48 → 4.0.50

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

@@ -1,216 +0,0 @@
-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, }) {
-        const options = {
-            context: variables.context,
-            graph: variables.graph,
-            focusResource: variables.focusResource,
-            preferredLanguages: variables.preferredLanguages,
-            propertyPath: this.rdfjsTermExpression(rdf.subject),
-            schema: this.typeSchemaVariable,
-        };
-        if (this.configuration.features.has("ObjectSet")) {
-            options["objectSet"] = variables.objectSet;
-        }
-        return Maybe.of(code `${this.name}: ${this.type.fromRdfResourceValuesFunction}(
-          new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.focusResource, propertyPath: this.rdfjsTermExpression(rdf.subject), term: code `${variables.focusResource}.identifier` }}).toValues(),
-          ${options}
-        ).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

@@ -1,4 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,15 +0,0 @@
-import { code, joinCode } 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 `(${property.type.equalsFunction})(${property.accessExpression({ variables: { object: code `left` } })}, ${property.accessExpression({ variables: { object: code `right` } })}).mapLeft(propertyValuesUnequal => ({ left, right, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
-    }
-    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

@@ -1,4 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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