@shaclmate/compiler 4.0.77 → 4.0.79

package/dist/generators/ts/AbstractType.d.ts

@@ -1,7 +1,7 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
-import type { AbstractType_ConversionFunction } from "./_AbstractType/AbstractType_ConversionFunction.js";
+import { AbstractType_ConversionFunction } from "./_AbstractType/AbstractType_ConversionFunction.js";
 import type { AbstractType_DiscriminantProperty } from "./_AbstractType/AbstractType_DiscriminantProperty.js";
 import { AbstractType_GraphqlType } from "./_AbstractType/AbstractType_GraphqlType.js";
 import { AbstractType_JsonType } from "./_AbstractType/AbstractType_JsonType.js";
@@ -273,6 +273,10 @@ export declare abstract class AbstractType {
 }
 export declare namespace AbstractType {
     type ConversionFunction = AbstractType_ConversionFunction;
+    namespace ConversionFunction {
+        const SourceType: typeof AbstractType_ConversionFunction.SourceType;
+        type SourceType = AbstractType_ConversionFunction.SourceType;
+    }
     type DiscriminantProperty = AbstractType_DiscriminantProperty;
     namespace DiscriminantProperty {
         type Value = AbstractType_DiscriminantProperty.Value;

package/dist/generators/ts/AbstractType.js

@@ -6,6 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
+import { AbstractType_ConversionFunction } from "./_AbstractType/AbstractType_ConversionFunction.js";
 import { AbstractType_GraphqlType } from "./_AbstractType/AbstractType_GraphqlType.js";
 import { AbstractType_JsonType } from "./_AbstractType/AbstractType_JsonType.js";
 import { AbstractType_JsType } from "./_AbstractType/AbstractType_JsType.js";
@@ -120,6 +121,10 @@ __decorate([
     Memoize()
 ], AbstractType.prototype, "schemaExpression", null);
 (function (AbstractType) {
+    let ConversionFunction;
+    (function (ConversionFunction) {
+        ConversionFunction.SourceType = AbstractType_ConversionFunction.SourceType;
+    })(ConversionFunction = AbstractType.ConversionFunction || (AbstractType.ConversionFunction = {}));
     AbstractType.GraphqlType = AbstractType_GraphqlType;
     AbstractType.JsType = AbstractType_JsType;
     AbstractType.JsonType = AbstractType_JsonType;

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

@@ -24,7 +24,6 @@ export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends Ab
     get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get equalsFunction(): Code;
-    protected get inlineExpression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get fromRdfResourceValuesFunction(): Code;
@@ -40,8 +39,9 @@ export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends Ab
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
+    protected get inlineExpression(): Code;
     protected get schemaInitializers(): readonly Code[];
-    protected staticModuleDeclarations(name: string): Record<string, Code>;
+    private get conversionFunctionExpression();
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: {
         variables: {
@@ -54,6 +54,7 @@ export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends Ab
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    protected staticModuleDeclarations(name: string): Record<string, Code>;
     private readonly lazyMembers;
 }
 export declare namespace DiscriminatedUnionType {

package/dist/generators/ts/DiscriminatedUnionType.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { DiscriminatedUnionType_conversionFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_conversionFunctionExpression.js";
 import { DiscriminatedUnionType_equalsFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_equalsFunctionExpression.js";
 import { DiscriminatedUnionType_filterFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_filterFunctionExpression.js";
 import { DiscriminatedUnionType_filterTypeExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_filterTypeExpression.js";
@@ -64,13 +65,14 @@ export class DiscriminatedUnionType extends AbstractType {
                 if (discriminant.kind === "Typeof") {
                     return code `(${joinCode(discriminantValues.map((discriminantValue) => code `typeof ${instance} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
                 }
-                if (discriminant.kind === "Intrinsic" && !json) {
-                    switch (member.type.kind) {
-                        case "Object":
-                        case "ObjectDiscriminatedUnion":
-                            return code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(${instance})`;
-                    }
-                }
+                // Causes problems in mixed Object | other dicriminated unions
+                // if (discriminant.kind === "Intrinsic" && !json) {
+                //   switch (member.type.kind) {
+                //     case "Object":
+                //     case "ObjectDiscriminatedUnion":
+                //       return code`${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(${instance})`;
+                //   }
+                // }
                 const discriminantName = json
                     ? discriminant.jsonName
                     : discriminant.name;
@@ -125,23 +127,15 @@ export class DiscriminatedUnionType extends AbstractType {
         });
     }
     get conversionFunction() {
-        return Maybe.of({
-            code: code `${this.reusables.snippets.identityConversionFunction}`,
-            sourceTypes: this.discriminant.kind === "Typeof"
-                ? this.members.flatMap(({ type }) => type.jsTypes.map((jsType) => ({
-                    expression: type.expression,
-                    jsType,
-                })))
-                : [
-                    {
-                        expression: this.expression,
-                        jsType: {
-                            instanceof: "Object",
-                            typeof: "object",
-                        },
-                    },
-                ],
-        });
+        if (this.conversionFunctionExpression.isNothing()) {
+            return this.conversionFunctionExpression;
+        }
+        return this.name
+            .map((name) => Maybe.of({
+            code: code `${name}.convert`,
+            sourceTypes: this.conversionFunctionExpression.extract().sourceTypes,
+        }))
+            .orDefault(this.conversionFunctionExpression);
     }
     get discriminantProperty() {
         switch (this.discriminant.kind) {
@@ -174,9 +168,6 @@ export class DiscriminatedUnionType extends AbstractType {
             .map((name) => code `${name}.equals`)
             .orDefault(DiscriminatedUnionType_equalsFunctionExpression.call(this));
     }
-    get inlineExpression() {
-        return DiscriminatedUnionType_inlineExpression.call(this);
-    }
     get filterFunction() {
         return this.name
             .map((name) => code `${name}.filter`)
@@ -269,16 +260,59 @@ export class DiscriminatedUnionType extends AbstractType {
             .map((name) => code `${name}.valueSparqlWherePatterns`)
             .orDefault(DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.call(this));
     }
+    get inlineExpression() {
+        return DiscriminatedUnionType_inlineExpression.call(this);
+    }
     get schemaInitializers() {
         return super.schemaInitializers.concat(code `members: { ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
             discriminantValues: discriminantValues,
             type: type.schema,
         }}`), { on: "," })} }`);
     }
+    get conversionFunctionExpression() {
+        return DiscriminatedUnionType_conversionFunctionExpression.call(this);
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.name.map((name) => code `${name}.fromJson`).orDefault(DiscriminatedUnionType_fromJsonFunctionExpression.call(this))}(${variables.value})`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    jsonSchema({ context, }) {
+        const expression = this.name
+            .map((name) => code `${name}.Json.schema()`)
+            .orDefault(DiscriminatedUnionType_jsonSchemaExpression.call(this));
+        if (context === "property" && this.recursive) {
+            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().expression}> => ${expression})`;
+        }
+        return expression;
+    }
+    jsonType() {
+        return this.name
+            .map((name) => new AbstractType.JsonType(code `${name}.Json`))
+            .orDefault(DiscriminatedUnionType_jsonTypeLiteral.call(this));
+    }
+    jsonUiSchemaElement() {
+        return Maybe.empty();
+    }
+    toJsonExpression({ variables, }) {
+        return code `${this.name.map((name) => code `${name}.toJson`).orDefault(DiscriminatedUnionType_toJsonFunctionExpression.call(this))}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const { value: valueVariable, ...otherVariables } = variables;
+        return code `${this.name.map((name) => code `${name}.toRdfResourceValues`).orDefault(DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this))}(${valueVariable}, ${otherVariables})`;
+    }
+    toStringExpression({ variables, }) {
+        return code `${this.name.map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`).orDefault(DiscriminatedUnionType_toStringFunctionExpression.call(this))}(${variables.value})`;
+    }
     staticModuleDeclarations(name) {
         const staticModuleDeclarations = {
             ...super.staticModuleDeclarations(name),
         };
+        this.conversionFunctionExpression.ifJust((conversionFunction) => {
+            staticModuleDeclarations["convert"] =
+                code `export const convert = ${conversionFunction.code};`;
+        });
         if (this.configuration.features.has("Object.equals")) {
             staticModuleDeclarations["equals"] =
                 code `export const equals = ${DiscriminatedUnionType_equalsFunctionExpression.call(this)};`;
@@ -338,39 +372,6 @@ export namespace Json {
         }
         return staticModuleDeclarations;
     }
-    fromJsonExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.fromJson`).orDefault(DiscriminatedUnionType_fromJsonFunctionExpression.call(this))}(${variables.value})`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
-    jsonSchema({ context, }) {
-        const expression = this.name
-            .map((name) => code `${name}.Json.schema()`)
-            .orDefault(DiscriminatedUnionType_jsonSchemaExpression.call(this));
-        if (context === "property" && this.recursive) {
-            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().expression}> => ${expression})`;
-        }
-        return expression;
-    }
-    jsonType() {
-        return this.name
-            .map((name) => new AbstractType.JsonType(code `${name}.Json`))
-            .orDefault(DiscriminatedUnionType_jsonTypeLiteral.call(this));
-    }
-    jsonUiSchemaElement() {
-        return Maybe.empty();
-    }
-    toJsonExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.toJson`).orDefault(DiscriminatedUnionType_toJsonFunctionExpression.call(this))}(${variables.value})`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        const { value: valueVariable, ...otherVariables } = variables;
-        return code `${this.name.map((name) => code `${name}.toRdfResourceValues`).orDefault(DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this))}(${valueVariable}, ${otherVariables})`;
-    }
-    toStringExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`).orDefault(DiscriminatedUnionType_toStringFunctionExpression.call(this))}(${variables.value})`;
-    }
     lazyMembers;
 }
 __decorate([
@@ -382,9 +383,6 @@ __decorate([
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "filterFunction", null);
@@ -421,6 +419,12 @@ __decorate([
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], DiscriminatedUnionType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], DiscriminatedUnionType.prototype, "conversionFunctionExpression", null);
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "jsonType", null);

package/dist/generators/ts/LazyOptionType.d.ts

@@ -17,6 +17,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
 }) => AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>) & {
     readonly GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     readonly JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
+    ConversionFunction: typeof import("./AbstractType.js").AbstractType.ConversionFunction;
     readonly JsType: typeof import("./_AbstractType/AbstractType_JsType.js").AbstractType_JsType;
 };
 export declare class LazyOptionType extends Super {

package/dist/generators/ts/ObjectType.js

@@ -71,11 +71,19 @@ export class ObjectType extends AbstractType {
         if (this.name.isJust()) {
             return Maybe.empty();
         }
+        const sourceTypePropertySignatures = [];
+        for (const property of this.properties) {
+            property.constructorParameter.ifJust((propertyConstructorParameter) => {
+                sourceTypePropertySignatures.push(propertyConstructorParameter.signature);
+            });
+        }
+        const sourceTypeExpression = code `{ ${joinCode(sourceTypePropertySignatures)} }`;
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         return Maybe.of({
-            code: this.createFunction,
+            code: code `(<${syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(value: ${sourceTypeExpression}, ${syntheticNamePrefix}defaultNamespace?: ${syntheticNamePrefix}DefaultNamespaceT) => ${this.createFunction}({ ...value, ${syntheticNamePrefix}defaultNamespace }))`,
             sourceTypes: [
                 {
-                    expression: this.constructorParameters.type.expression,
+                    expression: sourceTypeExpression,
                     jsType: {
                         instanceof: "Object",
                         typeof: "object",

package/dist/generators/ts/_AbstractType/AbstractType_ConversionFunction.d.ts

@@ -1,10 +1,16 @@
 import type { Code } from "../ts-poet-wrapper.js";
-import type { AbstractType_JsType } from "./AbstractType_JsType.js";
+import { AbstractType_JsType } from "./AbstractType_JsType.js";
 export interface AbstractType_ConversionFunction {
     readonly code: Code;
-    readonly sourceTypes: {
+    readonly sourceTypes: AbstractType_ConversionFunction.SourceType[];
+}
+export declare namespace AbstractType_ConversionFunction {
+    interface SourceType {
         readonly expression: Code;
         readonly jsType: AbstractType_JsType;
-    }[];
+    }
+    namespace SourceType {
+        function equals(left: SourceType, right: SourceType): boolean;
+    }
 }
 //# sourceMappingURL=AbstractType_ConversionFunction.d.ts.map

package/dist/generators/ts/_AbstractType/AbstractType_ConversionFunction.js

@@ -1,2 +1,19 @@
-export {};
+import { codeEquals } from "../codeEquals.js";
+import { AbstractType_JsType } from "./AbstractType_JsType.js";
+export var AbstractType_ConversionFunction;
+(function (AbstractType_ConversionFunction) {
+    let SourceType;
+    (function (SourceType) {
+        function equals(left, right) {
+            if (!codeEquals(left.expression, right.expression)) {
+                return false;
+            }
+            if (!AbstractType_JsType.equals(left.jsType, right.jsType)) {
+                return false;
+            }
+            return true;
+        }
+        SourceType.equals = equals;
+    })(SourceType = AbstractType_ConversionFunction.SourceType || (AbstractType_ConversionFunction.SourceType = {}));
+})(AbstractType_ConversionFunction || (AbstractType_ConversionFunction = {}));
 //# sourceMappingURL=AbstractType_ConversionFunction.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_conversionFunctionExpression.d.ts

@@ -0,0 +1,6 @@
+import { Maybe } from "purify-ts";
+import { AbstractType } from "../AbstractType.js";
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+export declare function DiscriminatedUnionType_conversionFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Maybe<AbstractType.ConversionFunction>;
+//# sourceMappingURL=DiscriminatedUnionType_conversionFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_conversionFunctionExpression.js

@@ -0,0 +1,86 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { AbstractType } from "../AbstractType.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_conversionFunctionExpression() {
+    if (this.discriminant.kind === "Typeof") {
+        // If the members are discriminated by typeof, they can all be used as source types.
+        return Maybe.of({
+            code: code `${this.reusables.snippets.identityConversionFunction}`,
+            sourceTypes: this.members.flatMap(({ type }) => type.jsTypes.map((jsType) => ({
+                expression: type.expression,
+                jsType,
+            }))),
+        });
+    }
+    if (this.discriminant.kind === "Intrinsic") {
+        // Allow discriminated unions with intrinsic discriminants (e.g., a "termType" property) to accept additional
+        // source types with typeofs besides "object".
+        // @rdfx/builder relies on discriminated unions of IRI | SomeObjectType and forces SomeObjectType to use the discriminant property
+        // "termType" so the two members share it. These properties should accept (keyof DefaultNamespaceT & string) | NamedNode | SomeObjectType source types --
+        // the "string" typeof for IRI and then "object" identity typeofs for the IRI and SomeObjectType, respectively.
+        const memberIdentitySourceTypes = [];
+        const otherMemberConversionsByTypeof = new Map();
+        for (const member of this.members) {
+            const memberConversionFunction = member.type.conversionFunction.extract();
+            const memberIdentitySourceType = {
+                expression: member.type.expression,
+                jsType: {
+                    instanceof: "Object",
+                    typeof: "object",
+                },
+            };
+            memberIdentitySourceTypes.push(memberIdentitySourceType);
+            if (!memberConversionFunction) {
+                // Identity conversion
+                continue;
+            }
+            const memberSourceTypes = memberConversionFunction.sourceTypes;
+            invariant(memberSourceTypes.length > 1, "member type should return Maybe.empty() instead of returning an identity conversion alone");
+            let haveMemberIdentitySourceType = false;
+            for (const memberSourceType of memberSourceTypes) {
+                if (AbstractType.ConversionFunction.SourceType.equals(memberSourceType, memberIdentitySourceType)) {
+                    haveMemberIdentitySourceType = true;
+                    continue;
+                }
+                if (memberSourceType.jsType.typeof === "object") {
+                    this.logger.debug("%s: member type %s conversion function has more than one source type with typeof === 'object'", this, member.type);
+                    return Maybe.empty();
+                }
+                if (otherMemberConversionsByTypeof.has(memberSourceType.jsType.typeof)) {
+                    this.logger.debug("%s: member type %s conversion function has a source type with the same non-object typeof as another member type", this, member.type);
+                    return Maybe.empty();
+                }
+                otherMemberConversionsByTypeof.set(memberSourceType.jsType.typeof, [
+                    memberSourceType,
+                    memberConversionFunction,
+                ]);
+            }
+            invariant(haveMemberIdentitySourceType, "member conversion source types should include the member type itself");
+        }
+        invariant(memberIdentitySourceTypes.length === this.members.length);
+        if (otherMemberConversionsByTypeof.size === 0) {
+            return Maybe.empty();
+        }
+        const otherMemberConversions = [...otherMemberConversionsByTypeof.values()];
+        const sourceTypes = memberIdentitySourceTypes.concat([
+            ...otherMemberConversions.map((_) => _[0]),
+        ]);
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        return Maybe.of({
+            code: code `\
+(<${syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(value: ${joinCode(sourceTypes.map((sourceType) => sourceType.expression), { on: " | " })}, defaultNamespace?: ${syntheticNamePrefix}DefaultNamespaceT): ${this.reusables.imports.Either}<Error, ${this.expression}> => {
+  switch (typeof value) {
+    case "object": return ${this.reusables.imports.Either}.of(value);
+    ${joinCode(otherMemberConversions.map(([otherMemberSourceType, otherMemberConversionFunction]) => code `case "${otherMemberSourceType.jsType.typeof}": return ${otherMemberConversionFunction.code}(value, defaultNamespace);`), { on: "\n" })}
+    default:
+      value satisfies never;
+      throw new Error("should never reach this point");
+  }
+})`,
+            sourceTypes,
+        });
+    }
+    return Maybe.empty();
+}
+//# sourceMappingURL=DiscriminatedUnionType_conversionFunctionExpression.js.map