@shaclmate/compiler 4.0.40 → 4.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.40",
+    "@shaclmate/shacl-ast": "4.0.42",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -16,12 +16,10 @@
     "@types/rdfjs__prefix-map": "~0.1.5",
     "@types/rdfjs__term-map": "~2.0.10",
     "@types/rdfjs__term-set": "~2.0.9",
-    "@types/toposort": "2.0.7",
     "change-case": "~5.4.4",
     "plur": "~5.1.0",
     "purify-ts": "~2.1.4",
     "reserved-identifiers": "~1.0.0",
-    "toposort": "2.0.2",
     "ts-invariant": "~0.10.3",
     "ts-poet": "~6.12.0",
     "typescript-memoize": "~1.1.1"
@@ -68,5 +66,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.40"
+  "version": "4.0.42"
 }

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.d.ts

@@ -1,9 +0,0 @@
-import { Either } from "purify-ts";
-import * as ast from "../ast/index.js";
-import type * as input from "../input/index.js";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-export declare function transformPropertyShapeToAstObjectTypeProperty(this: ShapesGraphToAstTransformer, { objectType, propertyShape, }: {
-    objectType: ast.ObjectType;
-    propertyShape: input.PropertyShape;
-}): Either<Error, ast.ObjectType.Property>;
-//# sourceMappingURL=transformPropertyShapeToAstObjectTypeProperty.d.ts.map

package/dist/ast/LazyObjectOptionType.d.ts

@@ -1,6 +0,0 @@
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-import type { OptionType } from "./OptionType.js";
-export declare class LazyObjectOptionType extends AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>> {
-    readonly kind = "LazyObjectOption";
-}
-//# sourceMappingURL=LazyObjectOptionType.d.ts.map

package/dist/ast/LazyObjectOptionType.js

@@ -1,5 +0,0 @@
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-export class LazyObjectOptionType extends AbstractLazyObjectType {
-    kind = "LazyObjectOption";
-}
-//# sourceMappingURL=LazyObjectOptionType.js.map

package/dist/ast/LazyObjectSetType.d.ts

@@ -1,6 +0,0 @@
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-import type { SetType } from "./SetType.js";
-export declare class LazyObjectSetType extends AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>> {
-    readonly kind = "LazyObjectSet";
-}
-//# sourceMappingURL=LazyObjectSetType.d.ts.map

package/dist/ast/LazyObjectSetType.js

@@ -1,5 +0,0 @@
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-export class LazyObjectSetType extends AbstractLazyObjectType {
-    kind = "LazyObjectSet";
-}
-//# sourceMappingURL=LazyObjectSetType.js.map

package/dist/ast/LazyObjectType.d.ts

@@ -1,5 +0,0 @@
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint> {
-    readonly kind = "LazyObject";
-}
-//# sourceMappingURL=LazyObjectType.d.ts.map

package/dist/ast/LazyObjectType.js

@@ -1,5 +0,0 @@
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-export class LazyObjectType extends AbstractLazyObjectType {
-    kind = "LazyObject";
-}
-//# sourceMappingURL=LazyObjectType.js.map

package/dist/ast/ObjectCompoundType.d.ts

@@ -1,12 +0,0 @@
-import { BlankNodeType } from "./BlankNodeType.js";
-import { IdentifierType } from "./IdentifierType.js";
-import { IriType } from "./IriType.js";
-import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
-export type ObjectCompoundType = ObjectIntersectionType | ObjectUnionType;
-export declare namespace ObjectCompoundType {
-    function identifierType(objectCompoundType: ObjectCompoundType): BlankNodeType | IdentifierType | IriType;
-    function memberObjectTypes(objectCompoundType: ObjectCompoundType): readonly ObjectType[];
-}
-//# sourceMappingURL=ObjectCompoundType.d.ts.map

package/dist/ast/ObjectIntersectionType.d.ts

@@ -1,4 +0,0 @@
-import type { IntersectionType } from "./IntersectionType.js";
-import type { ObjectType } from "./ObjectType.js";
-export type ObjectIntersectionType = IntersectionType<IntersectionType<ObjectType> | ObjectType>;
-//# sourceMappingURL=ObjectIntersectionType.d.ts.map

package/dist/ast/ObjectIntersectionType.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ObjectIntersectionType.js.map

package/dist/ast/ObjectUnionType.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectType } from "./ObjectType.js";
-import type { UnionType } from "./UnionType.js";
-export type ObjectUnionType = UnionType<UnionType<ObjectType> | ObjectType>;
-//# sourceMappingURL=ObjectUnionType.d.ts.map

package/dist/ast/ObjectUnionType.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ObjectUnionType.js.map

package/dist/generators/ts/LazyObjectOptionType.js

@@ -1,62 +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 { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-import { code } from "./ts-poet-wrapper.js";
-const Super = (AbstractLazyObjectType);
-export class LazyObjectOptionType extends Super {
-    graphqlArgs = Maybe.empty();
-    kind = "LazyObjectOption";
-    get conversionFunction() {
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
-            sourceTypes: [
-                {
-                    expression: this.expression,
-                    typeof: "object",
-                },
-                {
-                    expression: this.resolveType.expression,
-                    typeof: "object",
-                },
-                {
-                    expression: this.resolveType.itemType.expression,
-                    typeof: "object",
-                },
-                {
-                    expression: code `undefined`,
-                    typeof: "undefined",
-                },
-            ],
-        });
-    }
-    get runtimeClass() {
-        return {
-            name: code `${this.reusables.snippets.LazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
-            partialPropertyName: "partial",
-            rawName: code `${this.reusables.snippets.LazyObjectOption}`,
-        };
-    }
-    fromJsonExpression(parameters) {
-        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: (identifier) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve identifier \${identifier} deserialized from JSON\`))) }))`;
-    }
-    fromRdfResourceValuesExpression(parameters) {
-        const { variables } = parameters;
-        return code `${this.partialType.fromRdfResourceValuesExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.object}(identifier, options) })))`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;
-    }
-}
-__decorate([
-    Memoize()
-], LazyObjectOptionType.prototype, "conversionFunction", null);
-__decorate([
-    Memoize()
-], LazyObjectOptionType.prototype, "runtimeClass", null);
-//# sourceMappingURL=LazyObjectOptionType.js.map

package/dist/generators/ts/LazyObjectSetType.d.ts

@@ -1,20 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-import type { SetType } from "./SetType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class LazyObjectSetType extends AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>> {
-    readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazyObjectSet";
-    get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
-    protected get runtimeClass(): {
-        name: Code;
-        partialPropertyName: string;
-        rawName: Code;
-    };
-    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
-    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
-}
-type Super = AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>>;
-export {};
-//# sourceMappingURL=LazyObjectSetType.d.ts.map

package/dist/generators/ts/LazyObjectSetType.js

@@ -1,61 +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 { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-import { code } from "./ts-poet-wrapper.js";
-export class LazyObjectSetType extends AbstractLazyObjectType {
-    graphqlArgs = Maybe.of({
-        limit: {
-            type: code `${this.reusables.imports.GraphQLInt}`,
-        },
-        offset: {
-            type: code `${this.reusables.imports.GraphQLInt}`,
-        },
-    });
-    kind = "LazyObjectSet";
-    get conversionFunction() {
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
-            sourceTypes: [
-                {
-                    expression: this.expression,
-                    typeof: "object",
-                },
-                {
-                    expression: this.resolveType.expression,
-                    typeof: "object",
-                },
-                {
-                    expression: code `undefined`,
-                    typeof: "undefined",
-                },
-            ],
-        });
-    }
-    get runtimeClass() {
-        return {
-            name: code `${this.reusables.snippets.LazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
-            partialPropertyName: "partials",
-            rawName: code `${this.reusables.snippets.LazyObjectSet}`,
-        };
-    }
-    fromJsonExpression(parameters) {
-        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: () => Promise.resolve(${this.reusables.imports.Left}(new Error("unable to resolve identifiers deserialized from JSON"))) }))`;
-    }
-    fromRdfResourceValuesExpression(parameters) {
-        const { variables } = parameters;
-        return code `${this.partialType.fromRdfResourceValuesExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifiers, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers, ...options }) })))`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return code `(${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).then(either => either.unsafeCoerce())`;
-    }
-}
-__decorate([
-    Memoize()
-], LazyObjectSetType.prototype, "conversionFunction", null);
-//# sourceMappingURL=LazyObjectSetType.js.map

package/dist/generators/ts/LazyObjectType.d.ts

@@ -1,19 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint> {
-    readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazyObject";
-    get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
-    protected get runtimeClass(): {
-        name: Code;
-        partialPropertyName: string;
-        rawName: Code;
-    };
-    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
-    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
-}
-type Super = AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint>;
-export {};
-//# sourceMappingURL=LazyObjectType.d.ts.map

package/dist/generators/ts/LazyObjectType.js

@@ -1,53 +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 { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-import { code } from "./ts-poet-wrapper.js";
-export class LazyObjectType extends AbstractLazyObjectType {
-    graphqlArgs = Maybe.empty();
-    kind = "LazyObject";
-    get conversionFunction() {
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.expression}, ${this.resolveType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
-            sourceTypes: [
-                {
-                    expression: this.expression,
-                    typeof: "object",
-                },
-                {
-                    expression: this.resolveType.expression,
-                    typeof: "object",
-                },
-            ],
-        });
-    }
-    get runtimeClass() {
-        return {
-            name: code `${this.reusables.snippets.LazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.expression}, ${this.resolveType.expression}>`,
-            partialPropertyName: "partial",
-            rawName: code `${this.reusables.snippets.LazyObject}`,
-        };
-    }
-    fromJsonExpression(parameters) {
-        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: (identifier) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve identifier \${identifier} deserialized from JSON\`))) }))`;
-    }
-    fromRdfResourceValuesExpression(parameters) {
-        const { variables } = parameters;
-        return code `${this.partialType.fromRdfResourceValuesExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.objectSetMethodNames.object}(identifier, options) })))`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;
-    }
-}
-__decorate([
-    Memoize()
-], LazyObjectType.prototype, "conversionFunction", null);
-__decorate([
-    Memoize()
-], LazyObjectType.prototype, "runtimeClass", null);
-//# sourceMappingURL=LazyObjectType.js.map

package/dist/generators/ts/_ObjectType/ObjectType_createFunctionDeclaration.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_createFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_createFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_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 ObjectType_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.alias.unsafeCoerce()}.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.alias.unsafeCoerce()}.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.expression}> {
-  return ${returnExpression};
-}
-  
-export function createUnsafe(${parametersSignature}): ${this.expression} {
-  return create(parameters).unsafeCoerce();
-}`);
-}
-//# sourceMappingURL=ObjectType_createFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_equalsFunctionDeclaration.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_equalsFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_equalsFunctionDeclaration.d.ts.map

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

@@ -1,23 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_equalsFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.equals")) {
-        return Maybe.empty();
-    }
-    const chain = [];
-    // For every parent, find the nearest equals implementation
-    for (const parentObjectType of this.parentObjectTypes) {
-        chain.push(code `${parentObjectType.equalsFunction}(left, right)`);
-    }
-    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 Maybe.of(code `\
-export function equals(left: ${this.expression}, right: ${this.expression}): ${this.reusables.snippets.EqualsResult} {
-  return ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
-}`);
-}
-//# sourceMappingURL=ObjectType_equalsFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_filterFunctionDeclaration.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_filterFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_filterFunctionDeclaration.d.ts.map

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

@@ -1,24 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_filterFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.filter")) {
-        return Maybe.empty();
-    }
-    const statements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `if (!${parentObjectType.filterFunction}(filter, value)) { return false; }`);
-    }
-    if (this.properties.length > 0) {
-        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 Maybe.of(code `\
-export function filter(filter: ${this.filterType}, value: ${this.expression}): boolean {
-  ${joinCode(statements)}
-}`);
-}
-//# sourceMappingURL=ObjectType_filterFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_filterTypeDeclaration.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_filterTypeDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_filterTypeDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_fromJsonFunctionDeclaration.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_fromJsonFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_fromJsonFunctionDeclaration.d.ts.map

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

@@ -1,43 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_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.alias.unsafeCoerce()}.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.expression}> {
-  return ${returnExpression};
-}`);
-}
-//# sourceMappingURL=ObjectType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceFunctionDeclaration.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_fromRdfResourceFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_fromRdfResourceFunctionDeclaration.d.ts.map

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

@@ -1,80 +0,0 @@
-import { Maybe } from "purify-ts";
-import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_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.alias.unsafeCoerce()}._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.expression}> = (${variables.resource}, ${optionsVariable}) => {
-  return ${returnExpression};
-}
-
-export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`);
-}
-//# sourceMappingURL=ObjectType_fromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceValuesFunctionDeclaration.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_fromRdfResourceValuesFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_fromRdfResourceValuesFunctionDeclaration.d.ts.map