@shaclmate/compiler 4.0.8 → 4.0.9

package/dist/ast/ObjectType.js

@@ -12,12 +12,6 @@ import { AbstractType } from "./AbstractType.js";
 import { arrayEquals } from "./equals.js";
 import { Type } from "./Type.js";
 export class ObjectType extends AbstractType {
-    /**
-     * Classes generated from this type are abstract / cannot be instantiated themselves.
-     *
-     * Defaults to false.
-     */
-    abstract;
     /**
      * Ancestor (parents, their parents, ad nauseum) ObjectTypes of this ObjectType.
      *
@@ -37,11 +31,23 @@ export class ObjectType extends AbstractType {
      */
     #descendantObjectTypes = [];
     /**
-     * Should generated code derived from this ObjectType be visible outside its module?
+     * Immediate parent ObjectTypes of this Object types.
      *
-     * Defaults to true.
+     * Mutable to support cycle-handling logic in the compiler.
      */
-    export;
+    #parentObjectTypes = [];
+    /**
+     * Properties of this ObjectType.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    #properties = [];
+    /**
+     * Classes generated from this type are abstract / cannot be instantiated themselves.
+     *
+     * Defaults to false.
+     */
+    abstract;
     /**
      * If true, the code for this ObjectType is defined externally and should not be generated.
      *
@@ -67,26 +73,6 @@ export class ObjectType extends AbstractType {
      * Type discriminant.
      */
     kind = "ObjectType";
-    /**
-     * Name of this type, from shaclmate:name.
-     */
-    name;
-    /**
-     * Immediate parent ObjectTypes of this Object types.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #parentObjectTypes = [];
-    /**
-     * Properties of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #properties = [];
-    /**
-     * Identifier of the shape this ObjectType was derived from.
-     */
-    shapeIdentifier;
     /**
      * Was this type synthesized or did it come from SHACL?
      */
@@ -115,22 +101,37 @@ export class ObjectType extends AbstractType {
      * Whether to generate a TypeScript class or interface for this type.
      */
     tsObjectDeclarationType;
-    constructor({ abstract, export_, extern, fromRdfType, identifierMintingStrategy, identifierType, name, shapeIdentifier, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }) {
+    constructor({ abstract, extern, fromRdfType, identifierMintingStrategy, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }) {
         super(superParameters);
         this.abstract = abstract;
-        this.export = export_;
         this.extern = extern;
         this.fromRdfType = fromRdfType;
         this.identifierMintingStrategy = identifierMintingStrategy;
         this.identifierType = identifierType;
-        this.name = name;
-        this.shapeIdentifier = shapeIdentifier;
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
         this.tsFeatures = tsFeatures;
         this.tsImports = tsImports;
         this.tsObjectDeclarationType = tsObjectDeclarationType;
     }
+    get ancestorObjectTypes() {
+        return this.#ancestorObjectTypes;
+    }
+    get childObjectTypes() {
+        return this.#childObjectTypes;
+    }
+    get descendantObjectTypes() {
+        return this.#descendantObjectTypes;
+    }
+    get parentObjectTypes() {
+        return this.#parentObjectTypes;
+    }
+    get properties() {
+        return this.#properties;
+    }
+    get recursive() {
+        return this.properties.some((property) => property.recursive);
+    }
     addAncestorObjectTypes(...ancestorObjectTypes) {
         this.#ancestorObjectTypes.push(...ancestorObjectTypes);
     }
@@ -149,21 +150,6 @@ export class ObjectType extends AbstractType {
             invariant(Object.is(property.objectType, this));
         }
     }
-    get ancestorObjectTypes() {
-        return this.#ancestorObjectTypes;
-    }
-    get childObjectTypes() {
-        return this.#childObjectTypes;
-    }
-    get descendantObjectTypes() {
-        return this.#descendantObjectTypes;
-    }
-    get parentObjectTypes() {
-        return this.#parentObjectTypes;
-    }
-    get properties() {
-        return this.#properties;
-    }
     equals(other) {
         // Don't recurse
         return this.shapeIdentifier.equals(other.shapeIdentifier);
@@ -202,14 +188,14 @@ export class ObjectType extends AbstractType {
          * not be mutable.
          */
         mutable;
-        /**
-         * Object type this property belongs to.
-         */
-        objectType;
         /**
          * Name of this property, derived from sh:name or shaclmate:name.
          */
         name;
+        /**
+         * Object type this property belongs to.
+         */
+        objectType;
         /**
          * Relative order of this property, derived from sh:order.
          */
@@ -298,7 +284,6 @@ export class ObjectType extends AbstractType {
                     case "IdentifierType":
                     case "IriType":
                     case "LiteralType":
-                    case "PlaceholderType":
                     case "TermType":
                         return false;
                     case "LazyObjectOptionType":
@@ -339,34 +324,17 @@ export class ObjectType extends AbstractType {
                         if (DEBUG) {
                             process.stderr.write(`recurse into ${currentPropertyType}`);
                         }
-                        for (const memberType of currentPropertyType.memberTypes) {
+                        for (const member of currentPropertyType.members) {
                             if (helper(stack.concat({
                                 objectType,
                                 property,
-                                propertyType: propertyType.concat(memberType),
+                                propertyType: propertyType.concat(member.type),
                             }))) {
                                 return true;
                             }
                         }
                         return false;
                     }
-                    case "ObjectIntersectionType":
-                    case "ObjectUnionType": {
-                        if (DEBUG) {
-                            process.stderr.write(`recurse into ${currentPropertyType}`);
-                        }
-                        for (const memberType of currentPropertyType.memberObjectTypes) {
-                            for (const property of memberType.properties) {
-                                if (helper(stack.concat({
-                                    objectType: memberType,
-                                    property,
-                                }))) {
-                                    return true;
-                                }
-                            }
-                        }
-                        return false;
-                    }
                     case "DefaultValueType":
                     case "ListType":
                     case "OptionType":
@@ -381,7 +349,7 @@ export class ObjectType extends AbstractType {
             return helper([{ objectType: rootObjectType, property: rootProperty }]);
         }
         toString() {
-            return `${this.name.orDefault(Resource.Identifier.toString(this.shapeIdentifier))}(path=${PropertyPath.$toString(this.path)})`;
+            return `${this.name}(path=${PropertyPath.toString(this.path)})`;
         }
     }
     __decorate([

package/dist/ast/ObjectUnionType.d.ts

@@ -1,8 +1,4 @@
-import { AbstractObjectCompoundType } from "./AbstractObjectCompoundType.js";
-/**
- * A disjunction/union of object types, corresponding to an sh:xone on a node shape.
- */
-export declare class ObjectUnionType extends AbstractObjectCompoundType<ObjectUnionType> {
-    readonly kind = "ObjectUnionType";
-}
+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,8 +1,2 @@
-import { AbstractObjectCompoundType } from "./AbstractObjectCompoundType.js";
-/**
- * A disjunction/union of object types, corresponding to an sh:xone on a node shape.
- */
-export class ObjectUnionType extends AbstractObjectCompoundType {
-    kind = "ObjectUnionType";
-}
+export {};
 //# sourceMappingURL=ObjectUnionType.js.map

package/dist/ast/OptionType.d.ts

@@ -1,5 +1,4 @@
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import type { PlaceholderType } from "./PlaceholderType.js";
 /**
  * A type with zero or one values of an item type.
  */
@@ -8,7 +7,7 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType = OptionTy
     constructor({ itemType, }: Pick<ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0], "itemType">);
 }
 export declare namespace OptionType {
-    type ItemType = Exclude<AbstractContainerType.ItemType, PlaceholderType>;
+    type ItemType = AbstractContainerType.ItemType;
     const isItemType: typeof AbstractContainerType.isItemType;
 }
 //# sourceMappingURL=OptionType.d.ts.map

package/dist/ast/OptionType.js

@@ -9,6 +9,8 @@ export class OptionType extends AbstractContainerType {
             comment: itemType.comment,
             itemType,
             label: itemType.label,
+            name: itemType.name,
+            shapeIdentifier: itemType.shapeIdentifier,
         });
     }
 }

package/dist/ast/SetType.d.ts

@@ -1,5 +1,4 @@
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import type { PlaceholderType } from "./PlaceholderType.js";
 /**
  * An unordered set of items of a specific type.
  */
@@ -15,7 +14,7 @@ export declare class SetType<ItemTypeT extends SetType.ItemType = SetType.ItemTy
     equals(other: SetType<ItemTypeT>): boolean;
 }
 export declare namespace SetType {
-    type ItemType = Exclude<AbstractCollectionType.ItemType, PlaceholderType>;
+    type ItemType = AbstractCollectionType.ItemType;
     const isItemType: typeof import("./AbstractContainerType.js").AbstractContainerType.isItemType;
 }
 //# sourceMappingURL=SetType.d.ts.map

package/dist/ast/SetType.js

@@ -14,6 +14,8 @@ export class SetType extends AbstractCollectionType {
             comment: itemType.comment,
             itemType,
             label: itemType.label,
+            name: itemType.name,
+            shapeIdentifier: itemType.shapeIdentifier,
         });
         this.minCount = minCount;
     }

package/dist/ast/Type.d.ts

@@ -8,15 +8,12 @@ import type { LazyObjectSetType } from "./LazyObjectSetType.js";
 import type { LazyObjectType } from "./LazyObjectType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
-import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { OptionType } from "./OptionType.js";
-import type { PlaceholderType } from "./PlaceholderType.js";
 import type { SetType } from "./SetType.js";
 import type { TermType } from "./TermType.js";
 import type { UnionType } from "./UnionType.js";
-export type Type = BlankNodeType | DefaultValueType | IdentifierType | IntersectionType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType | LiteralType | ObjectIntersectionType | ObjectType | ObjectUnionType | OptionType | PlaceholderType | SetType | TermType | UnionType;
+export type Type = BlankNodeType | DefaultValueType | IdentifierType | IntersectionType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType | LiteralType | ObjectType | OptionType | SetType | TermType | UnionType;
 export declare namespace Type {
     function equals(left: Type, right: Type): boolean;
 }

package/dist/ast/Type.js

@@ -25,16 +25,10 @@ export var Type;
                 return left.equals(right);
             case "ListType":
                 return left.equals(right);
-            case "ObjectIntersectionType":
-                return left.equals(right);
             case "ObjectType":
                 return left.equals(right);
-            case "ObjectUnionType":
-                return left.equals(right);
             case "OptionType":
                 return left.equals(right);
-            case "PlaceholderType":
-                return left.equals(right);
             case "TermType":
                 return left.equals(right);
             case "UnionType":

package/dist/ast/UnionType.d.ts

@@ -1,13 +1,18 @@
+import type { Maybe } from "purify-ts";
 import { AbstractCompoundType } from "./AbstractCompoundType.js";
-import type { Type } from "./Type.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
 /**
  * A disjunction/union of types, corresponding to an sh:xone.
  */
-export declare class UnionType extends AbstractCompoundType<Type> {
+export declare class UnionType<MemberTypeT extends UnionType.MemberType = UnionType.MemberType> extends AbstractCompoundType<UnionType.Member<MemberTypeT>, MemberTypeT> {
     readonly kind = "UnionType";
-    readonly memberDiscriminantValues: readonly string[];
-    constructor({ memberDiscriminantValues, ...superParameters }: {
-        memberDiscriminantValues: readonly string[];
-    } & ConstructorParameters<typeof AbstractCompoundType<Type>>[0]);
+    isObjectUnionType(): this is ObjectUnionType;
+}
+export declare namespace UnionType {
+    interface Member<TypeT extends UnionType.MemberType> extends AbstractCompoundType.Member<TypeT> {
+        readonly discriminantValue: Maybe<number | string>;
+    }
+    type MemberType = AbstractCompoundType.MemberType;
+    const isMemberType: typeof AbstractCompoundType.isMemberType;
 }
 //# sourceMappingURL=UnionType.d.ts.map

package/dist/ast/UnionType.js

@@ -4,10 +4,12 @@ import { AbstractCompoundType } from "./AbstractCompoundType.js";
  */
 export class UnionType extends AbstractCompoundType {
     kind = "UnionType";
-    memberDiscriminantValues;
-    constructor({ memberDiscriminantValues, ...superParameters }) {
-        super(superParameters);
-        this.memberDiscriminantValues = memberDiscriminantValues;
+    isObjectUnionType() {
+        return this.members.every((member) => member.type.kind === "ObjectType" ||
+            (member.type.kind === "UnionType" && member.type.isObjectUnionType()));
     }
 }
+(function (UnionType) {
+    UnionType.isMemberType = AbstractCompoundType.isMemberType;
+})(UnionType || (UnionType = {}));
 //# sourceMappingURL=UnionType.js.map

package/dist/ast/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./Ast.js";
 export * from "./BlankNodeType.js";
-export * from "./Curie.js";
 export * from "./DefaultValueType.js";
 export * from "./IdentifierType.js";
 export * from "./IntersectionType.js";
@@ -10,11 +9,11 @@ export * from "./LazyObjectSetType.js";
 export * from "./LazyObjectType.js";
 export * from "./ListType.js";
 export * from "./LiteralType.js";
+export * from "./ObjectCompoundType.js";
 export * from "./ObjectIntersectionType.js";
 export * from "./ObjectType.js";
 export * from "./ObjectUnionType.js";
 export * from "./OptionType.js";
-export * from "./PlaceholderType.js";
 export * from "./SetType.js";
 export * from "./TermType.js";
 export * from "./Type.js";

package/dist/ast/index.js

@@ -1,6 +1,5 @@
 export * from "./Ast.js";
 export * from "./BlankNodeType.js";
-export * from "./Curie.js";
 export * from "./DefaultValueType.js";
 export * from "./IdentifierType.js";
 export * from "./IntersectionType.js";
@@ -10,11 +9,11 @@ export * from "./LazyObjectSetType.js";
 export * from "./LazyObjectType.js";
 export * from "./ListType.js";
 export * from "./LiteralType.js";
+export * from "./ObjectCompoundType.js";
 export * from "./ObjectIntersectionType.js";
 export * from "./ObjectType.js";
 export * from "./ObjectUnionType.js";
 export * from "./OptionType.js";
-export * from "./PlaceholderType.js";
 export * from "./SetType.js";
 export * from "./TermType.js";
 export * from "./Type.js";

package/dist/generators/json/AstJsonGenerator.js

@@ -34,11 +34,13 @@ function typeToJson(type) {
                 nodeKinds: [...type.nodeKinds],
             };
         case "IntersectionType":
-        case "UnionType":
             return {
                 ...common,
-                memberDiscriminantValues: type.kind === "UnionType" ? type.memberDiscriminantValues : undefined,
-                memberTypes: type.memberTypes.map((type) => typeToJson(type)),
+                members: type.members.map((member) => ({
+                    type: typeToJson(member.type),
+                })),
+                name: type.name.extract(),
+                shapeIdentifier: Resource.Identifier.toString(type.shapeIdentifier),
             };
         case "LazyObjectOptionType":
         case "LazyObjectSetType":
@@ -68,14 +70,6 @@ function typeToJson(type) {
                 minInclusive: type.minInclusive.map(termToJson).extract(),
             };
         }
-        case "ObjectIntersectionType":
-        case "ObjectUnionType":
-            return {
-                ...common,
-                name: type.name.extract(),
-                memberTypes: type.memberTypes.map((type) => typeToJson(type)),
-                shapeIdentifier: Resource.Identifier.toString(type.shapeIdentifier),
-            };
         case "ObjectType":
             return {
                 ...common,
@@ -98,8 +92,6 @@ function typeToJson(type) {
                 ...common,
                 itemType: typeToJson(type.itemType),
             };
-        case "PlaceholderType":
-            throw new Error(type.kind);
         case "SetType":
             return {
                 ...common,
@@ -109,6 +101,16 @@ function typeToJson(type) {
             return {
                 ...common,
             };
+        case "UnionType":
+            return {
+                ...common,
+                members: type.members.map((member) => ({
+                    discriminantValue: member.discriminantValue.extract(),
+                    type: typeToJson(member.type),
+                })),
+                name: type.name.extract(),
+                shapeIdentifier: Resource.Identifier.toString(type.shapeIdentifier),
+            };
     }
 }
 export class AstJsonGenerator {
@@ -127,7 +129,7 @@ export class AstJsonGenerator {
                     description: property.description.extract(),
                     label: property.label.extract(),
                     mutable: property.mutable,
-                    name: property.name.extract(),
+                    name: property.name,
                     order: property.order,
                     path: property.path,
                     recursive: property.recursive ? true : undefined,

package/dist/generators/ts/AbstractCollectionType.js

@@ -7,11 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe, NonEmptyList } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { snippets_isReadonlyBigIntArray } from "./_snippets/snippets_isReadonlyBigIntArray.js";
-import { snippets_isReadonlyBooleanArray } from "./_snippets/snippets_isReadonlyBooleanArray.js";
-import { snippets_isReadonlyNumberArray } from "./_snippets/snippets_isReadonlyNumberArray.js";
-import { snippets_isReadonlyObjectArray } from "./_snippets/snippets_isReadonlyObjectArray.js";
-import { snippets_isReadonlyStringArray } from "./_snippets/snippets_isReadonlyStringArray.js";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { codeEquals } from "./codeEquals.js";
 import { imports } from "./imports.js";
@@ -94,15 +89,15 @@ export class AbstractCollectionType extends AbstractContainerType {
                         sourceTypeCheckExpression: (value) => {
                             switch (itemTypeof) {
                                 case "bigint":
-                                    return code `${snippets_isReadonlyBigIntArray}(${value})`;
+                                    return code `${snippets.isReadonlyBigIntArray}(${value})`;
                                 case "boolean":
-                                    return code `${snippets_isReadonlyBooleanArray}(${value})`;
+                                    return code `${snippets.isReadonlyBooleanArray}(${value})`;
                                 case "number":
-                                    return code `${snippets_isReadonlyNumberArray}(${value})`;
+                                    return code `${snippets.isReadonlyNumberArray}(${value})`;
                                 case "object":
-                                    return code `${snippets_isReadonlyObjectArray}(${value})`;
+                                    return code `${snippets.isReadonlyObjectArray}(${value})`;
                                 case "string":
-                                    return code `${snippets_isReadonlyStringArray}(${value})`;
+                                    return code `${snippets.isReadonlyStringArray}(${value})`;
                                 case "function":
                                 case "symbol":
                                 case "undefined":
@@ -165,6 +160,9 @@ export class AbstractCollectionType extends AbstractContainerType {
         if (!this._mutable && this.minCount > 0) {
             expression = code `${imports.NonEmptyList}.fromArray(${expression}).unsafeCoerce()`;
         }
+        if (this.minCount === 0) {
+            expression = code `(${expression} ?? [])`;
+        }
         const valueVariable = code `item`;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
             variables: { value: valueVariable },

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

@@ -1,4 +1,6 @@
+import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
+import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -11,17 +13,19 @@ import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { NamedUnionType } from "./NamedUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
-import type { UnionType } from "./UnionType.js";
 /**
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
 export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType> extends AbstractType {
+    readonly abstract = false;
+    readonly declaration: Maybe<Code>;
     abstract readonly kind: "DefaultValueType" | "ListType" | "OptionType" | "SetType";
     /**
      * Container item type.
@@ -32,6 +36,7 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     constructor({ itemType, ...superParameters }: {
         itemType: ItemTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
+    get recursive(): boolean;
     get schema(): Code;
     protected get schemaObject(): {
         item: Code;
@@ -43,7 +48,7 @@ export declare namespace AbstractContainerType {
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
     const GraphqlType: typeof AbstractType.GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
-    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | LiteralType | ObjectType | ObjectUnionType | StringType | TermType | UnionType;
+    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | LiteralType | NamedObjectUnionType | NamedUnionType | ObjectType | StringType | TermType;
     function isItemType(type: Type): type is ItemType;
     const JsonType: typeof AbstractType.JsonType;
     type JsonType = AbstractType.JsonType;

package/dist/generators/ts/AbstractContainerType.js

@@ -4,6 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { AbstractType } from "./AbstractType.js";
 import { removeUndefined } from "./removeUndefined.js";
@@ -12,6 +13,8 @@ import { code } from "./ts-poet-wrapper.js";
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
 export class AbstractContainerType extends AbstractType {
+    abstract = false;
+    declaration = Maybe.empty();
     /**
      * Container item type.
      *
@@ -22,6 +25,9 @@ export class AbstractContainerType extends AbstractType {
         super(superParameters);
         this.itemType = itemType;
     }
+    get recursive() {
+        return this.itemType.recursive;
+    }
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
@@ -39,6 +45,7 @@ __decorate([
     AbstractContainerType.GraphqlType = AbstractType.GraphqlType;
     function isItemType(type) {
         switch (type.kind) {
+            case "AnonymousUnionType":
             case "BigDecimalType":
             case "BigIntType":
             case "BlankNodeType":
@@ -51,11 +58,11 @@ __decorate([
             case "IriType":
             case "ListType":
             case "LiteralType":
+            case "NamedObjectUnionType":
+            case "NamedUnionType":
             case "ObjectType":
-            case "ObjectUnionType":
             case "StringType":
             case "TermType":
-            case "UnionType":
                 return true;
             case "DefaultValueType":
             case "LazyObjectOptionType":

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

@@ -9,7 +9,7 @@ export declare abstract class AbstractDateType extends AbstractPrimitiveType<Dat
     readonly mutable = false;
     readonly name = "Date";
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     readonly typeofs: NonEmptyList<"object">;
     get conversions(): readonly AbstractPrimitiveType.Conversion[];
     protected get schemaObject(): {
@@ -20,7 +20,7 @@ export declare abstract class AbstractDateType extends AbstractPrimitiveType<Dat
     fromJsonExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromJsonExpression"]>[0]): Code;
     hashStatements({ variables, }: Parameters<AbstractPrimitiveType<Date>["hashStatements"]>[0]): readonly Code[];
     jsonType(): AbstractPrimitiveType.JsonType;
-    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<Date>["fromRdfExpressionChain"]>;
     protected abstract fromRdfResourceValueExpression(variables: {
         variables: {

package/dist/generators/ts/AbstractDateType.js

@@ -17,7 +17,7 @@ export class AbstractDateType extends AbstractPrimitiveType {
     mutable = false;
     name = "Date";
     schemaType = code `${snippets.DateSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.dateSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.dateSparqlWherePatterns}`;
     typeofs = NonEmptyList(["object"]);
     get conversions() {
         return [
@@ -48,7 +48,7 @@ export class AbstractDateType extends AbstractPrimitiveType {
     jsonType() {
         return new AbstractPrimitiveType.JsonType(code `string`);
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${snippets.literalFactory}.date(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {

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

@@ -1,7 +1,7 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
-import { type Code } from "ts-poet";
 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 fromStringFunction: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;