@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/generators/ts/TypeFactory.js

@@ -18,9 +18,9 @@ import { FloatType } from "./FloatType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IntType } from "./IntType.js";
 import { IriType } from "./IriType.js";
-import { LazyObjectOptionType } from "./LazyObjectOptionType.js";
-import { LazyObjectSetType } from "./LazyObjectSetType.js";
-import { LazyObjectType } from "./LazyObjectType.js";
+import { LazyOptionType } from "./LazyOptionType.js";
+import { LazySetType } from "./LazySetType.js";
+import { LazyType } from "./LazyType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
 import { ObjectType } from "./ObjectType.js";
@@ -49,40 +49,25 @@ export class TypeFactory {
                 return cachedObjectType;
             }
         }
+        const discriminantProperty = astType.name.map((name) => new ObjectType.DiscriminantProperty({
+            configuration: this.configuration,
+            logger: this.logger,
+            name: `${this.configuration.syntheticNamePrefix}type`,
+            objectType: { name: astType.name },
+            reusables: this.reusables,
+            value: name,
+        }));
         const identifierType = this.createIdentifierType(astType.identifierType);
         const objectType = new ObjectType({
-            alias: astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic })),
+            discriminantProperty,
             comment: astType.comment,
             configuration: this.configuration,
             extern: astType.extern,
             fromRdfType: astType.fromRdfType,
             identifierType,
             label: astType.label,
-            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 objectType.descendantObjectTypes) {
-                    discriminantDescendantValues.add(descendantObjectType.discriminantValue);
-                }
-                return new ObjectType.DiscriminantProperty({
-                    configuration: this.configuration,
-                    logger: this.logger,
-                    name: `${this.configuration.syntheticNamePrefix}type`,
-                    objectType,
-                    reusables: this.reusables,
-                    type: new ObjectType.DiscriminantProperty.Type({
-                        descendantValues: [...discriminantDescendantValues].sort(),
-                        mutable: false,
-                        ownValues: [objectType.discriminantValue],
-                    }),
-                });
-            },
-            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectType(astType)),
             lazyProperties: (objectType) => {
-                const properties = astType.properties
+                const properties = astType.fields
                     .toSorted((left, right) => {
                     if (left.order < right.order) {
                         return -1;
@@ -92,11 +77,13 @@ export class TypeFactory {
                     }
                     return this.tsName(left.name).localeCompare(this.tsName(right.name));
                 })
-                    .map((astProperty) => this.createObjectTypeProperty({
-                    astObjectTypeProperty: astProperty,
+                    .map((astField) => this.createObjectTypeProperty({
+                    astStructField: astField,
                     objectType,
                 }));
-                properties.splice(0, 0, objectType._discriminantProperty);
+                discriminantProperty.ifJust((discriminantProperty) => {
+                    properties.splice(0, 0, discriminantProperty);
+                });
                 properties.splice(0, 0, new ObjectType.IdentifierProperty({
                     configuration: this.configuration,
                     logger: this.logger,
@@ -108,8 +95,10 @@ export class TypeFactory {
                 return properties;
             },
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic })),
             recursive: astType.recursive,
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
         });
@@ -124,18 +113,19 @@ export class TypeFactory {
             }
         }
         const objectUnionType = new ObjectUnionType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
-            identifierType: Maybe.of(this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType))),
+            identifierType: Maybe.of(this.createIdentifierType(ast.StructCompoundType.identifierType(astType))),
             label: astType.label,
             logger: this.logger,
-            members: ast.ObjectCompoundType.memberObjectTypes(astType).map((namedObjectType) => ({
+            members: ast.StructCompoundType.memberStructTypes(astType).map((astStructType) => ({
                 discriminantValue: Maybe.empty(),
-                type: this.createObjectType(namedObjectType),
+                type: this.createObjectType(astStructType),
             })),
+            name: astType.name.map((name) => this.tsName(name)),
             recursive: astType.recursive,
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
             synthetic: astType.synthetic,
         });
         this.cachedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectUnionType);
@@ -153,22 +143,22 @@ export class TypeFactory {
                 throw new Error("not implemented");
             case "Iri":
                 return this.createIriType(astType);
-            case "LazyObjectOption":
-                return this.createLazyObjectOptionType(astType);
-            case "LazyObjectSet":
-                return this.createLazyObjectSetType(astType);
-            case "LazyObject":
-                return this.createLazyObjectType(astType);
+            case "Lazy":
+                return this.createLazyType(astType);
+            case "LazyOption":
+                return this.createLazyOptionType(astType);
+            case "LazySet":
+                return this.createLazySetType(astType);
             case "List":
                 return this.createListType(astType);
             case "Literal":
                 return this.createLiteralType(astType, parameters);
-            case "Object":
-                return this.createObjectType(astType);
             case "Option":
                 return this.createOptionType(astType);
             case "Set":
                 return this.createSetType(astType);
+            case "Struct":
+                return this.createObjectType(astType);
             case "Term":
                 return this.createTermType(astType);
             case "Union":
@@ -176,11 +166,10 @@ export class TypeFactory {
         }
     }
     createUnionType(astType) {
-        if (astType.isObjectUnionType()) {
+        if (astType.isStructUnionType()) {
             return this.createObjectUnionType(astType);
         }
         return new UnionType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             identifierType: Maybe.empty(),
@@ -190,19 +179,22 @@ export class TypeFactory {
                 discriminantValue: member.discriminantValue,
                 type: this.createType(member.type),
             })),
+            name: astType.name.map((name) => this.tsName(name)),
             recursive: astType.recursive,
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
             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,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     createDefaultValueType(astType) {
@@ -211,14 +203,15 @@ 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,
             itemType,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     createIdentifierType(astType) {
@@ -227,12 +220,13 @@ export class TypeFactory {
                 return this.createBlankNodeType(astType);
             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,
+                    name: astType.name.map((name) => this.tsName(name)),
                     reusables: this.reusables,
+                    shapeIdentifier: astType.shapeIdentifier,
                 });
             case "Iri":
                 return this.createIriType(astType);
@@ -240,66 +234,70 @@ export class TypeFactory {
     }
     createIriType(astType) {
         return new IriType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,
             in_: astType.in_,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
-    createLazyObjectOptionType(astType) {
-        return new LazyObjectOptionType({
-            alias: astType.name.map((name) => this.tsName(name)),
+    createLazyOptionType(astType) {
+        return new LazyOptionType({
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             partialType: this.createOptionType(astType.partialType),
             resolveType: this.createOptionType(astType.resolveType),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
-    createLazyObjectSetType(astType) {
-        return new LazyObjectSetType({
-            alias: astType.name.map((name) => this.tsName(name)),
+    createLazySetType(astType) {
+        return new LazySetType({
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             partialType: this.createSetType(astType.partialType),
             resolveType: this.createSetType(astType.resolveType),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
-    createLazyObjectType(astType) {
-        return new LazyObjectType({
-            alias: astType.name.map((name) => this.tsName(name)),
+    createLazyType(astType) {
+        return new LazyType({
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             partialType: this.createType(astType.partialType),
             resolveType: this.createType(astType.resolveType),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     createListType(astType) {
         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,
             itemType,
             label: astType.label,
             logger: this.logger,
-            minCount: 0n,
             mutable: astType.mutable,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
             toRdfTypes: astType.toRdfTypes,
         });
     }
@@ -328,7 +326,6 @@ 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,
@@ -336,11 +333,12 @@ export class TypeFactory {
                             label: astType.label,
                             languageIn: [],
                             logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
                             reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     case "bigint":
                         return new BigIntType({
-                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -349,12 +347,13 @@ export class TypeFactory {
                             label: astType.label,
                             languageIn: [],
                             logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
                             primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBigIntLiteral(value).unsafeCoerce()),
                             reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     case "boolean":
                         return new BooleanType({
-                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -363,13 +362,14 @@ export class TypeFactory {
                             languageIn: [],
                             in_: astType.in_,
                             logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
                             primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBooleanLiteral(value).unsafeCoerce()),
                             reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     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,
@@ -378,15 +378,16 @@ export class TypeFactory {
                             label: astType.label,
                             languageIn: [],
                             logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
                             primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "date"
                                 ? LiteralDecoder.decodeDateLiteral
                                 : LiteralDecoder.decodeDateTimeLiteral)(value).unsafeCoerce()),
                             reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     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,
@@ -395,15 +396,16 @@ export class TypeFactory {
                             label: astType.label,
                             languageIn: [],
                             logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
                             primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "float"
                                 ? LiteralDecoder.decodeFloatLiteral
                                 : LiteralDecoder.decodeIntLiteral)(value).unsafeCoerce()),
                             reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     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,
@@ -412,8 +414,10 @@ export class TypeFactory {
                                 label: astType.label,
                                 languageIn: astType.languageIn,
                                 logger: this.logger,
+                                name: astType.name.map((name) => this.tsName(name)),
                                 primitiveIn: astType.in_.map((value) => value.value),
                                 reusables: this.reusables,
+                                shapeIdentifier: astType.shapeIdentifier,
                             });
                         }
                         break;
@@ -433,7 +437,6 @@ 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,
@@ -441,52 +444,54 @@ export class TypeFactory {
             label: astType.label,
             languageIn: astType.languageIn,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
-    createObjectTypeProperty({ astObjectTypeProperty, objectType, }) {
+    createObjectTypeProperty({ astStructField, objectType, }) {
         {
-            const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astObjectTypeProperty.shapeIdentifier);
+            const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astStructField.shapeIdentifier);
             if (cachedProperty) {
                 return cachedProperty;
             }
         }
         const property = new ObjectType.ShaclProperty({
-            comment: astObjectTypeProperty.comment,
+            comment: astStructField.comment,
             configuration: this.configuration,
-            description: astObjectTypeProperty.description,
-            display: astObjectTypeProperty.display,
-            label: astObjectTypeProperty.label,
+            description: astStructField.description,
+            display: astStructField.display,
+            label: astStructField.label,
             logger: this.logger,
-            mutable: astObjectTypeProperty.mutable,
+            mutable: astStructField.mutable,
+            name: this.tsName(astStructField.name),
             objectType,
-            name: this.tsName(astObjectTypeProperty.name),
-            path: astObjectTypeProperty.path,
-            recursive: !!astObjectTypeProperty.recursive,
+            path: astStructField.path,
+            recursive: !!astStructField.recursive,
             reusables: this.reusables,
-            type: this.createType(astObjectTypeProperty.type),
+            type: this.createType(astStructField.type),
         });
-        this.cachedObjectTypePropertiesByShapeIdentifier.set(astObjectTypeProperty.shapeIdentifier, property);
+        this.cachedObjectTypePropertiesByShapeIdentifier.set(astStructField.shapeIdentifier, property);
         return property;
     }
     createOptionType(astType) {
         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,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     createSetType(astType) {
         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,
@@ -494,20 +499,23 @@ export class TypeFactory {
             logger: this.logger,
             mutable: astType.mutable,
             minCount: astType.minCount,
+            name: astType.name.map((name) => this.tsName(name)),
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     createTermType(astType) {
         return new TermType({
-            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,
             in_: astType.in_,
             label: astType.label,
             logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
             nodeKinds: astType.nodeKinds,
             reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
         });
     }
     tsName(name, options) {

package/dist/generators/ts/UnionType.d.ts

@@ -26,39 +26,44 @@ export declare class UnionType<MemberTypeT extends Type> extends AbstractType {
     get declaration(): Maybe<Code>;
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get equalsFunction(): Code;
+    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
+    get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): AbstractType.GraphqlType;
     get hashFunction(): Code;
+    get jsTypes(): AbstractType["jsTypes"];
     get jsonSchemaFunctionDeclaration(): Code;
     get jsonTypeAliasDeclaration(): Code;
     get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
     get mutable(): boolean;
-    get expression(): Code;
-    get referencesObjectType(): boolean;
+    get referencesNamedType(): boolean;
+    get schema(): Code;
     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;
-    protected get inlineFromJsonFunction(): Code;
-    protected get inlineFromRdfResourceValuesFunction(): Code;
-    protected get inlineHashFunction(): Code;
-    protected get inlineJsonSchema(): Code;
-    protected get inlineJsonType(): AbstractType.JsonType;
-    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 schemaInitializers(): readonly Code[];
+    protected get schemaTypeExpression(): Code;
     protected get staticModuleDeclarations(): Record<string, Code>;
+    private get equalsFunctionExpression();
+    private get filterFunctionExpression();
+    private get filterTypeLiteral();
+    private get fromJsonFunctionExpression();
+    private get fromRdfResourceValuesFunctionExpression();
+    private get hashFunctionExpression();
+    /**
+     * An inline expression of this type rather than a type reference/name.
+     */
+    private get inlineExpression();
+    private get jsonSchemaExpression();
+    private get jsonTypeLiteral();
+    private get toJsonFunctionExpression();
+    private get toRdfResourceValuesFunctionExpression();
+    private get toStringFunctionExpression();
+    private get valueSparqlConstructTriplesFunctionExpression();
+    private get valueSparqlWherePatternsFunctionExpression();
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: {
         variables: {
             value: Code;
@@ -84,17 +89,14 @@ type HybridDiscriminant = {
     readonly kind: "Hybrid";
     readonly memberValues: readonly {
         readonly kind: "Extrinsic" | "Intrinsic";
-        readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly values: readonly AbstractType.DiscriminantProperty.Value[];
     }[];
     readonly name: string;
 };
 type IntrinsicDiscriminant = {
     readonly jsonName: string;
     readonly kind: "Intrinsic";
-    readonly memberValues: readonly {
-        readonly descendantValues: readonly AbstractType.DiscriminantProperty.Value[];
-        readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
-    }[];
+    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
     readonly name: string;
 };
 type TypeofDiscriminant = {