@shaclmate/compiler 4.0.38 → 4.0.39

package/dist/ast/LiteralType.d.ts

@@ -3,7 +3,7 @@ import type { Maybe } from "purify-ts";
 import { AbstractTermType } from "./AbstractTermType.js";
 export declare class LiteralType extends AbstractTermType<Literal, Literal> {
     readonly datatype: Maybe<NamedNode>;
-    readonly kind = "LiteralType";
+    readonly kind = "Literal";
     readonly nodeKinds: ReadonlySet<"Literal">;
     readonly languageIn: readonly string[];
     readonly maxExclusive: Maybe<Literal>;

package/dist/ast/LiteralType.js

@@ -2,7 +2,7 @@ import { AbstractTermType } from "./AbstractTermType.js";
 import { arrayEquals, maybeEquals, strictEquals, termEquals, } from "./equals.js";
 export class LiteralType extends AbstractTermType {
     datatype;
-    kind = "LiteralType";
+    kind = "Literal";
     nodeKinds = nodeKinds;
     languageIn;
     maxExclusive;

package/dist/ast/ObjectCompoundType.js

@@ -54,11 +54,11 @@ export var ObjectCompoundType;
         const memberObjectTypes_ = [];
         for (const member of objectCompoundType.members) {
             switch (member.type.kind) {
-                case "ObjectType":
+                case "Object":
                     memberObjectTypes_.push(member.type);
                     break;
-                case "IntersectionType":
-                case "UnionType": {
+                case "Intersection":
+                case "Union": {
                     invariant(member.type.kind === objectCompoundType.kind);
                     memberObjectTypes_.push(...memberObjectTypes(member.type));
                     break;

package/dist/ast/ObjectType.d.ts

@@ -29,7 +29,7 @@ export declare class ObjectType extends AbstractType {
     /**
      * Type discriminant.
      */
-    readonly kind = "ObjectType";
+    readonly kind = "Object";
     readonly nodeKinds: ReadonlySet<NodeKind>;
     /**
      * Was this type synthesized or did it come from SHACL?

package/dist/ast/ObjectType.js

@@ -63,7 +63,7 @@ export class ObjectType extends AbstractType {
     /**
      * Type discriminant.
      */
-    kind = "ObjectType";
+    kind = "Object";
     nodeKinds = nodeKinds;
     /**
      * Was this type synthesized or did it come from SHACL?
@@ -271,15 +271,15 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                 invariant(propertyType.length > 0);
                 const currentPropertyType = propertyType.at(-1);
                 switch (currentPropertyType.kind) {
-                    case "BlankNodeType":
-                    case "IdentifierType":
-                    case "IriType":
-                    case "LiteralType":
-                    case "TermType":
+                    case "BlankNode":
+                    case "Identifier":
+                    case "Iri":
+                    case "Literal":
+                    case "Term":
                         return false;
-                    case "LazyObjectOptionType":
-                    case "LazyObjectSetType":
-                    case "LazyObjectType": {
+                    case "LazyObjectOption":
+                    case "LazyObjectSet":
+                    case "LazyObject": {
                         if (helper(stack.concat({
                             objectType,
                             property,
@@ -296,7 +296,7 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                         }
                         return false;
                     }
-                    case "ObjectType": {
+                    case "Object": {
                         if (DEBUG) {
                             process.stderr.write(`recurse into ${currentPropertyType}`);
                         }
@@ -310,8 +310,8 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                         }
                         return false;
                     }
-                    case "IntersectionType":
-                    case "UnionType": {
+                    case "Intersection":
+                    case "Union": {
                         if (DEBUG) {
                             process.stderr.write(`recurse into ${currentPropertyType}`);
                         }
@@ -326,10 +326,10 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                         }
                         return false;
                     }
-                    case "DefaultValueType":
-                    case "ListType":
-                    case "OptionType":
-                    case "SetType":
+                    case "DefaultValue":
+                    case "List":
+                    case "Option":
+                    case "Set":
                         return helper(stack.concat({
                             objectType,
                             property,

package/dist/ast/OptionType.d.ts

@@ -3,7 +3,7 @@ import { AbstractContainerType } from "./AbstractContainerType.js";
  * A type with zero or one values of an item type.
  */
 export declare class OptionType<ItemTypeT extends OptionType.ItemType = OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
-    readonly kind = "OptionType";
+    readonly kind = "Option";
     constructor({ itemType, }: Pick<ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0], "itemType">);
 }
 export declare namespace OptionType {

package/dist/ast/OptionType.js

@@ -3,7 +3,7 @@ import { AbstractContainerType } from "./AbstractContainerType.js";
  * A type with zero or one values of an item type.
  */
 export class OptionType extends AbstractContainerType {
-    kind = "OptionType";
+    kind = "Option";
     constructor({ itemType, }) {
         super({
             comment: itemType.comment,

package/dist/ast/SetType.d.ts

@@ -3,7 +3,7 @@ import { AbstractCollectionType } from "./AbstractCollectionType.js";
  * An unordered set of items of a specific type.
  */
 export declare class SetType<ItemTypeT extends SetType.ItemType = SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
-    readonly kind = "SetType";
+    readonly kind = "Set";
     /**
      * Minimum number of items in the set.
      */

package/dist/ast/SetType.js

@@ -3,7 +3,7 @@ import { AbstractCollectionType } from "./AbstractCollectionType.js";
  * An unordered set of items of a specific type.
  */
 export class SetType extends AbstractCollectionType {
-    kind = "SetType";
+    kind = "Set";
     /**
      * Minimum number of items in the set.
      */

package/dist/ast/TermType.d.ts

@@ -5,7 +5,7 @@ import { AbstractTermType } from "./AbstractTermType.js";
  * Term type that is neither an IdentifierType nor a LiteralType. For example, a term type with nodeKinds = Literal | NamedNode.
  */
 export declare class TermType extends AbstractTermType<Literal | NamedNode, BlankNode | Literal | NamedNode> {
-    readonly kind = "TermType";
+    readonly kind = "Term";
     readonly nodeKinds: ReadonlySet<NodeKind>;
     constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<Literal | NamedNode, BlankNode | Literal | NamedNode>>[0] & {
         nodeKinds: ReadonlySet<NodeKind>;

package/dist/ast/TermType.js

@@ -4,7 +4,7 @@ import { AbstractTermType } from "./AbstractTermType.js";
  * Term type that is neither an IdentifierType nor a LiteralType. For example, a term type with nodeKinds = Literal | NamedNode.
  */
 export class TermType extends AbstractTermType {
-    kind = "TermType";
+    kind = "Term";
     nodeKinds;
     constructor({ nodeKinds, ...superParameters }) {
         super(superParameters);

package/dist/ast/Type.js

@@ -5,35 +5,35 @@ export var Type;
             return false;
         }
         switch (left.kind) {
-            case "BlankNodeType":
+            case "BlankNode":
                 return left.equals(right);
-            case "DefaultValueType":
+            case "DefaultValue":
                 return left.equals(right);
-            case "IdentifierType":
+            case "Identifier":
                 return left.equals(right);
-            case "IntersectionType":
+            case "Intersection":
                 return left.equals(right);
-            case "IriType":
+            case "Iri":
                 return left.equals(right);
-            case "LiteralType":
+            case "Literal":
                 return left.equals(right);
-            case "LazyObjectOptionType":
+            case "LazyObjectOption":
                 return left.equals(right);
-            case "LazyObjectSetType":
+            case "LazyObjectSet":
                 return left.equals(right);
-            case "LazyObjectType":
+            case "LazyObject":
                 return left.equals(right);
-            case "ListType":
+            case "List":
                 return left.equals(right);
-            case "ObjectType":
+            case "Object":
                 return left.equals(right);
-            case "OptionType":
+            case "Option":
                 return left.equals(right);
-            case "TermType":
+            case "Term":
                 return left.equals(right);
-            case "UnionType":
+            case "Union":
                 return left.equals(right);
-            case "SetType":
+            case "Set":
                 return left.equals(right);
         }
     }

package/dist/ast/UnionType.d.ts

@@ -5,7 +5,7 @@ import type { ObjectUnionType } from "./ObjectUnionType.js";
  * A disjunction/union of types, corresponding to an sh:xone.
  */
 export declare class UnionType<MemberTypeT extends UnionType.MemberType = UnionType.MemberType> extends AbstractCompoundType<UnionType.Member<MemberTypeT>, MemberTypeT> {
-    readonly kind = "UnionType";
+    readonly kind = "Union";
     isObjectUnionType(): this is ObjectUnionType;
     toJSON(): {
         members: {

package/dist/ast/UnionType.js

@@ -3,11 +3,11 @@ import { AbstractCompoundType } from "./AbstractCompoundType.js";
  * A disjunction/union of types, corresponding to an sh:xone.
  */
 export class UnionType extends AbstractCompoundType {
-    kind = "UnionType";
+    kind = "Union";
     isObjectUnionType() {
         return (this.members.length > 0 &&
-            this.members.every((member) => member.type.kind === "ObjectType" ||
-                (member.type.kind === "UnionType" && member.type.isObjectUnionType())));
+            this.members.every((member) => member.type.kind === "Object" ||
+                (member.type.kind === "Union" && member.type.isObjectUnionType())));
     }
     toJSON() {
         return {

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -10,17 +10,17 @@ export function transformAstToLabeledPropertyGraph(ast) {
         for (const namedObjectTypeProperty of namedObjectType.properties) {
             let itemType;
             switch (namedObjectTypeProperty.type.kind) {
-                case "DefaultValueType":
-                case "ListType":
-                case "OptionType":
-                case "SetType":
+                case "DefaultValue":
+                case "List":
+                case "Option":
+                case "Set":
                     itemType = namedObjectTypeProperty.type.itemType;
                     break;
-                case "LazyObjectType":
+                case "LazyObject":
                     itemType = namedObjectTypeProperty.type.resolveType;
                     break;
-                case "LazyObjectOptionType":
-                case "LazyObjectSetType":
+                case "LazyObjectOption":
+                case "LazyObjectSet":
                     itemType = namedObjectTypeProperty.type.resolveType.itemType;
                     break;
                 default:
@@ -28,9 +28,9 @@ export function transformAstToLabeledPropertyGraph(ast) {
                     break;
             }
             switch (itemType.kind) {
-                case "IntersectionType":
-                case "ObjectType":
-                case "UnionType":
+                case "Intersection":
+                case "Object":
+                case "Union":
                     if (itemType.name.isJust()) {
                         relationships.push({
                             id: namedObjectTypeProperty.shapeIdentifier.toString(),

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -25,11 +25,7 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     get name(): Code;
     get schemaType(): Code;
     get validationFunction(): Maybe<Code>;
-    protected get schemaObject(): {
-        minCount: number | undefined;
-        item: Code;
-        kind: Code;
-    };
+    protected get schemaInitializers(): readonly Code[];
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/AbstractCollectionType.js

@@ -73,11 +73,12 @@ export class AbstractCollectionType extends AbstractContainerType {
     get validationFunction() {
         return Maybe.of(code `${this.reusables.snippets.validateArray}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)}, ${literalOf(!this._mutable)})`);
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            minCount: this.minCount > 0n ? Number(this.minCount) : undefined,
-        };
+    get schemaInitializers() {
+        let schemaInitializers = super.schemaInitializers;
+        if (this.minCount > 0n) {
+            schemaInitializers = schemaInitializers.concat(code `minCount: ${Number(this.minCount)}`);
+        }
+        return schemaInitializers;
     }
     fromJsonExpression({ variables, }) {
         let expression = variables.value;

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -25,7 +25,7 @@ import { type Code } from "./ts-poet-wrapper.js";
  */
 export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType> extends AbstractType {
     readonly declaration: Maybe<Code>;
-    abstract readonly kind: "DefaultValueType" | "ListType" | "OptionType" | "SetType";
+    abstract readonly kind: "DefaultValue" | "List" | "Option" | "Set";
     /**
      * Container item type.
      *
@@ -36,14 +36,11 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
         itemType: ItemTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get recursive(): boolean;
-    get schema(): Code;
+    get referencesObjectType(): boolean;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     protected get itemConversionFunctionDefault(): AbstractType.ConversionFunction;
     protected get itemValidationFunctionDefault(): Code;
-    protected get schemaObject(): {
-        item: Code;
-        kind: Code;
-    };
+    protected get schemaInitializers(): readonly Code[];
 }
 export declare namespace AbstractContainerType {
     type ConversionFunction = AbstractType.ConversionFunction;

package/dist/generators/ts/AbstractContainerType.js

@@ -7,7 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
-import { removeUndefined } from "./removeUndefined.js";
 import { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
@@ -27,8 +26,8 @@ export class AbstractContainerType extends AbstractType {
     get recursive() {
         return this.itemType.recursive;
     }
-    get schema() {
-        return code `${removeUndefined(this.schemaObject)}`;
+    get referencesObjectType() {
+        return this.itemType.referencesObjectType;
     }
     get toRdfResourceValueTypes() {
         return this.itemType.toRdfResourceValueTypes;
@@ -47,16 +46,17 @@ export class AbstractContainerType extends AbstractType {
     get itemValidationFunctionDefault() {
         return code `${this.reusables.snippets.identityValidationFunction}`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            item: code `() => (${this.itemType.schema})`,
-        };
+    get schemaInitializers() {
+        const initializers = super.schemaInitializers.concat();
+        if (this.recursive || this.itemType.referencesObjectType) {
+            initializers.push(code `get itemType() { return ${this.itemType.schema}; }`);
+        }
+        else {
+            initializers.push(code `itemType: ${this.itemType.schema}`);
+        }
+        return initializers;
     }
 }
-__decorate([
-    Memoize()
-], AbstractContainerType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], AbstractContainerType.prototype, "itemConversionFunctionDefault", null);
@@ -67,31 +67,31 @@ __decorate([
     AbstractContainerType.GraphqlType = AbstractType.GraphqlType;
     function isItemType(type) {
         switch (type.kind) {
-            case "AnonymousUnionType":
-            case "BigDecimalType":
-            case "BigIntType":
-            case "BlankNodeType":
-            case "BooleanType":
-            case "DateTimeType":
-            case "DateType":
-            case "FloatType":
-            case "IdentifierType":
-            case "IntType":
-            case "IriType":
-            case "ListType":
-            case "LiteralType":
-            case "NamedObjectUnionType":
-            case "NamedUnionType":
+            case "AnonymousUnion":
+            case "BigDecimal":
+            case "BigInt":
+            case "BlankNode":
+            case "Boolean":
+            case "DateTime":
+            case "Date":
+            case "Float":
+            case "Identifier":
+            case "Int":
+            case "Iri":
+            case "List":
+            case "Literal":
+            case "NamedObjectUnion":
+            case "NamedUnion":
             case "NamedObjectType":
-            case "StringType":
-            case "TermType":
+            case "String":
+            case "Term":
                 return true;
-            case "DefaultValueType":
-            case "LazyObjectOptionType":
-            case "LazyObjectSetType":
-            case "LazyObjectType":
-            case "OptionType":
-            case "SetType":
+            case "DefaultValue":
+            case "LazyObjectOption":
+            case "LazyObjectSet":
+            case "LazyObject":
+            case "Option":
+            case "Set":
                 return false;
         }
     }

package/dist/generators/ts/AbstractDateType.d.ts

@@ -4,7 +4,7 @@ export declare abstract class AbstractDateType extends AbstractPrimitiveType<Dat
     readonly equalsFunction: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
-    abstract readonly kind: "DateTimeType" | "DateType";
+    abstract readonly kind: "DateTime" | "Date";
     readonly mutable = false;
     readonly name = "Date";
     readonly schemaType: Code;

package/dist/generators/ts/AbstractIdentifierType.d.ts

@@ -3,7 +3,7 @@ import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNode | NamedNode> extends AbstractTermType<NamedNode, IdentifierT> {
-    abstract readonly kind: "BlankNodeType" | "IdentifierType" | "IriType";
+    abstract readonly kind: "BlankNode" | "Identifier" | "Iri";
     abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     abstract readonly parseFunction: Code;
     readonly stringifyFunction: Code;

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -16,6 +16,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     readonly declaration: Maybe<Code>;
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;
+    readonly referencesObjectType = true;
     readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;
     constructor({ partialType, resolveType, ...superParameters }: {
@@ -23,27 +24,27 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         resolveType: ResolveTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get equalsFunction(): Code;
-    get hashFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractType.GraphqlType;
+    get hashFunction(): Code;
     get name(): Code;
     get recursive(): boolean;
-    get schema(): Code;
+    protected get schemaInitializers(): readonly Code[];
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
-    protected get schemaObject(): {
-        partial: Code;
-        kind: Code;
-    };
     jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    protected resolveToPartialFunction<ObjectTypeT extends AbstractLazyObjectType.ObjectTypeConstraint>({ partialType, resolveType, }: {
+        partialType: ObjectTypeT;
+        resolveType: ObjectTypeT;
+    }): Code;
     protected resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }: {
         resolvedNamedObjectUnionType: NamedObjectUnionType;
         partialNamedObjectUnionType: NamedObjectUnionType;
@@ -51,10 +52,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
             resolvedObjectUnion: Code;
         };
     }): Code;
-    protected resolveToPartialFunction<ObjectTypeT extends AbstractLazyObjectType.ObjectTypeConstraint>({ partialType, resolveType, }: {
-        partialType: ObjectTypeT;
-        resolveType: ObjectTypeT;
-    }): Code;
 }
 export declare namespace AbstractLazyObjectType {
     type ObjectTypeConstraint = NamedObjectType | NamedObjectUnionType;