@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/generators/ts/SnippetDeclarations.js

@@ -1,367 +0,0 @@
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-export var SnippetDeclarations;
-(function (SnippetDeclarations) {
-    SnippetDeclarations.arrayEquals = `\
-/**
- * Compare two arrays element-wise with the provided elementEquals function.
- */  
-export function ${syntheticNamePrefix}arrayEquals<T>(
-  leftArray: readonly T[],
-  rightArray: readonly T[],
-  elementEquals: (left: T, right: T) => boolean | ${syntheticNamePrefix}EqualsResult,
-): ${syntheticNamePrefix}EqualsResult {
-  if (leftArray.length !== rightArray.length) {
-    return purify.Left({
-      left: leftArray,
-      right: rightArray,
-      type: "ArrayLength",
-    });
-  }
-
-  for (
-    let leftElementIndex = 0;
-    leftElementIndex < leftArray.length;
-    leftElementIndex++
-  ) {
-    const leftElement = leftArray[leftElementIndex];
-
-    const rightUnequals: ${syntheticNamePrefix}EqualsResult.Unequal[] = [];
-    for (
-      let rightElementIndex = 0;
-      rightElementIndex < rightArray.length;
-      rightElementIndex++
-    ) {
-      const rightElement = rightArray[rightElementIndex];
-
-      const leftElementEqualsRightElement =
-        ${syntheticNamePrefix}EqualsResult.fromBooleanEqualsResult(
-          leftElement,
-          rightElement,
-          elementEquals(leftElement, rightElement),
-        );
-      if (leftElementEqualsRightElement.isRight()) {
-        break; // left element === right element, break out of the right iteration
-      }
-      rightUnequals.push(
-        leftElementEqualsRightElement.extract() as ${syntheticNamePrefix}EqualsResult.Unequal,
-      );
-    }
-
-    if (rightUnequals.length === rightArray.length) {
-      // All right elements were unequal to the left element
-      return purify.Left({
-        left: {
-          array: leftArray,
-          element: leftElement,
-          elementIndex: leftElementIndex,
-        },
-        right: {
-          array: rightArray,
-          unequals: rightUnequals,
-        },
-        type: "ArrayElement",
-      });
-    }
-    // Else there was a right element equal to the left element, continue to the next left element
-  }
-
-  return ${syntheticNamePrefix}EqualsResult.Equal;
-}
-`;
-    SnippetDeclarations.arrayIntersection = `\
-export function ${syntheticNamePrefix}arrayIntersection<T>(left: readonly T[], right: readonly T[]): readonly T[] {
-  if (left.length === 0) {
-    return right;
-  }
-  if (right.length === 0) {
-    return left;
-  }
-
-  const intersection = new Set<T>();
-  if (left.length <= right.length) {
-    const rightSet = new Set(right);
-    for (const leftElement of left) {
-      if (rightSet.has(leftElement)) {
-        intersection.add(leftElement);
-      }
-    }
-  } else {
-    const leftSet = new Set(left);
-    for (const rightElement of right) {
-      if (leftSet.has(rightElement)) {
-        intersection.add(rightElement);
-      }  
-    }
-  }
-  return [...intersection];
-}`;
-    SnippetDeclarations.booleanEquals = `\
-/**
- * Compare two objects with equals(other: T): boolean methods and return an ${syntheticNamePrefix}EqualsResult.
- */
-export function ${syntheticNamePrefix}booleanEquals<T extends { equals: (other: T) => boolean }>(
-  left: T,
-  right: T,
-): ${syntheticNamePrefix}EqualsResult {
-  return ${syntheticNamePrefix}EqualsResult.fromBooleanEqualsResult(
-    left,
-    right,
-    left.equals(right),
-  );
-}`;
-    SnippetDeclarations.dateEquals = `\
-/**
- * Compare two Dates and return an ${syntheticNamePrefix}EqualsResult.
- */
-export function ${syntheticNamePrefix}dateEquals(left: Date, right: Date): ${syntheticNamePrefix}EqualsResult {
-  return ${syntheticNamePrefix}EqualsResult.fromBooleanEqualsResult(
-    left,
-    right,
-    left.getTime() === right.getTime(),
-  );
-}`;
-    SnippetDeclarations.EqualsResult = `\
-export type ${syntheticNamePrefix}EqualsResult = purify.Either<${syntheticNamePrefix}EqualsResult.Unequal, true>;
-
-export namespace ${syntheticNamePrefix}EqualsResult {
-  export const Equal: ${syntheticNamePrefix}EqualsResult = purify.Either.of<Unequal, true>(true);
-
-  export function fromBooleanEqualsResult(
-    left: any,
-    right: any,
-    equalsResult: boolean | ${syntheticNamePrefix}EqualsResult,
-  ): ${syntheticNamePrefix}EqualsResult {
-    if (typeof equalsResult !== "boolean") {
-      return equalsResult;
-    }
-
-    if (equalsResult) {
-      return Equal;
-    }
-
-    return purify.Left({ left, right, type: "BooleanEquals" });
-  }
-
-  export type Unequal =
-  | {
-    readonly left: {
-      readonly array: readonly any[];
-      readonly element: any;
-      readonly elementIndex: number;
-    };
-    readonly right: {
-      readonly array: readonly any[];
-      readonly unequals: readonly Unequal[];
-    };
-    readonly type: "ArrayElement";
-  }
-  | {
-    readonly left: readonly any[];
-    readonly right: readonly any[];
-    readonly type: "ArrayLength";
-  }
-  | {
-    readonly left: any;
-    readonly right: any;
-    readonly type: "BooleanEquals";
-  }
-  | {
-    readonly left: any;
-    readonly right: any;
-    readonly type: "LeftError";
-  }
-  | {
-    readonly right: any;
-    readonly type: "LeftNull";
-  }
-  | {
-    readonly left: bigint | boolean | number | string;
-    readonly right: bigint | boolean | number | string;
-    readonly type: "Primitive";
-  }
-  | {
-    readonly left: any;
-    readonly right: any;
-    readonly propertyName: string;
-    readonly propertyValuesUnequal: Unequal;
-    readonly type: "Property";
-  }
-  | {
-    readonly left: any;
-    readonly right: any;
-    readonly type: "RightError";
-  }
-  | {
-    readonly left: any;
-    readonly type: "RightNull";
-  };
-}    
-`;
-    SnippetDeclarations.maybeEquals = `\
-export function ${syntheticNamePrefix}maybeEquals<T>(
-  leftMaybe: purify.Maybe<T>,
-  rightMaybe: purify.Maybe<T>,
-  valueEquals: (left: T, right: T) => boolean | ${syntheticNamePrefix}EqualsResult,
-): ${syntheticNamePrefix}EqualsResult {
-  if (leftMaybe.isJust()) {
-    if (rightMaybe.isJust()) {
-      return ${syntheticNamePrefix}EqualsResult.fromBooleanEqualsResult(
-        leftMaybe,
-        rightMaybe,
-        valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),
-      );
-    }
-    return purify.Left({
-      left: leftMaybe.unsafeCoerce(),
-      type: "RightNull",
-    });
-  }
-
-  if (rightMaybe.isJust()) {
-    return purify.Left({
-      right: rightMaybe.unsafeCoerce(),
-      type: "LeftNull",
-    });
-  }
-
-  return ${syntheticNamePrefix}EqualsResult.Equal;
-}`;
-    SnippetDeclarations.LazyObjectSet = `\
-/**
- * Type of lazy properties that return a set of objects. This is a class instead of an interface so it can be instanceof'd elsewhere.
- */
-export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, StubObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
-  private readonly resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>;
-  readonly stubs: readonly StubObjectT[];
-
-  constructor({ resolver, stubs }: {
-    resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>,
-    stubs: readonly StubObjectT[]
-  }) {
-    this.resolver = resolver;
-    this.stubs = stubs;
-  }
-
-  async resolve(options?: { limit?: number; offset?: number }): Promise<purify.Either<Error, readonly ResolvedObjectT[]>> {
-    if (this.stubs.length === 0) {
-      return purify.Either.of([]);
-    }
-
-    const limit = options?.limit ?? Number.MAX_SAFE_INTEGER;
-    if (limit <= 0) {
-      return purify.Either.of([]);
-    }
-
-    let offset = options?.offset ?? 0;
-    if (offset < 0) {
-      offset = 0;
-    }
-
-    return await this.resolver(this.stubs.slice(offset, offset + limit).map(stub => stub.${syntheticNamePrefix}identifier));
-  }
-}`;
-    SnippetDeclarations.LazyOptionalObject = `\
-/**
- * Type of lazy properties that return a single optional object. This is a class instead of an interface so it can be instanceof'd elsewhere.
- */
-export class ${syntheticNamePrefix}LazyOptionalObject<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, StubObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
-  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>;
-  readonly stub: purify.Maybe<StubObjectT>;
-
-  constructor({ resolver, stub }: {
-    resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>,
-    stub: purify.Maybe<StubObjectT>
-  }) {
-    this.resolver = resolver;
-    this.stub = stub;
-  }
-
-  async resolve(): Promise<purify.Either<Error, purify.Maybe<ResolvedObjectT>>> {
-    if (this.stub.isNothing()) {
-      return purify.Either.of(purify.Maybe.empty());
-    }
-    return (await this.resolver(this.stub.unsafeCoerce().${syntheticNamePrefix}identifier)).map(purify.Maybe.of);
-  }
-}`;
-    SnippetDeclarations.LazyRequiredObject = `\
-/**
- * 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}LazyRequiredObject<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, StubObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
-  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>;
-  readonly stub: StubObjectT;
-
-  constructor({ resolver, stub }: {
-    resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>,
-    stub: StubObjectT
-  }) {
-    this.resolver = resolver;
-    this.stub = stub;
-  }
-
-  resolve(): Promise<purify.Either<Error, ResolvedObjectT>> {
-    return this.resolver(this.stub.${syntheticNamePrefix}identifier);
-  }
-}`;
-    SnippetDeclarations.RdfVocabularies = `\
-export namespace ${syntheticNamePrefix}RdfVocabularies {
-  export namespace rdf {
-    export const first = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first");
-    export const nil = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil");
-    export const rest = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest");
-    export const subject = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject");
-    export const type = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
-  }
-
-  export namespace rdfs {
-    export const subClassOf = dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf");
-  }
-
-  export namespace xsd {
-    export const boolean = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean");
-    export const date = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#date");
-    export const dateTime = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTime");
-    export const integer = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer");
-  }
-}`;
-    SnippetDeclarations.sparqlInstancesOfPattern = `\
-/**
- * A sparqljs.Pattern that's the equivalent of ?subject rdf:type/rdfs:subClassOf* ?rdfType .
- */
-export function ${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType, subject }: { rdfType: rdfjs.NamedNode | rdfjs.Variable, subject: sparqljs.Triple["subject"] }): sparqljs.Pattern {
-  return {
-    triples: [
-      {
-        subject,
-        predicate: {
-          items: [
-            $RdfVocabularies.rdf.type,
-            {
-              items: [$RdfVocabularies.rdfs.subClassOf],
-              pathType: "*",
-              type: "path",
-            },
-          ],
-          pathType: "/",
-          type: "path",
-        },
-        object: rdfType,
-      },
-    ],
-    type: "bgp",
-  };
-}`;
-    SnippetDeclarations.strictEquals = `\
-/**
- * Compare two values for strict equality (===), returning an ${syntheticNamePrefix}EqualsResult rather than a boolean.
- */
-export function ${syntheticNamePrefix}strictEquals<T extends bigint | boolean | number | string>(
-  left: T,
-  right: T,
-): ${syntheticNamePrefix}EqualsResult {
-  return ${syntheticNamePrefix}EqualsResult.fromBooleanEqualsResult(left, right, left === right);
-}`;
-    SnippetDeclarations.UnwrapL = `type ${syntheticNamePrefix}UnwrapL<T> = T extends purify.Either<infer L, any> ? L : never`;
-    SnippetDeclarations.UnwrapR = `type ${syntheticNamePrefix}UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never`;
-})(SnippetDeclarations || (SnippetDeclarations = {}));
-//# sourceMappingURL=SnippetDeclarations.js.map

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

@@ -1,12 +0,0 @@
-import type { Type } from "../Type.js";
-import { ShaclProperty } from "./ShaclProperty.js";
-export declare class EagerShaclProperty<TypeT extends Type> extends ShaclProperty<TypeT> {
-    readonly mutable: boolean;
-    readonly recursive: boolean;
-    constructor({ mutable, recursive, ...superParameters }: {
-        mutable: boolean;
-        recursive: boolean;
-    } & ConstructorParameters<typeof ShaclProperty<TypeT>>[0]);
-    get graphqlField(): ShaclProperty<TypeT>["graphqlField"];
-}
-//# sourceMappingURL=EagerShaclProperty.d.ts.map

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

@@ -1,31 +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 { ShaclProperty } from "./ShaclProperty.js";
-export class EagerShaclProperty extends ShaclProperty {
-    mutable;
-    recursive;
-    constructor({ mutable, recursive, ...superParameters }) {
-        super(superParameters);
-        this.mutable = mutable;
-        this.recursive = recursive;
-    }
-    get graphqlField() {
-        return Maybe.of({
-            args: Maybe.empty(),
-            description: this.comment.map(JSON.stringify),
-            name: this.name,
-            resolve: `(source, _args) => ${this.type.graphqlResolveExpression({ variables: { args: "_args", value: `source.${this.name}` } })}`,
-            type: this.type.graphqlName.toString(),
-        });
-    }
-}
-__decorate([
-    Memoize()
-], EagerShaclProperty.prototype, "graphqlField", null);
-//# sourceMappingURL=EagerShaclProperty.js.map

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

@@ -1,100 +0,0 @@
-import { Maybe } from "purify-ts";
-import "ts-morph";
-import type { TsFeature } from "../../../enums/TsFeature.js";
-import { Import } from "../Import.js";
-import type { ObjectType } from "../ObjectType.js";
-import type { ObjectUnionType } from "../ObjectUnionType.js";
-import type { OptionType } from "../OptionType.js";
-import type { SetType } from "../SetType.js";
-import { Type as _Type } from "../Type.js";
-import { ShaclProperty } from "./ShaclProperty.js";
-export declare class LazyShaclProperty<LazyTypeT extends LazyShaclProperty.Type<ResolvedTypeT, StubTypeT>, ResolvedTypeT extends LazyShaclProperty.Type.ResolvedTypeConstraint, StubTypeT extends LazyShaclProperty.Type.StubTypeConstraint> extends ShaclProperty<LazyTypeT> {
-    readonly mutable = false;
-    readonly recursive = false;
-    get graphqlField(): ShaclProperty<LazyShaclProperty.Type<StubTypeT, ResolvedTypeT>>["graphqlField"];
-}
-export declare namespace LazyShaclProperty {
-    export abstract class Type<ResolvedTypeT extends Type.ResolvedTypeConstraint, StubTypeT extends Type.StubTypeConstraint> extends _Type {
-        readonly discriminatorProperty: _Type["discriminatorProperty"];
-        readonly mutable = false;
-        readonly typeof = "object";
-        abstract readonly graphqlArgs: Maybe<Record<string, {
-            type: string;
-        }>>;
-        protected readonly resolvedType: ResolvedTypeT;
-        protected readonly runtimeClass: {
-            readonly name: string;
-            readonly rawName: string;
-            readonly snippetDeclaration: string;
-            readonly stubPropertyName: string;
-        };
-        protected readonly stubType: StubTypeT;
-        constructor({ stubType, resolvedType, runtimeClass, }: {
-            stubType: StubTypeT;
-            resolvedType: ResolvedTypeT;
-            runtimeClass: Type<ResolvedTypeT, StubTypeT>["runtimeClass"];
-        });
-        get conversions(): readonly _Type.Conversion[];
-        get equalsFunction(): string;
-        get graphqlName(): _Type.GraphqlName;
-        hashStatements({ depth, variables, }: Parameters<_Type["hashStatements"]>[0]): readonly string[];
-        get jsonName(): _Type.JsonName;
-        jsonUiSchemaElement(parameters: Parameters<_Type["jsonUiSchemaElement"]>[0]): Maybe<string>;
-        jsonZodSchema(parameters: Parameters<_Type["jsonZodSchema"]>[0]): string;
-        get name(): string;
-        snippetDeclarations(parameters: Parameters<_Type["snippetDeclarations"]>[0]): readonly string[];
-        sparqlConstructTemplateTriples(parameters: Parameters<_Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-        sparqlWherePatterns(parameters: Parameters<_Type["sparqlWherePatterns"]>[0]): readonly string[];
-        toJsonExpression({ variables, }: Parameters<_Type["toJsonExpression"]>[0]): string;
-        toRdfExpression({ variables, }: Parameters<_Type["toRdfExpression"]>[0]): string;
-        useImports(parameters: {
-            features: Set<TsFeature>;
-        }): readonly Import[];
-    }
-    export namespace Type {
-        type ResolvedTypeConstraint = ObjectType | ObjectUnionType | OptionType<ObjectType | ObjectUnionType> | SetType<ObjectType | ObjectUnionType>;
-        type StubTypeConstraint = ResolvedTypeConstraint;
-    }
-    export class ObjectSetType<ResolvedTypeT extends SetType<ObjectType | ObjectUnionType>, StubTypeT extends SetType<ObjectType | ObjectUnionType>> extends Type<ResolvedTypeT, StubTypeT> {
-        constructor({ resolvedType, stubType, }: {
-            resolvedType: ResolvedTypeT;
-            stubType: StubTypeT;
-        });
-        get conversions(): readonly _Type.Conversion[];
-        fromJsonExpression(parameters: Parameters<_Type["fromJsonExpression"]>[0]): string;
-        fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
-        get graphqlArgs(): Maybe<{
-            limit: {
-                type: string;
-            };
-            offset: {
-                type: string;
-            };
-        }>;
-        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
-    }
-    abstract class SingleObjectType<ResolvedTypeT extends Exclude<Type.ResolvedTypeConstraint, SetType<ObjectType | ObjectUnionType>>, StubTypeT extends Exclude<Type.StubTypeConstraint, SetType<ObjectType | ObjectUnionType>>> extends Type<ResolvedTypeT, StubTypeT> {
-        fromJsonExpression(parameters: Parameters<_Type["fromJsonExpression"]>[0]): string;
-        get graphqlArgs(): Type<ResolvedTypeT, ObjectUnionType>["graphqlArgs"];
-        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
-    }
-    export class OptionalObjectType<ResolvedTypeT extends OptionType<ObjectType | ObjectUnionType>, StubTypeT extends OptionType<ObjectType | ObjectUnionType>> extends SingleObjectType<ResolvedTypeT, StubTypeT> {
-        constructor({ resolvedType, stubType, }: {
-            resolvedType: ResolvedTypeT;
-            stubType: StubTypeT;
-        });
-        get conversions(): readonly _Type.Conversion[];
-        fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
-        graphqlResolveExpression(parameters: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
-    }
-    export class RequiredObjectType<ResolvedTypeT extends ObjectType | ObjectUnionType, StubTypeT extends ObjectType | ObjectUnionType> extends SingleObjectType<ResolvedTypeT, StubTypeT> {
-        constructor({ resolvedType, stubType, }: {
-            resolvedType: ResolvedTypeT;
-            stubType: StubTypeT;
-        });
-        get conversions(): readonly _Type.Conversion[];
-        fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
-    }
-    export {};
-}
-//# sourceMappingURL=LazyShaclProperty.d.ts.map