@shaclmate/compiler 4.0.65 → 4.0.66

package/dist/generators/ts/DiscriminatedUnionType.d.ts

@@ -12,9 +12,8 @@ export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends Ab
     readonly identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
     readonly kind: "ObjectDiscriminatedUnion" | "DiscriminatedUnion";
     readonly recursive: boolean;
-    readonly synthetic: boolean;
     readonly validationFunction: Maybe<Code>;
-    constructor({ identifierType, members, recursive, synthetic, ...superParameters }: {
+    constructor({ identifierType, members, recursive, ...superParameters }: {
         identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
         members: readonly (Pick<DiscriminatedUnionType.Member<MemberTypeT>, "type"> & {
             readonly discriminantValue: Maybe<number | string>;

package/dist/generators/ts/DiscriminatedUnionType.js

@@ -31,15 +31,13 @@ export class DiscriminatedUnionType extends AbstractType {
     identifierType;
     kind = "DiscriminatedUnion";
     recursive;
-    synthetic;
     validationFunction = Maybe.empty();
-    constructor({ identifierType, members, recursive, synthetic, ...superParameters }) {
+    constructor({ identifierType, members, recursive, ...superParameters }) {
         super(superParameters);
         this.identifierType = identifierType;
         invariant(members.length >= 2);
         this.recursive = recursive;
         this.discriminant = DiscriminatedUnionType_inferDiscriminant.call(this, members);
-        this.synthetic = synthetic;
         this.lazyMembers = () => members.map((member, memberI) => {
             let discriminantValues;
             switch (this.discriminant.kind) {

package/dist/generators/ts/TsGenerator.d.ts

@@ -11,10 +11,6 @@ export declare class TsGenerator implements Generator {
     });
     generate(ast_: ast.Ast): string;
     private objectSetTypeDeclarations;
-    /**
-     * Synthesize the $Object union.
-     */
-    private synthesizeUberObjectDiscriminatedUnionType;
 }
 export declare namespace TsGenerator {
     interface Configuration {

package/dist/generators/ts/TsGenerator.js

@@ -1,17 +1,11 @@
-import dataFactory from "@rdfx/data-factory";
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { BlankNodeType } from "./BlankNodeType.js";
 import { GraphqlSchema } from "./GraphqlSchema.js";
-import { IdentifierType } from "./IdentifierType.js";
-import { IriType } from "./IriType.js";
-import { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
 import { ObjectSetType } from "./ObjectSetType.js";
 import { RdfjsDatasetObjectSetType } from "./RdfjsDatasetObjectSetType.js";
 import { Reusables } from "./Reusables.js";
 import { SparqlObjectSetType } from "./SparqlObjectSetType.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
+import { UberObjectDiscriminatedUnionType } from "./UberObjectDiscriminatedUnionType.js";
 function compareTsNamedType(left, right) {
     return left.name.unsafeCoerce().localeCompare(right.name.unsafeCoerce());
 }
@@ -80,22 +74,12 @@ export class TsGenerator {
                 declarations.push(declaration);
             });
         }
-        switch (tsNamedObjectTypes.length) {
-            case 0:
-                break;
-            case 1:
-                declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${tsNamedObjectTypes[0].expression};`);
-                break;
-            default: {
-                const uberObjectDiscriminatedUnionType = this.synthesizeUberObjectDiscriminatedUnionType({
-                    configuration,
-                    namedObjectTypes: tsNamedObjectTypes,
-                    reusables,
-                });
-                declarations = declarations.concat(uberObjectDiscriminatedUnionType.declaration.toList());
-                tsNamedObjectDiscriminatedUnionTypes.push(uberObjectDiscriminatedUnionType);
-            }
-        }
+        declarations = declarations.concat(new UberObjectDiscriminatedUnionType({
+            configuration,
+            logger: this.logger,
+            members: tsNamedObjectTypes,
+            reusables,
+        }).declaration.toList());
         declarations.push(...this.objectSetTypeDeclarations({
             configuration,
             namedObjectTypes: tsNamedObjectTypes,
@@ -104,7 +88,7 @@ export class TsGenerator {
         }));
         if (configuration.features.has("GraphQL")) {
             const graphqlNamedObjectTypes = tsNamedObjectTypes.filter((tsNamedObjectType) => !tsNamedObjectType.synthetic);
-            const graphqlNamedObjectDiscriminatedUnionTypes = tsNamedObjectDiscriminatedUnionTypes.filter((tsNamedObjectDiscriminatedUnionType) => !tsNamedObjectDiscriminatedUnionType.synthetic);
+            const graphqlNamedObjectDiscriminatedUnionTypes = tsNamedObjectDiscriminatedUnionTypes;
             if (graphqlNamedObjectTypes.length > 0) {
                 declarations.push(new GraphqlSchema({
                     configuration,
@@ -138,75 +122,6 @@ export class TsGenerator {
         }
         return declarations;
     }
-    /**
-     * Synthesize the $Object union.
-     */
-    synthesizeUberObjectDiscriminatedUnionType({ configuration, namedObjectTypes, reusables, }) {
-        const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern);
-        invariant(filteredNamedObjectTypes.length > 0);
-        const nodeKinds = filteredNamedObjectTypes.reduce((nodeKinds, namedObjectType) => {
-            for (const nodeKind of namedObjectType.identifierType.nodeKinds) {
-                nodeKinds.add(nodeKind);
-            }
-            return nodeKinds;
-        }, new Set());
-        let identifierType;
-        if (nodeKinds.size === 2) {
-            identifierType = new IdentifierType({
-                name: Maybe.empty(),
-                comment: Maybe.empty(),
-                configuration,
-                label: Maybe.empty(),
-                logger: this.logger,
-                reusables,
-                shapeIdentifier: dataFactory.blankNode(),
-            });
-        }
-        else {
-            switch ([...nodeKinds][0]) {
-                case "BlankNode":
-                    identifierType = new BlankNodeType({
-                        name: Maybe.empty(),
-                        comment: Maybe.empty(),
-                        configuration,
-                        label: Maybe.empty(),
-                        logger: this.logger,
-                        reusables,
-                        shapeIdentifier: dataFactory.blankNode(),
-                    });
-                    break;
-                case "IRI":
-                    identifierType = new IriType({
-                        name: Maybe.empty(),
-                        comment: Maybe.empty(),
-                        configuration,
-                        hasValues: [],
-                        in_: [],
-                        label: Maybe.empty(),
-                        logger: this.logger,
-                        reusables,
-                        shapeIdentifier: dataFactory.blankNode(),
-                    });
-                    break;
-            }
-        }
-        return new ObjectDiscriminatedUnionType({
-            name: Maybe.of(`${configuration.syntheticNamePrefix}Object`),
-            comment: Maybe.empty(),
-            configuration,
-            identifierType: Maybe.of(identifierType),
-            label: Maybe.empty(),
-            logger: this.logger,
-            members: filteredNamedObjectTypes.map((namedObjectType) => ({
-                discriminantValue: Maybe.empty(),
-                type: namedObjectType,
-            })),
-            recursive: false,
-            reusables,
-            shapeIdentifier: dataFactory.blankNode(),
-            synthetic: true,
-        });
-    }
 }
 (function (TsGenerator) {
     let Configuration;

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.js

@@ -4,9 +4,6 @@ export function ObjectDiscriminatedUnionType_graphqlTypeVariableStatement() {
     if (!this.configuration.features.has("GraphQL")) {
         return {};
     }
-    if (this.synthetic) {
-        return {};
-    }
     const name = this.name.unsafeCoerce();
     return singleEntryRecord(`GraphQL`, code `\
 export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.js

@@ -8,9 +8,6 @@ export function ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration() {
     if (!name) {
         return {};
     }
-    if (name === `${this.configuration.syntheticNamePrefix}Object`) {
-        return {};
-    }
     return singleEntryRecord(`is${name}`, code `\
     export function is${name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${name} {
       return ${joinCode(this.members.map((member) => code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)`), { on: " || " })};