@shaclmate/compiler 4.0.41 → 4.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.41",
+    "@shaclmate/shacl-ast": "4.0.42",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -66,5 +66,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.41"
+  "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/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/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/_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,44 +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 = parametersPropertySignatures.length > 0
-        ? code `{ ${joinCode(parametersPropertySignatures)} }`
-        : code `object`;
-    const parametersHasQuestionToken = parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
-    const parametersVariable = code `parameters${parametersHasQuestionToken ? "?" : ""}`;
-    const parametersSignature = code `parameters${parametersHasQuestionToken ? "?" : ""}: ${parametersType}`;
-    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.push("toJson");
-    }
-    if (this.configuration.features.has("Object.toString")) {
-        monkeyPatchMethods.push(`${this.configuration.syntheticNamePrefix}toString`);
-    }
-    if (monkeyPatchMethods.length > 0) {
-        returnExpression = code `${returnExpression}.map(object => ${this.reusables.snippets.monkeyPatchObject}(object, { ${monkeyPatchMethods.join(", ")} }))`;
-    }
-    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_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,21 +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 = [];
-    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,18 +0,0 @@
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-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 propertyInitializers = this.properties.flatMap((property) => property.fromJsonInitializer({ variables }).toList());
-    invariant(propertyInitializers.length > 0);
-    return Maybe.of(code `\
-export function fromJson(${variables.jsonObject}: ${this.jsonType().expression}): ${this.reusables.imports.Either}<Error, ${this.expression}> {
-  return ${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} }).chain(create);
-}`);
-}
-//# 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_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

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

@@ -1,15 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_fromRdfResourceValuesFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.fromRdf")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.alias.unsafeCoerce()}> = (values, options) => 
-  values.chain(
-    values => values.chainMap(
-      value => value.toResource().chain(resource => ${this.alias.unsafeCoerce()}.fromRdfResource(resource, options))
-    )
-  );`);
-}
-//# sourceMappingURL=ObjectType_fromRdfResourceValuesFunctionDeclaration.js.map

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

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

@@ -1,10 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_fromRdfTypeVariableStatement() {
-    if (!this.configuration.features.has("Object.fromRdf")) {
-        return Maybe.empty();
-    }
-    return this.fromRdfType.map((fromRdfType) => code `\
-export const fromRdfType: ${this.reusables.imports.NamedNode}<string> = ${this.rdfjsTermExpression(fromRdfType)};`);
-}
-//# sourceMappingURL=ObjectType_fromRdfTypeVariableStatement.js.map

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

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

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

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

@@ -1,41 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-const hasherVariable = code `hasher`;
-export function ObjectType_hashFunctionDeclarations() {
-    if (!this.configuration.features.has("Object.hash")) {
-        return [];
-    }
-    return [
-        code `\
-export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.expression}): HasherT {
-  ${joinCode([
-            code `${this.alias.unsafeCoerce()}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`,
-            ...this.properties
-                .filter((property) => property.kind !== "Shacl")
-                .flatMap((property) => property.hashStatements({
-                variables: {
-                    hasher: hasherVariable,
-                    value: code `${property.accessExpression({ variables: { object: this.thisVariable } })}`,
-                },
-            })),
-            code `return ${hasherVariable};`,
-        ])}
-}`,
-        code `\
-export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.expression}): HasherT {
-  ${joinCode([
-            ...this.properties.flatMap((property) => property.kind === "Shacl"
-                ? property.hashStatements({
-                    variables: {
-                        hasher: hasherVariable,
-                        value: property.accessExpression({
-                            variables: { object: this.thisVariable },
-                        }),
-                    },
-                })
-                : []),
-            code `return ${hasherVariable};`,
-        ])}
-}`,
-    ];
-}
-//# sourceMappingURL=ObjectType_hashFunctionDeclarations.js.map

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

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

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

@@ -1,12 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-import { tsComment } from "../tsComment.js";
-export function ObjectType_interfaceDeclaration() {
-    return code `\
-${this.comment
-        .alt(this.label)
-        .map(tsComment)
-        .orDefault("")}export interface ${this.alias.unsafeCoerce()} {
-  ${joinCode(this.properties.map((property) => property.declaration), { on: "\n\n" })}
-}`;
-}
-//# sourceMappingURL=ObjectType_interfaceDeclaration.js.map

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

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

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

@@ -1,9 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonTypeAliasDeclaration() {
-    if (!this.configuration.features.has("Object.JSON.type")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `export type Json = { ${joinCode(this.properties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`);
-}
-//# sourceMappingURL=ObjectType_jsonTypeAliasDeclaration.js.map

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

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

@@ -1,15 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonUiSchemaFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.JSON.uiSchema")) {
-        return Maybe.empty();
-    }
-    const variables = { scopePrefix: code `scopePrefix` };
-    const elements = this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList());
-    return Maybe.of(code `\
-export function uiSchema(parameters?: { scopePrefix?: string }): any {
-  const scopePrefix = parameters?.scopePrefix ?? "#";
-  return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.alias.unsafeCoerce())}", type: "Group" };
-}`);
-}
-//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionDeclaration.js.map

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

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

@@ -1,12 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_schemaVariableStatement() {
-    if (!this.configuration.features.has("Object.schema")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export const schema = { properties: { ${joinCode(this.properties.flatMap((property) => property.schema
-        .toList()
-        .map((propertySchema) => code `${property.name}: ${propertySchema}`)), { on: ", " })} } } as const;`);
-}
-//# sourceMappingURL=ObjectType_schemaVariableStatement.js.map

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

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

@@ -1,20 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toJsonFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.toJson")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export function toJson(${this.thisVariable}: ${this.expression}): ${this.jsonType().expression} {
-  return JSON.parse(JSON.stringify({ ${joinCode(this.properties.flatMap((property) => property
-        .toJsonInitializer({
-        variables: {
-            value: property.accessExpression({
-                variables: { object: this.thisVariable },
-            }),
-        },
-    })
-        .toList()), { on: "," })} } satisfies ${this.jsonType().expression}));
-}`);
-}
-//# sourceMappingURL=ObjectType_toJsonFunctionDeclaration.js.map

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

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

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

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

@@ -1,29 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toStringFunctionDeclarations() {
-    if (!this.configuration.features.has("Object.toString")) {
-        return [];
-    }
-    const propertiesToStringsReturnExpression = code `${this.reusables.snippets.compactRecord}({${joinCode(this.properties.flatMap((property) => property
-        .toStringInitializer({
-        variables: {
-            value: property.accessExpression({
-                variables: { object: this.thisVariable },
-            }),
-        },
-    })
-        .toList()), { on: "," })}})`;
-    const toStringReturnExpression = (propertiesToStrings) => code `\`${this.alias.unsafeCoerce()}(\${JSON.stringify(${propertiesToStrings})})\``;
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    return [
-        // Use overloads to allow the function to be attached to an instance or used freestanding
-        code `\
-export function _propertiesToStrings(${this.thisVariable}: ${this.expression}): Record<string, string> {
-  return ${propertiesToStringsReturnExpression};
-}`,
-        code `\
-export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.expression}): string {
-  return ${toStringReturnExpression(code `_propertiesToStrings(${this.thisVariable})`)};
-}`,
-    ];
-}
-//# sourceMappingURL=ObjectType_toStringFunctionDeclarations.js.map

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

@@ -1,11 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
-  ${this.alias.unsafeCoerce()}.focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
-}
-//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map

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

@@ -1,13 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_valueSparqlWherePatternsFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
-  (propertyPatterns as readonly ${this.reusables.snippets.SparqlPattern}[]).concat(
-    ${this.alias.unsafeCoerce()}.focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
-  );`);
-}
-//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/_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 identifierTypeDeclarations(this: ObjectType): readonly Code[];
-//# sourceMappingURL=identifierTypeDeclarations.d.ts.map

package/dist/generators/ts/_snippets/snippets_LazyObject.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_LazyObject: SnippetFactory;
-//# sourceMappingURL=snippets_LazyObject.d.ts.map

package/dist/generators/ts/_snippets/snippets_LazyObject.js

@@ -1,22 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_LazyObject = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LazyObject`, code `\
-/**
- * Type of lazy properties that return a single required object. This is a class instead of an interface so it can be instanceof'd elsewhere.
- */
-export class ${syntheticNamePrefix}LazyObject<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }> {
-  readonly partial: PartialObjectT;
-  private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
-
-  constructor({ partial, resolver }: {
-    partial: PartialObjectT
-    resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
-  }) {
-    this.partial = partial;
-    this.resolver = resolver;
-  }
-
-  resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ResolvedObjectT>> {
-    return this.resolver(this.partial.${syntheticNamePrefix}identifier(), options);
-  }
-}`);
-//# sourceMappingURL=snippets_LazyObject.js.map

package/dist/generators/ts/_snippets/snippets_LazyObjectOption.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_LazyObjectOption: SnippetFactory;
-//# sourceMappingURL=snippets_LazyObjectOption.d.ts.map