@shaclmate/compiler 4.0.38 → 4.0.40

package/dist/generators/ts/TypeFactory.js

@@ -7,7 +7,6 @@ import { Maybe } from "purify-ts";
 import reservedTsIdentifiers_ from "reserved-identifiers";
 import { invariant } from "ts-invariant";
 import * as ast from "../../ast/index.js";
-import { AnonymousUnionType } from "./AnonymousUnionType.js";
 import { BigDecimalType } from "./BigDecimalType.js";
 import { BigIntType } from "./BigIntType.js";
 import { BlankNodeType } from "./BlankNodeType.js";
@@ -24,19 +23,18 @@ import { LazyObjectSetType } from "./LazyObjectSetType.js";
 import { LazyObjectType } from "./LazyObjectType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
-import { NamedObjectType } from "./NamedObjectType.js";
-import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import { NamedUnionType } from "./NamedUnionType.js";
+import { ObjectType } from "./ObjectType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
 import { OptionType } from "./OptionType.js";
 import { SetType } from "./SetType.js";
 import { StringType } from "./StringType.js";
 import { TermType } from "./TermType.js";
-import { code } from "./ts-poet-wrapper.js";
+import { UnionType } from "./UnionType.js";
 export class TypeFactory {
     configuration;
     logger;
     reusables;
-    cachedNamedObjectUnionTypesByShapeIdentifier = new TermMap();
+    cachedObjectUnionTypesByShapeIdentifier = new TermMap();
     cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
     cachedObjectTypesByShapeIdentifier = new TermMap();
     constructor({ configuration, logger, reusables, }) {
@@ -44,7 +42,7 @@ export class TypeFactory {
         this.logger = logger;
         this.reusables = reusables;
     }
-    createNamedObjectType(astType) {
+    createObjectType(astType) {
         {
             const cachedObjectType = this.cachedObjectTypesByShapeIdentifier.get(astType.shapeIdentifier);
             if (cachedObjectType) {
@@ -52,40 +50,38 @@ export class TypeFactory {
             }
         }
         const identifierType = this.createIdentifierType(astType.identifierType);
-        const name = this.tsName(astType.name.unsafeCoerce(), {
-            synthetic: astType.synthetic,
-        });
-        const namedObjectType = new NamedObjectType({
+        const objectType = new ObjectType({
+            alias: astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic })),
             comment: astType.comment,
             configuration: this.configuration,
             extern: astType.extern,
             fromRdfType: astType.fromRdfType,
             identifierType,
             label: astType.label,
-            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createNamedObjectType(astType)),
-            lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createNamedObjectType(astType)),
-            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createNamedObjectType(astType)),
-            lazyDiscriminantProperty: (namedObjectType) => {
+            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectType(astType)),
+            lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createObjectType(astType)),
+            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectType(astType)),
+            lazyDiscriminantProperty: (objectType) => {
                 // Discriminant property
                 const discriminantDescendantValues = new Set();
-                for (const descendantObjectType of namedObjectType.descendantObjectTypes) {
+                for (const descendantObjectType of objectType.descendantObjectTypes) {
                     discriminantDescendantValues.add(descendantObjectType.discriminantValue);
                 }
-                return new NamedObjectType.DiscriminantProperty({
+                return new ObjectType.DiscriminantProperty({
                     configuration: this.configuration,
                     logger: this.logger,
                     name: `${this.configuration.syntheticNamePrefix}type`,
-                    namedObjectType,
+                    objectType,
                     reusables: this.reusables,
-                    type: new NamedObjectType.DiscriminantProperty.Type({
+                    type: new ObjectType.DiscriminantProperty.Type({
                         descendantValues: [...discriminantDescendantValues].sort(),
                         mutable: false,
-                        ownValues: [namedObjectType.discriminantValue],
+                        ownValues: [objectType.discriminantValue],
                     }),
                 });
             },
-            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createNamedObjectType(astType)),
-            lazyProperties: (namedObjectType) => {
+            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectType(astType)),
+            lazyProperties: (objectType) => {
                 const properties = astType.properties
                     .toSorted((left, right) => {
                     if (left.order < right.order) {
@@ -98,95 +94,93 @@ export class TypeFactory {
                 })
                     .map((astProperty) => this.createObjectTypeProperty({
                     astObjectTypeProperty: astProperty,
-                    namedObjectType,
+                    objectType,
                 }));
-                properties.splice(0, 0, namedObjectType._discriminantProperty);
-                properties.splice(0, 0, new NamedObjectType.IdentifierProperty({
+                properties.splice(0, 0, objectType._discriminantProperty);
+                properties.splice(0, 0, new ObjectType.IdentifierProperty({
                     configuration: this.configuration,
                     logger: this.logger,
                     name: `${this.configuration.syntheticNamePrefix}identifier`,
-                    namedObjectType,
+                    objectType,
                     reusables: this.reusables,
                     type: identifierType,
-                    typeAlias: code `${name}.Identifier`,
                 }));
                 return properties;
             },
             logger: this.logger,
-            name,
             recursive: astType.recursive,
             reusables: this.reusables,
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
         });
-        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectType);
-        return namedObjectType;
+        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
+        return objectType;
     }
-    createNamedObjectUnionType(astType) {
+    createObjectUnionType(astType) {
         {
-            const cachedNamedObjectUnionType = this.cachedNamedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
-            if (cachedNamedObjectUnionType) {
-                return cachedNamedObjectUnionType;
+            const cachedObjectUnionType = this.cachedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedObjectUnionType) {
+                return cachedObjectUnionType;
             }
         }
-        const namedObjectUnionType = new NamedObjectUnionType({
+        const objectUnionType = new ObjectUnionType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
-            identifierType: this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType)),
+            identifierType: Maybe.of(this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType))),
             label: astType.label,
             logger: this.logger,
             members: ast.ObjectCompoundType.memberObjectTypes(astType).map((namedObjectType) => ({
                 discriminantValue: Maybe.empty(),
-                type: this.createNamedObjectType(namedObjectType),
+                type: this.createObjectType(namedObjectType),
             })),
-            name: this.tsName(astType.name.unsafeCoerce()),
             recursive: astType.recursive,
             reusables: this.reusables,
             synthetic: astType.synthetic,
         });
-        this.cachedNamedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectUnionType);
-        return namedObjectUnionType;
+        this.cachedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectUnionType);
+        return objectUnionType;
     }
     createType(astType, parameters) {
         switch (astType.kind) {
-            case "BlankNodeType":
+            case "BlankNode":
                 return this.createBlankNodeType(astType);
-            case "DefaultValueType":
+            case "DefaultValue":
                 return this.createDefaultValueType(astType);
-            case "IdentifierType":
+            case "Identifier":
                 return this.createIdentifierType(astType);
-            case "IntersectionType":
+            case "Intersection":
                 throw new Error("not implemented");
-            case "IriType":
+            case "Iri":
                 return this.createIriType(astType);
-            case "LazyObjectOptionType":
+            case "LazyObjectOption":
                 return this.createLazyObjectOptionType(astType);
-            case "LazyObjectSetType":
+            case "LazyObjectSet":
                 return this.createLazyObjectSetType(astType);
-            case "LazyObjectType":
+            case "LazyObject":
                 return this.createLazyObjectType(astType);
-            case "ListType":
+            case "List":
                 return this.createListType(astType);
-            case "LiteralType":
+            case "Literal":
                 return this.createLiteralType(astType, parameters);
-            case "ObjectType":
-                return this.createNamedObjectType(astType);
-            case "OptionType":
+            case "Object":
+                return this.createObjectType(astType);
+            case "Option":
                 return this.createOptionType(astType);
-            case "SetType":
+            case "Set":
                 return this.createSetType(astType);
-            case "TermType":
+            case "Term":
                 return this.createTermType(astType);
-            case "UnionType":
+            case "Union":
                 return this.createUnionType(astType);
         }
     }
     createUnionType(astType) {
         if (astType.isObjectUnionType()) {
-            return this.createNamedObjectUnionType(astType);
+            return this.createObjectUnionType(astType);
         }
-        return astType.name
-            .map((name) => new NamedUnionType({
+        return new UnionType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             identifierType: Maybe.empty(),
@@ -196,26 +190,14 @@ export class TypeFactory {
                 discriminantValue: member.discriminantValue,
                 type: this.createType(member.type),
             })),
-            name,
             recursive: astType.recursive,
             reusables: this.reusables,
-        }))
-            .orDefaultLazy(() => new AnonymousUnionType({
-            comment: astType.comment,
-            configuration: this.configuration,
-            label: astType.label,
-            identifierType: Maybe.empty(),
-            logger: this.logger,
-            members: astType.members.map((member) => ({
-                discriminantValue: member.discriminantValue,
-                type: this.createType(member.type),
-            })),
-            recursive: astType.recursive,
-            reusables: this.reusables,
-        }));
+            synthetic: astType.synthetic,
+        });
     }
     createBlankNodeType(astType) {
         return new BlankNodeType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
@@ -229,6 +211,7 @@ export class TypeFactory {
         });
         invariant(DefaultValueType.isItemType(itemType));
         return new DefaultValueType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             defaultValue: astType.defaultValue,
@@ -240,22 +223,24 @@ export class TypeFactory {
     }
     createIdentifierType(astType) {
         switch (astType.kind) {
-            case "BlankNodeType":
+            case "BlankNode":
                 return this.createBlankNodeType(astType);
-            case "IdentifierType":
+            case "Identifier":
                 return new IdentifierType({
+                    alias: astType.name.map((name) => this.tsName(name)),
                     comment: astType.comment,
                     configuration: this.configuration,
                     label: astType.label,
                     logger: this.logger,
                     reusables: this.reusables,
                 });
-            case "IriType":
+            case "Iri":
                 return this.createIriType(astType);
         }
     }
     createIriType(astType) {
         return new IriType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,
@@ -267,6 +252,7 @@ export class TypeFactory {
     }
     createLazyObjectOptionType(astType) {
         return new LazyObjectOptionType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
@@ -278,6 +264,7 @@ export class TypeFactory {
     }
     createLazyObjectSetType(astType) {
         return new LazyObjectSetType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
@@ -289,6 +276,7 @@ export class TypeFactory {
     }
     createLazyObjectType(astType) {
         return new LazyObjectType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
@@ -302,6 +290,7 @@ export class TypeFactory {
         const itemType = this.createType(astType.itemType);
         invariant(ListType.isItemType(itemType));
         return new ListType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             identifierNodeKind: astType.identifierNodeKind,
@@ -339,6 +328,7 @@ export class TypeFactory {
                 switch (datatypeDefinition.kind) {
                     case "bigdecimal":
                         return new BigDecimalType({
+                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             hasValues: astType.hasValues,
@@ -350,6 +340,7 @@ export class TypeFactory {
                         });
                     case "bigint":
                         return new BigIntType({
+                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -363,6 +354,7 @@ export class TypeFactory {
                         });
                     case "boolean":
                         return new BooleanType({
+                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -377,6 +369,7 @@ export class TypeFactory {
                     case "date":
                     case "datetime":
                         return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)({
+                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -393,6 +386,7 @@ export class TypeFactory {
                     case "float":
                     case "int":
                         return new (datatypeDefinition.kind === "float" ? FloatType : IntType)({
+                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -409,6 +403,7 @@ export class TypeFactory {
                     case "string":
                         if (!datatype.equals(rdf.langString)) {
                             return new StringType({
+                                alias: astType.name.map((name) => this.tsName(name)),
                                 comment: astType.comment,
                                 configuration: this.configuration,
                                 datatype,
@@ -438,6 +433,7 @@ export class TypeFactory {
         //   // this.logger.debug("literal type has no datatypes");
         // }
         return new LiteralType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,
@@ -448,14 +444,14 @@ export class TypeFactory {
             reusables: this.reusables,
         });
     }
-    createObjectTypeProperty({ astObjectTypeProperty, namedObjectType, }) {
+    createObjectTypeProperty({ astObjectTypeProperty, objectType, }) {
         {
             const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astObjectTypeProperty.shapeIdentifier);
             if (cachedProperty) {
                 return cachedProperty;
             }
         }
-        const property = new NamedObjectType.ShaclProperty({
+        const property = new ObjectType.ShaclProperty({
             comment: astObjectTypeProperty.comment,
             configuration: this.configuration,
             description: astObjectTypeProperty.description,
@@ -463,7 +459,7 @@ export class TypeFactory {
             label: astObjectTypeProperty.label,
             logger: this.logger,
             mutable: astObjectTypeProperty.mutable,
-            namedObjectType,
+            objectType,
             name: this.tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path,
             recursive: !!astObjectTypeProperty.recursive,
@@ -477,6 +473,7 @@ export class TypeFactory {
         const itemType = this.createType(astType.itemType);
         invariant(OptionType.isItemType(itemType));
         return new OptionType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             itemType,
@@ -489,6 +486,7 @@ export class TypeFactory {
         const itemType = this.createType(astType.itemType);
         invariant(SetType.isItemType(itemType));
         return new SetType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             itemType,
@@ -501,6 +499,7 @@ export class TypeFactory {
     }
     createTermType(astType) {
         return new TermType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,

package/dist/generators/ts/{AbstractUnionType.d.ts → UnionType.d.ts}

@@ -6,26 +6,41 @@ import type { IriType } from "./IriType.js";
 import type { Type } from "./Type.js";
 import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractUnionType<MemberTypeT extends Type> extends AbstractType {
+export declare class UnionType<MemberTypeT extends Type> extends AbstractType {
     private readonly discriminant;
-    private readonly identifierType;
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
+    readonly kind: "ObjectUnion" | "Union";
     readonly recursive: boolean;
+    readonly synthetic: boolean;
     readonly validationFunction: Maybe<Code>;
-    constructor({ identifierType, members, recursive, ...superParameters }: {
+    constructor({ identifierType, members, recursive, synthetic, ...superParameters }: {
         identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
         members: readonly (Pick<AbstractUnionType.Member<MemberTypeT>, "type"> & {
             readonly discriminantValue: Maybe<number | string>;
         })[];
         recursive: boolean;
+        synthetic: boolean;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
+    get declaration(): Maybe<Code>;
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractType.GraphqlType;
+    get hashFunction(): Code;
+    get jsonSchemaFunctionDeclaration(): Code;
+    get jsonTypeAliasDeclaration(): Code;
     get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
     get mutable(): boolean;
-    get schema(): Code;
+    get expression(): Code;
+    get referencesObjectType(): boolean;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get typeofs(): AbstractType["typeofs"];
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     protected get inlineEqualsFunction(): Code;
     protected get inlineFilterFunction(): Code;
     protected get inlineFilterType(): Code;
@@ -34,38 +49,48 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     protected get inlineHashFunction(): Code;
     protected get inlineJsonSchema(): Code;
     protected get inlineJsonType(): AbstractType.JsonType;
-    protected get inlineName(): Code;
+    protected get inlineExpression(): Code;
     protected get inlineToJsonFunction(): Code;
     protected get inlineToRdfResourceValuesFunction(): Code;
     protected get inlineToStringFunction(): Code;
     protected get inlineValueSparqlConstructTriplesFunction(): Code;
     protected get inlineValueSparqlWherePatternsFunction(): Code;
-    protected get schemaObject(): {
-        kind: Code;
-        members: Code;
-    };
+    protected get schemaInitializers(): readonly Code[];
+    protected get staticModuleDeclarations(): Record<string, Code>;
+    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
+    jsonType(): AbstractType.JsonType;
     jsonUiSchemaElement(): Maybe<Code>;
+    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     private readonly lazyMembers;
 }
 type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
 type ExtrinsicDiscriminant = {
     readonly jsonName: string;
-    readonly kind: "extrinsic";
+    readonly kind: "Extrinsic";
     readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
     readonly name: string;
 };
 type HybridDiscriminant = {
     readonly jsonName: string;
-    readonly kind: "hybrid";
+    readonly kind: "Hybrid";
     readonly memberValues: readonly {
-        readonly kind: "extrinsic" | "intrinsic";
+        readonly kind: "Extrinsic" | "Intrinsic";
         readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
     }[];
     readonly name: string;
 };
 type IntrinsicDiscriminant = {
     readonly jsonName: string;
-    readonly kind: "intrinsic";
+    readonly kind: "Intrinsic";
     readonly memberValues: readonly {
         readonly descendantValues: readonly AbstractType.DiscriminantProperty.Value[];
         readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
@@ -73,7 +98,7 @@ type IntrinsicDiscriminant = {
     readonly name: string;
 };
 type TypeofDiscriminant = {
-    readonly kind: "typeof";
+    readonly kind: "Typeof";
     readonly memberValues: readonly Typeof[];
 };
 export declare namespace Discriminant {
@@ -96,4 +121,4 @@ export declare namespace AbstractUnionType {
     }
 }
 export {};
-//# sourceMappingURL=AbstractUnionType.d.ts.map
+//# sourceMappingURL=UnionType.d.ts.map