@shaclmate/compiler 4.0.39 → 4.0.41

package/dist/generators/ts/NamedObjectType.js

@@ -1,342 +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 { camelCase } from "change-case";
-import { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
-import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
-import { identifierTypeDeclarations } from "./_NamedObjectType/identifierTypeDeclarations.js";
-import { NamedObjectType_createFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_createFunctionDeclaration.js";
-import { NamedObjectType_equalsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_equalsFunctionDeclaration.js";
-import { NamedObjectType_filterFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_filterFunctionDeclaration.js";
-import { NamedObjectType_filterTypeDeclaration } from "./_NamedObjectType/NamedObjectType_filterTypeDeclaration.js";
-import { NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js";
-import { NamedObjectType_focusSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js";
-import { NamedObjectType_fromJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.js";
-import { NamedObjectType_fromRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.js";
-import { NamedObjectType_fromRdfResourceValuesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromRdfResourceValuesFunctionDeclaration.js";
-import { NamedObjectType_fromRdfTypeVariableStatement } from "./_NamedObjectType/NamedObjectType_fromRdfTypeVariableStatement.js";
-import { NamedObjectType_graphqlTypeVariableStatement } from "./_NamedObjectType/NamedObjectType_graphqlTypeVariableStatement.js";
-import { NamedObjectType_hashFunctionDeclarations } from "./_NamedObjectType/NamedObjectType_hashFunctionDeclarations.js";
-import { NamedObjectType_interfaceDeclaration } from "./_NamedObjectType/NamedObjectType_interfaceDeclaration.js";
-import { NamedObjectType_isTypeFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_isTypeFunctionDeclaration.js";
-import { NamedObjectType_jsonParseFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonParseFunctionDeclaration.js";
-import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js";
-import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
-import { NamedObjectType_jsonUiSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.js";
-import { NamedObjectType_objectSetMethodNames } from "./_NamedObjectType/NamedObjectType_objectSetMethodNames.js";
-import { NamedObjectType_schemaVariableStatement } from "./_NamedObjectType/NamedObjectType_schemaVariableStatement.js";
-import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
-import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { NamedObjectType_toJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_toJsonFunctionDeclaration.js";
-import { NamedObjectType_toRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_toRdfResourceFunctionDeclaration.js";
-import { NamedObjectType_toStringFunctionDeclarations } from "./_NamedObjectType/NamedObjectType_toStringFunctionDeclarations.js";
-import { NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js";
-import { NamedObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
-import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
-import { AbstractType } from "./AbstractType.js";
-import { code, def, joinCode } from "./ts-poet-wrapper.js";
-export class NamedObjectType extends AbstractType {
-    toRdfTypes;
-    conversionFunction = Maybe.empty();
-    extern;
-    fromRdfType;
-    graphqlArgs = Maybe.empty();
-    identifierType;
-    kind = "NamedObjectType";
-    name;
-    recursive;
-    referencesObjectType = true;
-    synthetic;
-    typeofs = ["object"];
-    validationFunction = Maybe.empty();
-    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }) {
-        super(superParameters);
-        this.extern = extern;
-        this.fromRdfType = fromRdfType;
-        this.identifierType = identifierType;
-        // Lazily initialize some members in getters to avoid recursive construction
-        this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
-        this.lazyChildObjectTypes = lazyChildObjectTypes;
-        this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
-        this.lazyDiscriminantProperty = lazyDiscriminantProperty;
-        this.lazyParentObjectTypes = lazyParentObjectTypes;
-        this.lazyProperties = lazyProperties;
-        this.name = name;
-        this.recursive = recursive;
-        this.synthetic = synthetic;
-        this.toRdfTypes = toRdfTypes;
-    }
-    get _discriminantProperty() {
-        return this.lazyDiscriminantProperty(this);
-    }
-    get ancestorObjectTypes() {
-        return this.lazyAncestorObjectTypes();
-    }
-    get childObjectTypes() {
-        return this.lazyChildObjectTypes();
-    }
-    get declaration() {
-        const declarations = [];
-        if (!this.extern) {
-            const staticModuleDeclarations = [];
-            if (this.configuration.features.has("Object.type")) {
-                declarations.push(NamedObjectType_interfaceDeclaration.call(this));
-            }
-            staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionDeclaration.call(this).toList(), ...NamedObjectType_hashFunctionDeclarations.call(this));
-            const jsonModuleDeclarations = [
-                ...NamedObjectType_jsonParseFunctionDeclaration.call(this).toList(),
-                ...NamedObjectType_jsonSchemaFunctionDeclaration.call(this).toList(),
-                ...NamedObjectType_jsonUiSchemaFunctionDeclaration.call(this).toList(),
-            ];
-            staticModuleDeclarations.push(...NamedObjectType_graphqlTypeVariableStatement.call(this).toList(), ...identifierTypeDeclarations.call(this), ...NamedObjectType_jsonTypeAliasDeclaration.call(this).toList(), ...(jsonModuleDeclarations.length > 0
-                ? [
-                    code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
-                ]
-                : []), ...NamedObjectType_filterFunctionDeclaration.call(this).toList(), ...NamedObjectType_filterTypeDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), ...NamedObjectType_isTypeFunctionDeclaration.call(this).toList(), ...NamedObjectType_schemaVariableStatement.call(this).toList(), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
-                configuration: this.configuration,
-                filterType: this.filterType,
-                name: this.name,
-                reusables: this.reusables,
-            }).toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
-                configuration: this.configuration,
-                filterType: this.filterType,
-                name: this.name,
-                reusables: this.reusables,
-            }).toList(), ...NamedObjectType_toJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_toStringFunctionDeclarations.call(this), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.call(this).toList());
-            if (staticModuleDeclarations.length > 0) {
-                declarations.push(code `\
-export namespace ${def(this.name)} {
-${joinCode(staticModuleDeclarations, { on: "\n\n" })}
-}`);
-            }
-        }
-        if (declarations.length === 0) {
-            return Maybe.empty();
-        }
-        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
-    }
-    get descendantFromRdfTypeVariables() {
-        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
-    }
-    get descendantFromRdfTypes() {
-        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfType.toList());
-    }
-    get descendantObjectTypes() {
-        return this.lazyDescendantObjectTypes();
-    }
-    get discriminantProperty() {
-        return Maybe.of({
-            jsonName: this._discriminantProperty.jsonName,
-            name: this._discriminantProperty.name,
-            ownValues: this._discriminantProperty.type.ownValues,
-            descendantValues: this._discriminantProperty.type.descendantValues,
-        });
-    }
-    get discriminantValue() {
-        return this.name;
-    }
-    get equalsFunction() {
-        return code `${this.name}.equals`;
-    }
-    get filterFunction() {
-        return code `${this.name}.filter`;
-    }
-    get filterType() {
-        return code `${this.name}.Filter`;
-    }
-    get fromRdfTypeVariable() {
-        return this.fromRdfType.map(() => code `${this.name}.fromRdfType`);
-    }
-    get graphqlType() {
-        return new AbstractType.GraphqlType(code `${this.name}.GraphQL`, this.reusables);
-    }
-    get hashFunction() {
-        return code `${this.name}.hash`;
-    }
-    get identifierTypeAlias() {
-        return code `${this.name}.Identifier`;
-    }
-    get mutable() {
-        return this.properties.some((property) => property.mutable);
-    }
-    get objectSetMethodNames() {
-        return NamedObjectType_objectSetMethodNames.call({
-            configuration: this.configuration,
-            name: this.name,
-        });
-    }
-    get parentObjectTypes() {
-        return this.lazyParentObjectTypes();
-    }
-    get properties() {
-        const properties = this.lazyProperties(this);
-        const propertyNames = new Set();
-        for (const property of properties) {
-            if (propertyNames.has(property.name)) {
-                throw new Error(`duplicate property '${property.name}'`);
-            }
-        }
-        return properties;
-    }
-    get schema() {
-        return code `${this.name}.schema`;
-    }
-    get schemaType() {
-        return code `typeof ${this.schema}`;
-    }
-    get toRdfResourceValueTypes() {
-        return new Set([...this.identifierType.nodeKinds].map(NodeKind.toTermType));
-    }
-    get toRdfjsResourceType() {
-        if (this.parentObjectTypes.length > 0) {
-            return this.parentObjectTypes[0].toRdfjsResourceType;
-        }
-        return code `${this.reusables.imports.Resource}${this.identifierType.kind === "Iri" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return code `${this.name}.valueSparqlConstructTriples`;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return code `${this.name}.valueSparqlWherePatterns`;
-    }
-    get thisVariable() {
-        return code `_${camelCase(this.name)}`;
-    }
-    fromJsonExpression({ variables, }) {
-        // Assumes the JSON object has been recursively validated already.
-        return code `${this.name}.fromJson(${variables.value})`;
-    }
-    fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
-        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
-        if (!this.configuration.features.has("ObjectSet")) {
-            delete fromRdfResourceValuesOptions["objectSet"];
-        }
-        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
-    jsonSchema({ context, }) {
-        let expression = code `${this.name}.Json.schema()`;
-        if (context === "property" &&
-            this.properties.some((property) => property.recursive)) {
-            expression = code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.name}.Json> => ${expression})`;
-        }
-        return expression;
-    }
-    jsonType() {
-        return new AbstractType.JsonType(code `${this.name}.Json`);
-    }
-    jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(code `${this.name}.Json.uiSchema({ scopePrefix: ${variables.scopePrefix} })`);
-    }
-    toJsonExpression({ variables, }) {
-        return code `${this.name}.toJson(${variables.value})`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        return code `[${this.name}.toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
-    }
-    toStringExpression({ variables, }) {
-        return code `${this.name}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`;
-    }
-    lazyAncestorObjectTypes;
-    lazyChildObjectTypes;
-    lazyDescendantObjectTypes;
-    lazyDiscriminantProperty;
-    lazyParentObjectTypes;
-    lazyProperties;
-}
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "_discriminantProperty", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "ancestorObjectTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "childObjectTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "descendantFromRdfTypeVariables", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "descendantFromRdfTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "descendantObjectTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "discriminantProperty", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "discriminantValue", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "filterFunction", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "filterType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "fromRdfTypeVariable", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "hashFunction", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "identifierTypeAlias", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "mutable", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "objectSetMethodNames", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "parentObjectTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "properties", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "schema", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "schemaType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "toRdfResourceValueTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "toRdfjsResourceType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "thisVariable", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "jsonType", null);
-(function (NamedObjectType) {
-    NamedObjectType.IdentifierProperty = _IdentifierProperty;
-    NamedObjectType.ShaclProperty = _ShaclProperty;
-    NamedObjectType.DiscriminantProperty = _DiscriminantProperty;
-})(NamedObjectType || (NamedObjectType = {}));
-//# sourceMappingURL=NamedObjectType.js.map

package/dist/generators/ts/NamedObjectUnionType.d.ts

@@ -1,37 +0,0 @@
-import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
-import { AbstractType } from "./AbstractType.js";
-import type { BlankNodeType } from "./BlankNodeType.js";
-import type { IdentifierType } from "./IdentifierType.js";
-import type { IriType } from "./IriType.js";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class NamedObjectUnionType extends AbstractNamedUnionType<NamedObjectType> {
-    #private;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "NamedObjectUnion";
-    readonly synthetic: boolean;
-    constructor({ identifierType, synthetic, ...superParameters }: {
-        identifierType: BlankNodeType | IdentifierType | IriType;
-        synthetic: boolean;
-    } & Omit<ConstructorParameters<typeof AbstractNamedUnionType<NamedObjectType>>[0], "identifierType">);
-    get graphqlType(): AbstractType.GraphqlType;
-    get identifierTypeAlias(): Code;
-    get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
-    get schema(): Code;
-    get schemaType(): Code;
-    protected get staticModuleDeclarations(): Record<string, Code>;
-    private get focusSparqlConstructTriplesFunctionDeclaration();
-    private get focusSparqlWherePatternsFunctionDeclaration();
-    private get fromRdfResourceFunctionDeclaration();
-    private get graphqlTypeVariableStatement();
-    private get identifierTypeDeclarations();
-    private get isTypeFunctionDeclaration();
-    private get schemaVariableStatement();
-    private get toRdfResourceFunctionDeclaration();
-    graphqlResolveExpression({ variables, }: {
-        variables: {
-            value: Code;
-        };
-    }): Code;
-}
-//# sourceMappingURL=NamedObjectUnionType.d.ts.map

package/dist/generators/ts/NamedUnionType.d.ts

@@ -1,11 +0,0 @@
-import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
-import type { AbstractType } from "./AbstractType.js";
-import type { Type } from "./Type.js";
-import type { Code } from "./ts-poet-wrapper.js";
-export declare class NamedUnionType extends AbstractNamedUnionType<Type> {
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "NamedUnion";
-    graphqlResolveExpression(): Code;
-    get graphqlType(): AbstractType.GraphqlType;
-}
-//# sourceMappingURL=NamedUnionType.d.ts.map

package/dist/generators/ts/NamedUnionType.js

@@ -1,13 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
-export class NamedUnionType extends AbstractNamedUnionType {
-    graphqlArgs = Maybe.empty();
-    kind = "NamedUnion";
-    graphqlResolveExpression() {
-        throw new Error("GraphQL doesn't support scalar unions");
-    }
-    get graphqlType() {
-        throw new Error("GraphQL doesn't support scalar unions");
-    }
-}
-//# sourceMappingURL=NamedUnionType.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_createFunctionDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_createFunctionDeclaration.js

@@ -1,65 +0,0 @@
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function NamedObjectType_createFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.create")) {
-        return Maybe.empty();
-    }
-    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParameter.toList());
-    const parametersType = [];
-    if (parametersPropertySignatures.length > 0) {
-        parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
-    }
-    for (const parentObjectType of this.parentObjectTypes) {
-        parametersType.push(code `Parameters<typeof ${parentObjectType.name}.create>[0]`);
-    }
-    if (parametersType.length === 0) {
-        parametersType.push(code `object`);
-    }
-    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
-        parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
-    const parametersVariable = code `parameters${parametersHasQuestionToken ? "?" : ""}`;
-    const parametersSignature = code `parameters${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}`;
-    const chains = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        chains.push({
-            expression: code `${parentObjectType.name}.create(parameters)`,
-            variable: `super${parentObjectTypeI}`,
-        });
-    });
-    const propertyInitializers = this.properties.flatMap((property) => property
-        .constructorInitializer({
-        variables: { parameters: parametersVariable },
-    })
-        .toList());
-    invariant(propertyInitializers.length > 0);
-    chains.push({
-        expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`,
-        variable: "properties",
-    });
-    let returnExpression = code `{ ${chains
-        .map((chain) => `...${chain.variable}`)
-        .join(", ")}, ${this._discriminantProperty.name}: ${literalOf(this.discriminantValue)} as const }`;
-    const monkeyPatchMethods = [];
-    if (this.configuration.features.has("Object.toJson")) {
-        monkeyPatchMethods.push("toJson");
-    }
-    if (this.configuration.features.has("Object.toString")) {
-        monkeyPatchMethods.push(`${this.configuration.syntheticNamePrefix}toString`);
-    }
-    if (monkeyPatchMethods.length > 0) {
-        returnExpression = code `${this.reusables.snippets.monkeyPatchObject}(${returnExpression}, { ${monkeyPatchMethods.join(", ")} })`;
-    }
-    returnExpression = chains
-        .toReversed()
-        .reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, returnExpression);
-    return Maybe.of(code `\
-export function create(${parametersSignature}): ${this.reusables.imports.Either}<Error, ${this.name}> {
-  return ${returnExpression};
-}
-  
-export function createUnsafe(${parametersSignature}): ${this.name} {
-  return create(parameters).unsafeCoerce();
-}`);
-}
-//# sourceMappingURL=NamedObjectType_createFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_equalsFunctionDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_filterFunctionDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_filterTypeDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.js

@@ -1,43 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_fromJsonFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.fromJson")) {
-        return Maybe.empty();
-    }
-    const variables = {
-        jsonObject: code `${this.configuration.syntheticNamePrefix}json`,
-    };
-    const chains = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        chains.push({
-            expression: code `${parentObjectType.name}.fromJson(${variables.jsonObject})`,
-            variable: `super${parentObjectTypeI}`,
-        });
-    });
-    const propertyInitializers = this.properties.flatMap((property) => property.fromJsonInitializer({ variables }).toList());
-    if (propertyInitializers.length > 0) {
-        chains.push({
-            expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`,
-            variable: "properties",
-        });
-    }
-    let returnExpression;
-    switch (chains.length) {
-        case 0:
-            returnExpression = code `create({})`;
-            break;
-        case 1:
-            returnExpression = code `(${chains[0].expression}).chain(create)`;
-            break;
-        default:
-            returnExpression = code `${chains
-                .reverse()
-                .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(create({ ${chains.map((chain) => `...${chain.variable}`).join(", ")} }))`)}`;
-            break;
-    }
-    return Maybe.of(code `\
-export function fromJson(${variables.jsonObject}: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.name}> {
-  return ${returnExpression};
-}`);
-}
-//# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.js

@@ -1,80 +0,0 @@
-import { Maybe } from "purify-ts";
-import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.fromRdf")) {
-        return Maybe.empty();
-    }
-    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 propertyFromRdfResourceValuesExpressionVariable = {
-        context: variables.context,
-        graph: variables.graph,
-        objectSet: variables.objectSet,
-        preferredLanguages: variables.preferredLanguages,
-        resource: variables.resource,
-    };
-    const chains = [];
-    const partials = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        chains.push({
-            expression: code `${parentObjectType.name}._fromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
-            variable: `super${parentObjectTypeI}`,
-        });
-        partials.push(`super${parentObjectTypeI}`);
-    });
-    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
-        chains.push({
-            expression: code `!${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.resource}, ${arrayOf(fromRdfTypeVariable, ...this.descendantFromRdfTypeVariables)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`,
-            variable: `_rdfTypeCheck`,
-        });
-    });
-    const propertyFromRdfResourceValuesInitializers = this.properties.flatMap((property) => property
-        .fromRdfResourceValuesInitializer({
-        variables: propertyFromRdfResourceValuesExpressionVariable,
-    })
-        .toList());
-    if (Object.keys(propertyFromRdfResourceValuesInitializers).length > 0) {
-        chains.push({
-            expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyFromRdfResourceValuesInitializers, { on: ", " })} })`,
-            variable: "properties",
-        });
-        partials.push("properties");
-    }
-    let partialsJoined;
-    switch (partials.length) {
-        case 0:
-            partialsJoined = code `{}`;
-            break;
-        case 1:
-            partialsJoined = code `${partials[0]}`;
-            break;
-        default:
-            partialsJoined = code `{ ${partials.map((partial) => `...${partial}`).join(", ")} }`;
-            break;
-    }
-    let returnExpression;
-    const resultExpression = code `create(${partialsJoined})`;
-    if (chains.length === 0) {
-        returnExpression = code `${this.reusables.imports.Right}(${resultExpression})`;
-    }
-    else {
-        returnExpression = code `${chains
-            .reverse()
-            .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(${resultExpression})`)}`;
-    }
-    return Maybe.of(code `\
-export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.name}> = (${variables.resource}, ${optionsVariable}) => {
-  return ${returnExpression};
-}
-
-export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`);
-}
-//# sourceMappingURL=NamedObjectType_fromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceValuesFunctionDeclaration.d.ts

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