@shaclmate/compiler 4.0.94 → 4.0.95

package/dist/generators/ts/UberObjectDiscriminatedUnionType.js

@@ -7,7 +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 { code, def, joinCode } from "./ts-poet-wrapper.js";
+import { code, def, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 /**
  * The $Object discriminated union used in type guard functions (isSomeObjectType(object: $Object)) and some convenience methods.
  */
@@ -17,8 +17,8 @@ export class UberObjectDiscriminatedUnionType {
     reusables;
     constructor({ configuration, members, reusables, }) {
         this.configuration = configuration;
-        this.members = members.filter((member) => !member.extern);
-        invariant(this.members.every((member) => member.name.isJust()));
+        this.members = members;
+        invariant(this.members.every((member) => member.name.isJust() && (member.kind !== "Object" || !member.extern)));
         this.reusables = reusables;
     }
     get declaration() {
@@ -27,12 +27,12 @@ export class UberObjectDiscriminatedUnionType {
         }
         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(" | ")};`);
+            declarations.push(code `export type ${def(this.name)} = ${this.members.map((member) => `${member.name.unsafeCoerce()}.Discriminated`).join(" | ")};`);
         }
         const staticModuleDeclarations = [
             ...this.equalsFunctionDeclaration.toList(),
             ...this.hashFunctionDeclaration.toList(),
-            ...this.toJsonFunctionDeclaration.toList(),
+            ...this.toJsonObjectFunctionDeclaration.toList(),
             ...this.toRdfResourceFunctionDeclaration.toList(),
             ...this.toStringFunctionDeclaration.toList(),
         ];
@@ -61,7 +61,7 @@ export function equals(left: ${this.name}, right: ${this.name}): ${this.reusable
   }
 
 ${this.memberTypeSwitch({
-            caseBlock: (member) => code `return ${member.equalsFunction}(left, right as ${member.name.unsafeCoerce()});`,
+            caseBlock: (member) => code `return ${member.equalsFunction.annotatedUsage}(left, right as ${member.name.unsafeCoerce()});`,
             variables: { value: code `left` },
         })}
 }`);
@@ -69,7 +69,7 @@ ${this.memberTypeSwitch({
     get name() {
         return `${this.configuration.syntheticNamePrefix}Object`;
     }
-    get toJsonFunctionDeclaration() {
+    get toJsonObjectFunctionDeclaration() {
         if (!this.configuration.features.has("Object.toJson")) {
             return Maybe.empty();
         }
@@ -79,7 +79,11 @@ ${this.memberTypeSwitch({
         return Maybe.of(code `\
 export function toJson(object: ${this.name}) {
 ${this.memberTypeSwitch({
-            caseBlock: (member) => code `return ${member.toJsonExpression({ variables: { value: code `object` } })};`,
+            caseBlock: (member) => code `\
+return {
+  ...(${member.toJsonObjectFunction.annotatedUsage})(object),
+  ${literalOf(this.configuration.objectDiscriminantProperty.jsonName)}: ${literalOf(member.discriminatedType.unsafeCoerce().discriminantProperty.values[0])} as const
+};`,
             variables: { value: code `object` },
         })}
 }`);
@@ -92,7 +96,7 @@ ${this.memberTypeSwitch({
             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) => {
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${this.reusables.imports.Resource}.Identifier, ${this.name}> = (object, options) => {
 ${this.memberTypeSwitch({
             caseBlock: (member) => code `return ${member.name.unsafeCoerce()}.toRdfResource(object, options);`,
             variables: { value: code `object` },
@@ -107,9 +111,9 @@ ${this.memberTypeSwitch({
             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 {
+export const hash: ${this.reusables.snippets.HashFunction}<${this.name}> = (hasher, object) => {
 ${this.memberTypeSwitch({
-            caseBlock: (member) => code `return ${member.hashFunction}(hasher, object);`,
+            caseBlock: (member) => code `${member.hashFunction.annotatedUsage}(hasher, object); break;`,
             variables: { value: code `object` },
         })}
 }`);
@@ -133,7 +137,9 @@ ${this.memberTypeSwitch({
     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" })}
+${joinCode(this.members.flatMap((member) => member.discriminatedType
+            .unsafeCoerce()
+            .discriminantProperty.values.map((discriminantPropertyValue) => code `case ${literalOf(discriminantPropertyValue)}: ${caseBlock(member)}`)), { on: "\n" })}
 default: ${variables.value} satisfies never; throw new Error("should never reach this point");
 }`;
     }

package/dist/generators/ts/ZodGenerator.js

@@ -1,5 +1,3 @@
-import { ObjectType_jsonSchemaExpression } from "./_ObjectType/ObjectType_jsonSchemaExpression.js";
-import { ObjectType_jsonTypeExpression } from "./_ObjectType/ObjectType_jsonTypeExpression.js";
 import { Reusables } from "./Reusables.js";
 import { TsGenerator } from "./TsGenerator.js";
 import { TypeFactory } from "./TypeFactory.js";
@@ -10,7 +8,10 @@ export class ZodGenerator {
         this.logger = logger;
     }
     generate(ast_) {
-        const configuration = TsGenerator.Configuration.finalize(ast_, TsGenerator.Configuration.default_);
+        const configuration = TsGenerator.Configuration.finalize(ast_, {
+            ...TsGenerator.Configuration.default_,
+            features: new Set(["Object.JSON.schema", "Object.JSON.type"]),
+        });
         const reusables = new Reusables({ configuration, logger: this.logger });
         const typeFactory = new TypeFactory({
             configuration,
@@ -24,13 +25,7 @@ export class ZodGenerator {
                     const tsNamedObjectType = typeFactory.createObjectType(astNamedType);
                     declarations.push(code `\
 export namespace ${tsNamedObjectType.name.unsafeCoerce()} {
-  export type Json = ${ObjectType_jsonTypeExpression.call(tsNamedObjectType)};
-
-  export namespace Json {
-    export function schema() {
-      return ${ObjectType_jsonSchemaExpression.call(tsNamedObjectType)};
-    }
-  }
+${tsNamedObjectType.jsonObjectType.declaration.unsafeCoerce()}
 }`);
                     break;
                 }
@@ -38,10 +33,7 @@ export namespace ${tsNamedObjectType.name.unsafeCoerce()} {
                     const tsNamedDiscriminatedUnionType = typeFactory.createDiscriminatedUnionType(astNamedType);
                     declarations.push(code `\
 export namespace ${tsNamedDiscriminatedUnionType.name.unsafeCoerce()} {
-  ${tsNamedDiscriminatedUnionType.jsonTypeAliasDeclaration}
-  export namespace Json {
-    ${tsNamedDiscriminatedUnionType.jsonSchemaFunctionDeclaration}
-  }
+${tsNamedDiscriminatedUnionType.jsonObjectType.declaration.unsafeCoerce()}
 }`);
                     break;
                 }

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_Discriminant.d.ts

@@ -2,24 +2,21 @@ import type { AbstractType } from "../AbstractType.js";
 import type { Typeof } from "../Typeof.js";
 export type AbstractDiscriminatedUnionType_Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
 type ExtrinsicDiscriminant = {
-    readonly jsonName: string;
     readonly kind: "Extrinsic";
-    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
+    readonly memberValues: AbstractType.DiscriminatedType["discriminantProperty"]["values"];
     readonly name: string;
 };
 type HybridDiscriminant = {
-    readonly jsonName: string;
     readonly kind: "Hybrid";
     readonly memberValues: readonly {
         readonly kind: "Extrinsic" | "Intrinsic";
-        readonly values: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly values: AbstractType.DiscriminatedType["discriminantProperty"]["values"];
     }[];
     readonly name: string;
 };
 type IntrinsicDiscriminant = {
-    readonly jsonName: string;
     readonly kind: "Intrinsic";
-    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
+    readonly memberValues: AbstractType.DiscriminatedType["discriminantProperty"]["values"];
     readonly name: string;
 };
 type TypeofDiscriminant = {

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_conversionFunctionExpression.d.ts → AbstractDiscriminatedUnionType_conversionFunction.d.ts}

@@ -3,4 +3,4 @@ import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUni
 import { AbstractType } from "../AbstractType.js";
 import type { Type } from "../Type.js";
 export declare function AbstractDiscriminatedUnionType_conversionFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Maybe<AbstractType.ConversionFunction>;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_conversionFunctionExpression.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_conversionFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_conversionFunctionExpression.js → AbstractDiscriminatedUnionType_conversionFunction.js}

@@ -26,7 +26,7 @@ export function AbstractDiscriminatedUnionType_conversionFunctionExpression() {
         for (const member of this.members) {
             const memberConversionFunction = member.type.conversionFunction.extract();
             const memberIdentitySourceType = {
-                expression: member.type.expression,
+                expression: member.type.discriminatedType.unsafeCoerce().expression,
                 jsType: {
                     instanceof: "Object",
                     typeof: "object",
@@ -85,4 +85,4 @@ export function AbstractDiscriminatedUnionType_conversionFunctionExpression() {
     }
     return Maybe.empty();
 }
-//# sourceMappingURL=AbstractDiscriminatedUnionType_conversionFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_conversionFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_equalsFunctionExpression.d.ts → AbstractDiscriminatedUnionType_equalsFunction.d.ts}

@@ -2,4 +2,4 @@ import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUni
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function AbstractDiscriminatedUnionType_equalsFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_equalsFunctionExpression.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_equalsFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_equalsFunctionExpression.js → AbstractDiscriminatedUnionType_equalsFunction.js}

@@ -1,12 +1,12 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function AbstractDiscriminatedUnionType_equalsFunctionExpression() {
     return code `\
-((left: ${this.expression}, right: ${this.expression}) => {
+(left, right) => {
 ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `left`)} && ${typeCheck(code `right`)}) {
-  return ${type.equalsFunction}(${unwrap(code `left`)} as ${type.expression}, ${unwrap(code `right`)} as ${type.expression});
+  return ${type.equalsFunction.annotatedUsage}(${unwrap(code `left`)} as ${type.expression}, ${unwrap(code `right`)} as ${type.expression});
 }`))}
 
   return ${this.reusables.imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
-})`;
+}`;
 }
-//# sourceMappingURL=AbstractDiscriminatedUnionType_equalsFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_equalsFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_filterFunctionExpression.d.ts → AbstractDiscriminatedUnionType_filterFunction.d.ts}

@@ -2,4 +2,4 @@ import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUni
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function AbstractDiscriminatedUnionType_filterFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_filterFunctionExpression.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_filterFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_filterFunctionExpression.js → AbstractDiscriminatedUnionType_filterFunction.js}

@@ -1,24 +1,23 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export function AbstractDiscriminatedUnionType_filterFunctionExpression() {
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return code `\
-((filter: ${this.filterType}, value: ${this.expression}) => {
+(filter, value) => {
 ${joinCode([
-        ...this.identifierType
-            .map((identifierType) => code `\
-if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier())) {
+        ...this.identifierProperty
+            .map((identifierProperty) => code `\
+if (filter.${identifierProperty.name} !== undefined && !${identifierProperty.type.filterFunction.unannotatedUsage}(filter.${identifierProperty.name}, value.${identifierProperty.name}())) {
   return false;
 }`)
             .toList(),
         ...this.members.map(({ primaryDiscriminantValue, type, typeCheck, unwrap }) => code `\
 if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeCheck(code `value`)}) {
-  if (!${type.filterFunction}(filter.on[${literalOf(primaryDiscriminantValue)}], ${unwrap(code `value`)})) {
+  if (!${type.filterFunction.unannotatedUsage}(filter.on[${literalOf(primaryDiscriminantValue)}], ${unwrap(code `value`)})) {
     return false;
   }
 }`),
     ])}
 
   return true;
-})`;
+}`;
 }
-//# sourceMappingURL=AbstractDiscriminatedUnionType_filterFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_filterFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterTypeExpression.js

@@ -1,9 +1,8 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export function AbstractDiscriminatedUnionType_filterTypeExpression() {
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return code `\
   {
-   ${this.identifierType.map((identifierType) => code `readonly ${syntheticNamePrefix}identifier?: ${identifierType.filterType};`).orDefault(code ``)}
+   ${this.identifierProperty.map((identifierProperty) => code `readonly ${identifierProperty.name}?: ${identifierProperty.type.filterType};`).orDefault(code ``)}
    readonly on?: { ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}?: ${type.filterType}`), { on: ";" })} }
   }`;
 }

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromJsonObjectFunction.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_fromJsonObjectFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_fromJsonObjectFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromJsonObjectFunction.js

@@ -0,0 +1,18 @@
+import { codeEquals } from "../codeEquals.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function AbstractDiscriminatedUnionType_fromJsonObjectFunctionExpression() {
+    return code `\
+(value, options) => {
+${joinCode(this.members.map(({ primaryDiscriminantValue, type, wrap }) => {
+        const valueVariable = code `value`;
+        const wrappedValue = wrap(valueVariable);
+        const mapAndWrapValue = codeEquals(wrappedValue, valueVariable)
+            ? ""
+            : code `.map(${valueVariable} => (${wrappedValue}))`;
+        return code `if (value.${this.configuration.objectDiscriminantProperty.jsonName} === ${literalOf(primaryDiscriminantValue)}) { return ${type.fromJsonObjectFunction.unannotatedUsage}(value, { ...options, schema: ${this.schema}.members[${literalOf(primaryDiscriminantValue)}].type })${mapAndWrapValue} as ${this.reusables.imports.Either}<Error, ${this.expression}>; }`;
+    }))}
+
+  throw new Error("unable to deserialize JSON");
+}`;
+}
+//# sourceMappingURL=AbstractDiscriminatedUnionType_fromJsonObjectFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.d.ts → AbstractDiscriminatedUnionType_fromRdfResourceValuesFunction.d.ts}

@@ -2,4 +2,4 @@ import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUni
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_fromRdfResourceValuesFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js → AbstractDiscriminatedUnionType_fromRdfResourceValuesFunction.js}

@@ -4,7 +4,7 @@ export function AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpr
     // 1. Apportion input values to different union members. For each value, let each member try to map the value until one succeeds (Right). If none succeed, return Left.
     // 2. Pass all of a member's successfully-mapped input values back into the member's mapper so it can potentially reorder them (by e.g., preferred language)
     return code `\
-(((inputValues, options) => {
+(inputValues, options) => {
   const memberInputValues: ${this.reusables.imports.Resource}.Values[] = Array.from({ length: ${this.members.length} }).map(() => ${this.reusables.imports.Resource}.Values.empty({
     focusResource: inputValues.focusResource,
     propertyPath: inputValues.propertyPath
@@ -15,7 +15,7 @@ export function AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpr
     for (let memberI = 0; memberI < ${this.members.length}; memberI++) {
 ${joinCode(this.members.map((member, memberI) => code `\
       if (memberI === ${memberI}) {
-        memberOutputValuesEither = ${member.type.fromRdfResourceValuesFunction}(inputValueAsValues, { ...options, ignoreRdfType: false, schema: options.schema.members[${literalOf(member.primaryDiscriminantValue)}].type })
+        memberOutputValuesEither = ${member.type.fromRdfResourceValuesFunction.unannotatedUsage}(inputValueAsValues, { ...options, ignoreRdfType: false, schema: options.schema.members[${literalOf(member.primaryDiscriminantValue)}].type })
         if (memberOutputValuesEither.isRight()) {
           memberInputValues[memberI] = memberInputValues[memberI].concat(inputValue);
           break;
@@ -37,7 +37,7 @@ ${joinCode(this.members.map((member, memberI) => code `\
     }
     switch (memberI) {
 ${joinCode(this.members.map((member, memberI) => {
-        let memberFromRdfResourceValuesExpression = code `${member.type.fromRdfResourceValuesFunction}(memberInputValues[memberI], { ...options, ignoreRdfType: false, schema: options.schema.members[${literalOf(member.primaryDiscriminantValue)}].type })`;
+        let memberFromRdfResourceValuesExpression = code `${member.type.fromRdfResourceValuesFunction.annotatedUsage}(memberInputValues[memberI], { ...options, ignoreRdfType: false, schema: options.schema.members[${literalOf(member.primaryDiscriminantValue)}].type })`;
         if (this.discriminant.kind === "Extrinsic" ||
             (this.discriminant.kind === "Hybrid" &&
                 this.discriminant.memberValues[memberI].kind === "Extrinsic")) {
@@ -52,6 +52,6 @@ ${joinCode(this.members.map((member, memberI) => {
     }
   }
   return ${this.reusables.imports.Right}(collectedOutputValues);
-}) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>)`;
+}`;
 }
-//# sourceMappingURL=AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_fromRdfResourceValuesFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_hashFunctionExpression.d.ts → AbstractDiscriminatedUnionType_hashFunction.d.ts}

@@ -2,4 +2,4 @@ import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUni
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function AbstractDiscriminatedUnionType_hashFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_hashFunctionExpression.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_hashFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_hashFunctionExpression.js → AbstractDiscriminatedUnionType_hashFunction.js}

@@ -1,9 +1,8 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function AbstractDiscriminatedUnionType_hashFunctionExpression() {
     return code `\
-(<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, value: ${this.expression}): HasherT => {
-${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.hashFunction}(hasher, ${unwrap(code `value`)}); }`))}
-  return hasher;
-})`;
+(hasher, value) => {
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { ${type.hashFunction.annotatedUsage}(hasher, ${unwrap(code `value`)}); return; }`))}
+}`;
 }
-//# sourceMappingURL=AbstractDiscriminatedUnionType_hashFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_hashFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inferDiscriminant.js

@@ -15,7 +15,6 @@ export function AbstractDiscriminatedUnionType_inferDiscriminant(members) {
     // extrinsic with user-specified values
     if (members.some((member) => member.discriminantValue.isJust())) {
         return {
-            jsonName: this.configuration.objectDiscriminantProperty.jsonName,
             kind: "Extrinsic",
             memberValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
             name: this.configuration.objectDiscriminantProperty.name,
@@ -27,24 +26,24 @@ export function AbstractDiscriminatedUnionType_inferDiscriminant(members) {
         let intrinsicDiscriminantProperty;
         let memberValues = [];
         for (const memberType of memberTypes) {
-            const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
-            if (!memberTypeDiscriminantProperty) {
+            const memberDiscriminatedType = memberType.discriminatedType.extract();
+            if (!memberDiscriminatedType) {
                 intrinsicDiscriminantProperty = undefined;
                 break;
             }
             if (!intrinsicDiscriminantProperty) {
-                intrinsicDiscriminantProperty = memberTypeDiscriminantProperty;
+                intrinsicDiscriminantProperty =
+                    memberDiscriminatedType.discriminantProperty;
             }
-            else if (memberTypeDiscriminantProperty.name !==
+            else if (memberDiscriminatedType.discriminantProperty.name !==
                 intrinsicDiscriminantProperty.name) {
                 intrinsicDiscriminantProperty = undefined;
                 break;
             }
-            memberValues = memberValues.concat(memberTypeDiscriminantProperty.values);
+            memberValues = memberValues.concat(memberDiscriminatedType.discriminantProperty.values);
         }
         if (intrinsicDiscriminantProperty) {
             return {
-                jsonName: intrinsicDiscriminantProperty.jsonName,
                 kind: "Intrinsic",
                 memberValues,
                 name: intrinsicDiscriminantProperty.name,
@@ -86,7 +85,6 @@ export function AbstractDiscriminatedUnionType_inferDiscriminant(members) {
             }
         }
         return {
-            jsonName: "termType",
             kind: "Hybrid",
             memberValues: memberTypes.map((memberType, memberTypeI) => {
                 const memberTermTypes = termTypes(memberType);
@@ -122,7 +120,6 @@ export function AbstractDiscriminatedUnionType_inferDiscriminant(members) {
         }
         invariant(memberValues.length === memberTypes.length);
         return {
-            jsonName: this.configuration.objectDiscriminantProperty.jsonName,
             kind: "Extrinsic",
             memberValues,
             name: this.configuration.objectDiscriminantProperty.name,

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inlineExpression.js

@@ -3,26 +3,26 @@ export function AbstractDiscriminatedUnionType_inlineExpression() {
     const discriminant = this.discriminant; // To get type narrowing to work
     switch (discriminant.kind) {
         case "Extrinsic":
-            return code `(${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.expression} }`), { on: "|" })})`;
+            return code `(${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.expression} }`), { on: " | " })})`;
         case "Hybrid":
             return code `(${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                 switch (discriminant.memberValues[memberI].kind) {
                     case "Extrinsic":
                         return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.expression} }`;
                     case "Intrinsic":
-                        return code `${type.expression}`;
+                        return code `${type.discriminatedType.unsafeCoerce().expression}`;
                     default:
                         throw new Error();
                 }
-            }), { on: "|" })})`;
+            }), { on: " | " })})`;
         case "Intrinsic":
             // If every type shares a discriminant (e.g., RDF/JS "termType" or generated ObjectType "type"),
             // just join their names with "|"
-            return code `(${joinCode(this.members.map(({ type }) => code `${type.expression}`), { on: "|" })})`;
+            return code `(${joinCode(this.members.map(({ type }) => code `${type.discriminatedType.unsafeCoerce().expression}`), { on: " | " })})`;
         case "Typeof":
             // The type.name may include literal values, but they should still be unambiguous with other member types since the typeofs
             // of the different member types are known to be different.
-            return code `(${joinCode(this.members.map(({ type }) => code `${type.expression}`), { on: "|" })})`;
+            return code `(${joinCode(this.members.map(({ type }) => code `${type.expression}`), { on: " | " })})`;
         default:
             discriminant;
             throw new Error("should never reach this point");

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonObjectFunction.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_toJsonObjectFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toJsonObjectFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonObjectFunction.js

@@ -0,0 +1,16 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function AbstractDiscriminatedUnionType_toJsonObjectFunctionExpression() {
+    return code `\
+(value) => {
+${joinCode(this.members.map(({ primaryDiscriminantValue, type, typeCheck, unwrap }) => code `\
+if (${typeCheck(code `value`)}) {
+  return {
+    ...(${type.toJsonObjectFunction.annotatedUsage})(${unwrap(code `value`)}),
+    ${literalOf(this.configuration.objectDiscriminantProperty.jsonName)}: ${literalOf(primaryDiscriminantValue)}
+  }
+}`))}
+
+  throw new Error("unable to serialize to JSON");
+}`;
+}
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toJsonObjectFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toLoggableFunction.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_toLoggableFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toLoggableFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toLoggableFunction.js

@@ -0,0 +1,20 @@
+import { codeEquals } from "../codeEquals.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function AbstractDiscriminatedUnionType_toLoggableFunctionExpression() {
+    const memberToLoggableExpressions = this.members.map(({ type, unwrap }) => type.toLoggableExpression({
+        variables: { value: unwrap(code `value`) },
+    }));
+    // If every toLoggable expression is the same, use that expression and don't bother discriminating the member type.
+    if (memberToLoggableExpressions.every((memberToLoggableExpression, memberI) => memberI === 0 ||
+        codeEquals(memberToLoggableExpression, memberToLoggableExpressions[0]))) {
+        return code `(value) => ${memberToLoggableExpressions[0]}`;
+    }
+    // Otherwise have to discriminate the member type.
+    return code `\
+(value) => {
+${joinCode(this.members.map(({ typeCheck }, memberI) => code `if (${typeCheck(code `value`)}) { return ${memberToLoggableExpressions[memberI]}; }`))}
+
+  throw new Error("unable to serialize to loggable");
+}`;
+}
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toLoggableFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.d.ts → AbstractDiscriminatedUnionType_toRdfResourceValuesFunction.d.ts}

@@ -2,4 +2,4 @@ import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUni
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toRdfResourceValuesFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toRdfResourceValuesFunction.js

@@ -0,0 +1,18 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression() {
+    return code `\
+(value, _options): (${this.toRdfResourceValueTypesExpression})[] => {
+  ${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
+        variables: {
+            graph: code `_options.graph`,
+            propertyPath: code `_options.propertyPath`,
+            resource: code `_options.resource`,
+            resourceSet: code `_options.resourceSet`,
+            value: unwrap(code `value`),
+        },
+    })}; }`))}
+
+  throw new Error("unable to serialize to RDF");
+}`;
+}
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toRdfResourceValuesFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_toStringFunctionExpression.d.ts → AbstractDiscriminatedUnionType_toStringFunction.d.ts}

@@ -2,4 +2,4 @@ import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUni
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function AbstractDiscriminatedUnionType_toStringFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_toStringFunctionExpression.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toStringFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_toStringFunctionExpression.js → AbstractDiscriminatedUnionType_toStringFunction.js}

@@ -1,12 +1,12 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function AbstractDiscriminatedUnionType_toStringFunctionExpression() {
     return code `\
-((value: ${this.expression}): string => {
+(value) => {
 ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
         variables: { value: unwrap(code `value`) },
     })}; }`))}
 
   throw new Error("unable to serialize to string");
-})`;
+}`;
 }
-//# sourceMappingURL=AbstractDiscriminatedUnionType_toStringFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toStringFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.d.ts → AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunction.d.ts}

@@ -2,4 +2,4 @@ import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUni
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js → AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunction.js}

@@ -1,13 +1,13 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export function AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression() {
     return code `\
-((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
+({ ignoreRdfType, filter, schema, ...otherParameters }) => {
   let triples: ${this.reusables.imports.sparqljs}.Triple[] = [];
 
   ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
-triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
+triples = triples.concat(${type.valueSparqlConstructTriplesFunction.unannotatedUsage}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
   
   return triples;
-}) satisfies ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
+}`;
 }
-//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunction.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.d.ts → AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunction.d.ts}

@@ -2,4 +2,4 @@ import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUni
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunction.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/{AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js → AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunction.js}

@@ -1,13 +1,13 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export function AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression() {
     return code `\
-((({ filter, schema, ...otherParameters }) => {
+({ filter, schema, ...otherParameters }) => {
   const unionPatterns: ${this.reusables.imports.sparqljs}.GroupPattern[] = [];
 
   ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
-unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
+unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction.unannotatedUsage}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
   
   return [{ patterns: unionPatterns, type: "union" }];
-}) satisfies ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
+}`;
 }
-//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunction.js.map