@shaclmate/compiler 4.0.65 → 4.0.67

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/UberObjectDiscriminatedUnionType.d.ts

@@ -0,0 +1,29 @@
+import { Maybe } from "purify-ts";
+import type { Logger } from "ts-log";
+import type { ObjectType } from "./ObjectType.js";
+import type { Reusables } from "./Reusables.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * The $Object discriminated union used in type guard functions (isSomeObjectType(object: $Object)) and some convenience methods.
+ */
+export declare class UberObjectDiscriminatedUnionType {
+    private readonly configuration;
+    private readonly members;
+    private readonly reusables;
+    constructor({ configuration, members, reusables, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+        members: readonly ObjectType[];
+        reusables: Reusables;
+    });
+    get declaration(): Maybe<Code>;
+    private get equalsFunctionDeclaration();
+    private get name();
+    private get toJsonFunctionDeclaration();
+    private get toRdfResourceFunctionDeclaration();
+    private get hashFunctionDeclaration();
+    private get toStringFunctionDeclaration();
+    private memberTypeSwitch;
+}
+//# sourceMappingURL=UberObjectDiscriminatedUnionType.d.ts.map

package/dist/generators/ts/UberObjectDiscriminatedUnionType.js

@@ -0,0 +1,144 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { code, def, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * The $Object discriminated union used in type guard functions (isSomeObjectType(object: $Object)) and some convenience methods.
+ */
+export class UberObjectDiscriminatedUnionType {
+    configuration;
+    members;
+    reusables;
+    constructor({ configuration, members, reusables, }) {
+        this.configuration = configuration;
+        this.members = members.filter((member) => !member.extern);
+        invariant(this.members.every((member) => member.name.isJust()));
+        this.reusables = reusables;
+    }
+    get declaration() {
+        if (this.members.length === 0) {
+            return Maybe.empty();
+        }
+        const declarations = [];
+        if (this.configuration.features.has("Object.type")) {
+            declarations.push(code `export type ${def(this.name)} = ${this.members.map((member) => member.name.unsafeCoerce()).join(" | ")};`);
+        }
+        const staticModuleDeclarations = [
+            ...this.equalsFunctionDeclaration.toList(),
+            ...this.hashFunctionDeclaration.toList(),
+            ...this.toJsonFunctionDeclaration.toList(),
+            ...this.toRdfResourceFunctionDeclaration.toList(),
+            ...this.toStringFunctionDeclaration.toList(),
+        ];
+        if (staticModuleDeclarations.length > 0) {
+            declarations.push(code `\
+export namespace ${def(this.name)} {
+${joinCode(staticModuleDeclarations, { on: "\n\n" })}
+}`);
+        }
+        if (declarations.length === 0) {
+            return Maybe.empty();
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+    }
+    get equalsFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.equals")) {
+            return Maybe.empty();
+        }
+        if (this.members.length === 1) {
+            return Maybe.of(code `export const equals = ${this.members[0].name.unsafeCoerce()}.equals`);
+        }
+        return Maybe.of(code `\
+export function equals(left: ${this.name}, right: ${this.name}): ${this.reusables.snippets.EqualsResult} {
+  if (left.${this.configuration.objectDiscriminantProperty.name} !== right.${this.configuration.objectDiscriminantProperty.name}) {
+    return ${this.reusables.imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
+  }
+
+${this.memberTypeSwitch({
+            caseBlock: (member) => code `return ${member.equalsFunction}(left, right as ${member.name.unsafeCoerce()});`,
+            variables: { value: code `left` },
+        })}
+}`);
+    }
+    get name() {
+        return `${this.configuration.syntheticNamePrefix}Object`;
+    }
+    get toJsonFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.toJson")) {
+            return Maybe.empty();
+        }
+        if (this.members.length === 1) {
+            return Maybe.of(code `export const toJson = ${this.members[0].name.unsafeCoerce()}.toJson;`);
+        }
+        return Maybe.of(code `\
+export function toJson(object: ${this.name}) {
+${this.memberTypeSwitch({
+            caseBlock: (member) => code `return ${member.toJsonExpression({ variables: { value: code `object` } })};`,
+            variables: { value: code `object` },
+        })}
+}`);
+    }
+    get toRdfResourceFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.toRdf")) {
+            return Maybe.empty();
+        }
+        if (this.members.length === 1) {
+            return Maybe.of(code `export const toRdfResource = ${this.members[0].name.unsafeCoerce()}.toRdfResource;`);
+        }
+        return Maybe.of(code `\
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${this.name}> = (object, options) => {
+${this.memberTypeSwitch({
+            caseBlock: (member) => code `return ${member.name.unsafeCoerce()}.toRdfResource(object, options);`,
+            variables: { value: code `object` },
+        })}
+};`);
+    }
+    get hashFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.hash")) {
+            return Maybe.empty();
+        }
+        if (this.members.length === 1) {
+            return Maybe.of(code `export const hash = ${this.members[0].name.unsafeCoerce()}.hash;`);
+        }
+        return Maybe.of(code `\
+export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, object: ${this.name}): HasherT {
+${this.memberTypeSwitch({
+            caseBlock: (member) => code `return ${member.hashFunction}(hasher, object);`,
+            variables: { value: code `object` },
+        })}
+}`);
+    }
+    get toStringFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.toString")) {
+            return Maybe.empty();
+        }
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        if (this.members.length === 1) {
+            return Maybe.of(code `export const ${syntheticNamePrefix}toString = ${this.members[0].name.unsafeCoerce()}.${syntheticNamePrefix}toString;`);
+        }
+        return Maybe.of(code `\
+export function ${syntheticNamePrefix}toString(object: ${this.name}) {
+${this.memberTypeSwitch({
+            caseBlock: (member) => code `return ${member.toStringExpression({ variables: { value: code `object` } })};`,
+            variables: { value: code `object` },
+        })}
+}`);
+    }
+    memberTypeSwitch({ caseBlock, variables, }) {
+        return code `\
+switch (${variables.value}.${this.configuration.objectDiscriminantProperty.name}) {
+${joinCode(this.members.map((member) => code `case "${member.discriminantProperty.unsafeCoerce().value}": ${caseBlock(member)}`), { on: "\n" })}
+default: ${variables.value} satisfies never; throw new Error("should never reach this point");
+}`;
+    }
+}
+__decorate([
+    Memoize()
+], UberObjectDiscriminatedUnionType.prototype, "name", null);
+//# sourceMappingURL=UberObjectDiscriminatedUnionType.js.map

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: " || " })};

package/dist/generators/ts/_snippets/snippets_RdfVocabularies.js

@@ -19,6 +19,7 @@ namespace ${syntheticNamePrefix}RdfVocabularies {
     byte: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#byte"),
     date: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#date"),
     dateTime: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#dateTime"),
+    dateTimeStamp: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#dateTimeStamp"),
     decimal: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#decimal"),
     double: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#double"),
     float: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#float"),