@shaclmate/compiler 4.0.98 → 4.0.100

package/dist/generators/ts/StringType.d.ts

@@ -1,31 +1,31 @@
 import type { Literal } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import type { Callable } from "./Callable.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class StringType extends AbstractPrimitiveType<string> {
     private readonly languageIn;
     protected readonly decodedIn: string[];
     readonly conversionFunction: Maybe<AbstractPrimitiveType.ConversionFunction>;
-    readonly filterFunction: ReferenceCallable;
+    readonly filterFunction: BuiltinCallable;
     readonly filterType: Code;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    readonly hashFunction: ReferenceCallable;
+    readonly hashFunction: BuiltinCallable;
     readonly jsTypes: readonly [{
         readonly typeof: "string";
     }];
     readonly jsonValueType: AbstractPrimitiveType.JsonType;
     readonly kind = "String";
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
     constructor({ languageIn, ...superParameters }: {
         languageIn: readonly string[];
     } & ConstructorParameters<typeof AbstractPrimitiveType<string>>[0]);
     get fromJsonObjectFunction(): Callable;
     get fromJsonValueFunction(): Callable;
     get fromRdfResourceValuesFunction(): Callable;
-    get schemaType(): Code;
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
     valueExpression(literal: Literal | string): Code;
 }

package/dist/generators/ts/StringType.js

@@ -9,16 +9,17 @@ import { xsd } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { arrayOf, code, literalOf } from "./ts-poet-wrapper.js";
 export class StringType extends AbstractPrimitiveType {
     languageIn;
     decodedIn = this.in_.map((in_) => LiteralDecoder.decodeStringLiteral(in_).unsafeCoerce());
     conversionFunction = Maybe.empty();
-    filterFunction = new ReferenceCallable(this.reusables.snippets.filterString);
+    filterFunction = new BuiltinCallable(this.reusables.snippets.filterString);
     filterType = code `${this.reusables.snippets.StringFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
-    hashFunction = new ReferenceCallable(this.reusables.snippets.hashString);
+    hashFunction = new BuiltinCallable(this.reusables.snippets.hashString);
     jsTypes = [
         {
             typeof: "string",
@@ -31,29 +32,31 @@ export class StringType extends AbstractPrimitiveType {
             : undefined,
     });
     kind = "String";
-    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.stringSparqlWherePatterns);
+    valueSparqlWherePatternsFunction = new BuiltinCallable(this.reusables.snippets.stringSparqlWherePatterns);
     constructor({ languageIn, ...superParameters }) {
         super(superParameters);
         this.languageIn = languageIn;
     }
     get fromJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.stringFromJsonObject}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.stringFromJsonObject}<${this.expression}>`);
     }
     get fromJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.stringFromJsonString}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.stringFromJsonString}<${this.expression}>`);
     }
     get fromRdfResourceValuesFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.stringFromRdfResourceValues}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.stringFromRdfResourceValues}<${this.expression}>`);
     }
-    get schemaType() {
-        return code `${this.reusables.snippets.StringSchema}<${this.expression}>`;
-    }
-    get schemaInitializers() {
-        let initializers = super.schemaInitializers;
-        if (this.languageIn.length > 0) {
-            initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
-        }
-        return initializers;
+    get schema() {
+        return new SchemaObject({
+            properties: this.languageIn.length > 0
+                ? {
+                    ...super.schema.properties,
+                    languageIn: code `languageIn: ${arrayOf(...this.languageIn)}`,
+                }
+                : super.schema.properties,
+            type: new SchemaObject.BuiltinType(code `${this.reusables.snippets.StringSchema}<${this.expression}>`),
+            variable: super.schema.variable,
+        });
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${this.rdfjsTermExpression(this.datatype)}` : ""})]`;
@@ -73,5 +76,5 @@ __decorate([
 ], StringType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
-], StringType.prototype, "schemaType", null);
+], StringType.prototype, "schema", null);
 //# sourceMappingURL=StringType.js.map

package/dist/generators/ts/TermType.d.ts

@@ -2,21 +2,22 @@ import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { AbstractTermType } from "./AbstractTermType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import type { Callable } from "./Callable.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class TermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractTermType {
     readonly conversionFunction: Maybe<AbstractTermType.ConversionFunction>;
-    readonly filterFunction: ReferenceCallable;
+    readonly filterFunction: BuiltinCallable;
     readonly jsTypes: readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
     }];
     readonly kind = "Term";
     readonly nodeKinds: ReadonlySet<NodeKind>;
-    readonly toJsonObjectFunction: ReferenceCallable;
-    readonly toJsonValueFunction: ReferenceCallable;
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly toJsonObjectFunction: BuiltinCallable;
+    readonly toJsonValueFunction: BuiltinCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
     constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<ConstantTermT, RuntimeTermT>>[0] & {
         nodeKinds: ReadonlySet<NodeKind>;
     });
@@ -28,9 +29,8 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     get graphqlType(): AbstractTermType.GraphqlType;
     get jsonObjectType(): AbstractTermType["jsonObjectType"];
     get jsonValueType(): AbstractTermType["jsonValueType"];
-    get schemaType(): Code;
     protected get inlineExpression(): Code;
-    protected get schemaInitializers(): Code[];
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     graphqlResolveExpression(_parameters: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
     toLoggableExpression({ variables, }: Parameters<AbstractTermType["toLoggableExpression"]>[0]): Code;
 }

package/dist/generators/ts/TermType.js

@@ -9,19 +9,20 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class TermType extends AbstractTermType {
     conversionFunction = Maybe.empty();
-    filterFunction = new ReferenceCallable(this.reusables.snippets.filterTerm);
+    filterFunction = new BuiltinCallable(this.reusables.snippets.filterTerm);
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
     kind = "Term";
     nodeKinds;
-    toJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.termToJsonObject);
+    toJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.termToJsonObject);
     toJsonValueFunction = this.toJsonObjectFunction;
-    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.termSparqlWherePatterns);
+    valueSparqlWherePatternsFunction = new BuiltinCallable(this.reusables.snippets.termSparqlWherePatterns);
     constructor({ nodeKinds, ...superParameters }) {
         super(superParameters);
         this.nodeKinds = nodeKinds;
@@ -42,13 +43,13 @@ export class TermType extends AbstractTermType {
         return code `${this.reusables.snippets.TermFilter}<${this.expression}>`;
     }
     get fromJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.termFromJsonObject}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.termFromJsonObject}<${this.expression}>`);
     }
     get fromJsonValueFunction() {
         return this.fromJsonObjectFunction;
     }
     get fromRdfResourceValuesFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.termFromRdfResourceValues}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.termFromRdfResourceValues}<${this.expression}>`);
     }
     get graphqlType() {
         throw new Error("not implemented");
@@ -79,9 +80,6 @@ export class TermType extends AbstractTermType {
     get jsonValueType() {
         return this.jsonObjectType;
     }
-    get schemaType() {
-        return code `${this.reusables.snippets.TermSchema}<${this.expression}>`;
-    }
     get inlineExpression() {
         return code `(${joinCode([...this.nodeKinds]
             .map((nodeKind) => {
@@ -99,8 +97,15 @@ export class TermType extends AbstractTermType {
         })
             .map((import_) => code `${import_}`), { on: " | " })})`;
     }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `types: ${arrayOf(...[...this.nodeKinds].map(NodeKind.toTermType))}`);
+    get schema() {
+        return new SchemaObject({
+            properties: {
+                ...super.schema.properties,
+                types: code `types: ${arrayOf(...[...this.nodeKinds].map(NodeKind.toTermType))}`,
+            },
+            type: new SchemaObject.BuiltinType(code `${this.reusables.snippets.TermSchema}<${this.expression}>`),
+            variable: super.schema.variable,
+        });
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
@@ -126,8 +131,8 @@ __decorate([
 ], TermType.prototype, "jsonObjectType", null);
 __decorate([
     Memoize()
-], TermType.prototype, "schemaType", null);
+], TermType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
-], TermType.prototype, "inlineExpression", null);
+], TermType.prototype, "schema", null);
 //# sourceMappingURL=TermType.js.map

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

@@ -9,7 +9,7 @@ ${joinCode(this.members.map(({ primaryDiscriminantValue, type, wrap }) => {
         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}>; }`;
+        return code `if (value.${this.configuration.objectDiscriminantProperty.jsonName} === ${literalOf(primaryDiscriminantValue)}) { return ${type.fromJsonObjectFunction.unannotatedUsage}(value, { ...options, schema: ${this.schema.variable.map((variable) => code `${variable}.members[${literalOf(primaryDiscriminantValue)}].type`).orDefault(type.schema.expression)} })${mapAndWrapValue} as ${this.reusables.imports.Either}<Error, ${this.expression}>; }`;
     }))}
 
   throw new Error("unable to deserialize JSON");

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

@@ -1,4 +1,5 @@
 import { Maybe } from "purify-ts";
+import type { Callable } from "../Callable.js";
 import type { Reusables } from "../Reusables.js";
 import type { Snippet } from "../Snippet.js";
 import type { TsGenerator } from "../TsGenerator.js";
@@ -17,9 +18,6 @@ declare abstract class AbstractJsonType {
         snippet: Maybe<Snippet>;
         reusables: Reusables;
     });
-    protected moduleDeclarations({ unqualifiedName, }: {
-        unqualifiedName: string;
-    }): Code[];
     get declaration(): Maybe<Code>;
     get expression(): Code;
     get schema(): Code;
@@ -28,11 +26,17 @@ declare abstract class AbstractJsonType {
             scopePrefix: Code;
         };
     }): Maybe<Code>;
+    protected moduleDeclarations({ unqualifiedName, }: {
+        unqualifiedName: string;
+    }): Code[];
+    protected schemaTypeExpression({ unqualifiedName, }: {
+        unqualifiedName: string;
+    }): Code;
 }
 declare abstract class AbstractJsonPrimitiveType<PrimitiveT extends boolean | number | string> extends AbstractJsonType {
+    protected abstract readonly typeof: "boolean" | "number" | "string";
     readonly inReference: Maybe<Code>;
     readonly in_: readonly PrimitiveT[];
-    protected abstract readonly typeof: "boolean" | "number" | "string";
     constructor({ in_, inReference, ...superParameters }: {
         in_: readonly PrimitiveT[];
         inReference: Maybe<Code>;
@@ -52,8 +56,8 @@ declare class JsonArrayType extends AbstractJsonType {
     protected get schemaExpression(): Code;
 }
 declare class JsonBooleanType extends AbstractJsonPrimitiveType<boolean> {
-    readonly kind = "JsonBoolean";
     protected readonly typeof = "boolean";
+    readonly kind = "JsonBoolean";
 }
 declare class JsonDiscriminatedUnionType extends AbstractJsonType {
     readonly kind = "JsonDiscriminatedUnion";
@@ -65,12 +69,6 @@ declare class JsonDiscriminatedUnionType extends AbstractJsonType {
     protected get inlineExpression(): Code;
     protected get schemaExpression(): Code;
 }
-declare namespace JsonDiscriminatedUnionType {
-    interface Member {
-        readonly discriminantValue: number | string;
-        readonly type: JsonIntersectionType | JsonObjectType;
-    }
-}
 declare class JsonIntersectionType extends AbstractJsonType {
     readonly kind = "JsonIntersection";
     readonly memberTypes: readonly JsonType[];
@@ -82,24 +80,29 @@ declare class JsonIntersectionType extends AbstractJsonType {
     protected get schemaExpression(): Code;
 }
 declare class JsonNumberType extends AbstractJsonPrimitiveType<number> {
-    readonly kind = "JsonNumber";
     protected readonly typeof = "number";
+    readonly kind = "JsonNumber";
 }
 declare class JsonObjectType extends AbstractJsonType {
+    private readonly cachedMemberTypes;
+    private readonly shorthand;
     readonly kind = "JsonObject";
     readonly members: readonly JsonObjectType.Member[];
-    private readonly memberTypes;
-    constructor({ members, ...superParameters }: {
+    constructor({ members, shorthand, ...superParameters }: {
         members: readonly JsonObjectType.Member[];
+        shorthand: Maybe<JsonObjectType.Shorthand>;
     } & ConstructorParameters<typeof AbstractJsonType>[0]);
     protected get inlineExpression(): Code;
     protected get schemaExpression(): Code;
+    protected schemaTypeExpression({ unqualifiedName, }: {
+        unqualifiedName: string;
+    }): Code;
     private get uiSchemaFunctionExpression();
-    private memberType;
+    uiSchemaElement({ variables, }: Parameters<AbstractJsonType["uiSchemaElement"]>[0]): Maybe<Code>;
     protected moduleDeclarations(parameters: {
         unqualifiedName: string;
     }): Code[];
-    uiSchemaElement({ variables, }: Parameters<AbstractJsonType["uiSchemaElement"]>[0]): Maybe<Code>;
+    private memberType;
 }
 declare class JsonStringType extends AbstractJsonPrimitiveType<string> {
     private readonly format;
@@ -149,6 +152,7 @@ declare class JsonTypeFactory {
     }): JsonNumberType;
     createJsonObjectType(partialMembers: readonly JsonObjectType.PartialMember[] | Record<string, Omit<JsonObjectType.PartialMember, "name">>, options?: {
         name?: AbstractJsonType.Name;
+        shorthand?: JsonObjectType.Shorthand;
         snippet?: Snippet;
     }): JsonObjectType;
     createJsonStringType(options?: {
@@ -163,6 +167,12 @@ declare class JsonTypeFactory {
 type JsonType = JsonArrayType | JsonBooleanType | JsonDiscriminatedUnionType | JsonIntersectionType | JsonNumberType | JsonObjectType | JsonStringType;
 export type AbstractType_JsonType = JsonType;
 export type AbstractType_JsonTypeFactory = JsonTypeFactory;
+declare namespace JsonDiscriminatedUnionType {
+    interface Member {
+        readonly discriminantValue: number | string;
+        readonly type: JsonIntersectionType | JsonObjectType;
+    }
+}
 export declare namespace AbstractJsonType {
     type Name = readonly string[];
 }
@@ -192,6 +202,19 @@ declare namespace JsonObjectType {
         recursive?: boolean;
         uiSchemaElement?: Maybe<MemberUiSchemaElementFunction> | MemberUiSchemaElementFunction;
     };
+    /**
+     * Shorthand for the object type, such as a string that can be transformed into the object.
+     */
+    export interface Shorthand {
+        /**
+         * Zod-compatible transformer that takes an instance of the shorthand type and transforms it to an instance of the object type.
+         */
+        readonly transformer: Callable;
+        /**
+         * Shorthand type, such as a JSON string.
+         */
+        readonly type: JsonType;
+    }
     export {};
 }
 declare namespace JsonStringType {

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

@@ -19,21 +19,6 @@ class AbstractJsonType {
         this.reusables = reusables;
         this.snippet = snippet;
     }
-    moduleDeclarations({ unqualifiedName, }) {
-        const moduleDeclarations = [];
-        if (this.configuration.features.has("Object.JSON.parse")) {
-            moduleDeclarations.push(code `\
-export function parse(json: unknown): ${this.reusables.imports.Either}<Error, ${unqualifiedName}> {
-  const jsonSafeParseResult = schema().safeParse(json);
-  if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
-  return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
-}`);
-        }
-        if (this.configuration.features.has("Object.JSON.schema")) {
-            moduleDeclarations.push(code `export function schema() { return ${this.schemaExpression} satisfies ${this.reusables.imports.z}.ZodType<Json>; }`);
-        }
-        return moduleDeclarations;
-    }
     get declaration() {
         if (this.name.isNothing() || this.snippet.isJust()) {
             return Maybe.empty();
@@ -67,6 +52,24 @@ export function parse(json: unknown): ${this.reusables.imports.Either}<Error, ${
     uiSchemaElement(_parameters) {
         return Maybe.empty();
     }
+    moduleDeclarations({ unqualifiedName, }) {
+        const moduleDeclarations = [];
+        if (this.configuration.features.has("Object.JSON.parse")) {
+            moduleDeclarations.push(code `\
+export function parse(json: unknown): ${this.reusables.imports.Either}<Error, ${unqualifiedName}> {
+  const jsonSafeParseResult = schema().safeParse(json);
+  if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
+  return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
+}`);
+        }
+        if (this.configuration.features.has("Object.JSON.schema")) {
+            moduleDeclarations.push(code `export function schema() { return ${this.schemaExpression} satisfies ${this.schemaTypeExpression({ unqualifiedName })}; }`);
+        }
+        return moduleDeclarations;
+    }
+    schemaTypeExpression({ unqualifiedName, }) {
+        return code `${this.reusables.imports.z}.ZodType<${unqualifiedName}>`;
+    }
 }
 __decorate([
     Memoize()
@@ -136,8 +139,8 @@ __decorate([
     Memoize()
 ], JsonArrayType.prototype, "schemaExpression", null);
 class JsonBooleanType extends AbstractJsonPrimitiveType {
-    kind = "JsonBoolean";
     typeof = "boolean";
+    kind = "JsonBoolean";
 }
 class JsonDiscriminatedUnionType extends AbstractJsonType {
     kind = "JsonDiscriminatedUnion";
@@ -200,17 +203,19 @@ __decorate([
     Memoize()
 ], JsonIntersectionType.prototype, "schemaExpression", null);
 class JsonNumberType extends AbstractJsonPrimitiveType {
-    kind = "JsonNumber";
     typeof = "number";
+    kind = "JsonNumber";
 }
 class JsonObjectType extends AbstractJsonType {
+    cachedMemberTypes;
+    shorthand;
     kind = "JsonObject";
     members;
-    memberTypes;
-    constructor({ members, ...superParameters }) {
+    constructor({ members, shorthand, ...superParameters }) {
         super(superParameters);
+        this.cachedMemberTypes = Array.from({ length: members.length }).map(() => null);
         this.members = members;
-        this.memberTypes = Array.from({ length: members.length }).map(() => null);
+        this.shorthand = shorthand;
     }
     get inlineExpression() {
         return code `{ ${joinCode(this.members.map((member, memberI) => {
@@ -218,7 +223,7 @@ class JsonObjectType extends AbstractJsonType {
         }), { on: ", " })} }`;
     }
     get schemaExpression() {
-        return code `${this.reusables.imports.z}.object({ ${joinCode(this.members.map((member, memberI) => {
+        const objectSchema = code `${this.reusables.imports.z}.object({ ${joinCode(this.members.map((member, memberI) => {
             const memberType = this.memberType(memberI);
             let schema = memberType.schema;
             if (member.recursive) {
@@ -241,6 +246,16 @@ class JsonObjectType extends AbstractJsonType {
             }
             return code `${literalOf(member.name)}: ${schema}`;
         }), { on: ", " })} })`;
+        return this.shorthand
+            .map((shorthand) => {
+            return code `${this.reusables.imports.z}.union([${objectSchema}, ${shorthand.type.schema}.transform(${shorthand.transformer.unannotatedUsage})])`;
+        })
+            .orDefault(objectSchema);
+    }
+    schemaTypeExpression({ unqualifiedName, }) {
+        return this.shorthand
+            .map((shorthand) => code `${this.reusables.imports.z}.ZodType<${unqualifiedName}, ${unqualifiedName} | ${shorthand.type.expression}>`)
+            .orDefault(super.schemaTypeExpression({ unqualifiedName }));
     }
     get uiSchemaFunctionExpression() {
         const variables = { scopePrefix: code `(_options?.scopePrefix ?? "#")` };
@@ -256,14 +271,10 @@ class JsonObjectType extends AbstractJsonType {
   return ${uiSchema};
 })`;
     }
-    memberType(memberI) {
-        if (this.memberTypes[memberI] === null) {
-            this.memberTypes[memberI] =
-                typeof this.members[memberI].type === "function"
-                    ? this.members[memberI].type()
-                    : this.members[memberI].type;
-        }
-        return this.memberTypes[memberI];
+    uiSchemaElement({ variables, }) {
+        return Maybe.of(code `${this.name
+            .map((name) => code `${name.join(".")}.uiSchema`)
+            .orDefaultLazy(() => this.uiSchemaFunctionExpression)}({ scopePrefix: ${variables.scopePrefix} })`);
     }
     moduleDeclarations(parameters) {
         const moduleDeclarations = super.moduleDeclarations(parameters);
@@ -272,10 +283,14 @@ class JsonObjectType extends AbstractJsonType {
         }
         return moduleDeclarations;
     }
-    uiSchemaElement({ variables, }) {
-        return Maybe.of(code `${this.name
-            .map((name) => code `${name.join(".")}.uiSchema`)
-            .orDefaultLazy(() => this.uiSchemaFunctionExpression)}({ scopePrefix: ${variables.scopePrefix} })`);
+    memberType(memberI) {
+        if (this.cachedMemberTypes[memberI] === null) {
+            this.cachedMemberTypes[memberI] =
+                typeof this.members[memberI].type === "function"
+                    ? this.members[memberI].type()
+                    : this.members[memberI].type;
+        }
+        return this.cachedMemberTypes[memberI];
     }
 }
 __decorate([
@@ -406,6 +421,7 @@ class JsonTypeFactory {
                     : Maybe.fromNullable(member.uiSchemaElement),
             })),
             name: Maybe.fromNullable(options?.name),
+            shorthand: Maybe.fromNullable(options?.shorthand),
             snippet: Maybe.fromNullable(options?.snippet),
         });
     }

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

@@ -14,7 +14,7 @@ if (focusIdentifier.termType === "Variable") {
       ignoreRdfType: false,
       preferredLanguages,
       propertyPatterns: [],
-      schema: ${this.identifierType.schema},
+      schema: ${this.identifierType.schema.expression},
       valueVariable: focusIdentifier,
       variablePrefix,
   }));

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_fromRdfResourceValuesFunction.js

@@ -3,6 +3,6 @@ export function ObjectIntersectionType_fromRdfResourceValuesFunctionExpression()
     return code `(values, options) => values.chainMap(value => value.toResource().chain(resource => ${this.fromRdfResourceFunction.annotatedUsage}(resource, options)))`;
 }
 export function ObjectIntersectionType_fromRdfResourceValuesFunctionType() {
-    return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, ${this.schemaType}>`;
+    return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, ${this.schema.type.expression}>`;
 }
 //# sourceMappingURL=ObjectIntersectionType_fromRdfResourceValuesFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_AbstractProperty.d.ts

@@ -3,6 +3,7 @@ import type { Maybe } from "purify-ts";
 import type { AbstractType } from "../AbstractType.js";
 import type { Reusables } from "../Reusables.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import type { SchemaObject } from "../SchemaObject.js";
 import type { TsGenerator } from "../TsGenerator.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
@@ -83,13 +84,9 @@ export declare abstract class ObjectType_AbstractProperty {
      */
     abstract readonly recursive: boolean;
     /**
-     * TypeScript object describing this type, for runtime use.
+     * TypeScript object describing this property, for runtime use.
      */
-    abstract readonly schema: Maybe<Code>;
-    /**
-     * TypeScript type describing .schema.
-     */
-    abstract readonly schemaType: Maybe<Code>;
+    abstract readonly schema: Maybe<SchemaObject<SchemaObject.UserDefinedType>>;
     constructor({ configuration, jsonTypeFactory, logger, name, objectType, reusables, }: {
         configuration: TsGenerator.Configuration;
         jsonTypeFactory: AbstractType.JsonTypeFactory;
@@ -244,6 +241,6 @@ export declare abstract class ObjectType_AbstractProperty {
         };
     }): Maybe<Code>;
     protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
-    protected get schemaVariable(): Code;
+    protected get schemaVariable(): Maybe<Code>;
 }
 //# sourceMappingURL=ObjectType_AbstractProperty.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_AbstractProperty.js

@@ -32,9 +32,7 @@ export class ObjectType_AbstractProperty {
     }
     rdfjsTermExpression;
     get schemaVariable() {
-        return this.objectType.name
-            .map((name) => code `${name}.schema.properties.${this.name}`)
-            .orDefaultLazy(() => this.schema.unsafeCoerce());
+        return this.objectType.name.map((name) => code `${name}.schema.properties.${this.name}`);
     }
 }
 __decorate([

package/dist/generators/ts/_ObjectType/ObjectType_DiscriminantProperty.d.ts

@@ -15,7 +15,6 @@ export declare class ObjectType_DiscriminantProperty extends ObjectType_Abstract
     readonly mutable = false;
     readonly recursive = false;
     readonly schema: ObjectType_AbstractProperty["schema"];
-    readonly schemaType: ObjectType_AbstractProperty["schemaType"];
     readonly value: string;
     constructor({ configuration, value, ...superParameters }: {
         value: string;

package/dist/generators/ts/_ObjectType/ObjectType_DiscriminantProperty.js

@@ -22,7 +22,6 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
     mutable = false;
     recursive = false;
     schema = Maybe.empty();
-    schemaType = Maybe.empty();
     value;
     constructor({ configuration, value, ...superParameters }) {
         super({

package/dist/generators/ts/_ObjectType/ObjectType_IdentifierProperty.d.ts

@@ -2,6 +2,7 @@ import { Maybe } from "purify-ts";
 import type { BlankNodeType } from "../BlankNodeType.js";
 import type { IdentifierType } from "../IdentifierType.js";
 import type { IriType } from "../IriType.js";
+import { SchemaObject } from "../SchemaObject.js";
 import { type Code } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export declare class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
@@ -24,8 +25,8 @@ export declare class ObjectType_IdentifierProperty extends ObjectType_AbstractPr
     get graphqlField(): ObjectType_AbstractProperty["graphqlField"];
     get hashFunctionParameter(): Maybe<Code>;
     get jsonObjectMember(): ObjectType_AbstractProperty["jsonObjectMember"];
-    get schema(): Maybe<Code>;
-    get schemaType(): Maybe<Code>;
+    get schema(): Maybe<SchemaObject<SchemaObject.UserDefinedType>>;
+    private get _schema();
     private get typeExpression();
     private get typeSchemaVariable();
     createInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["createInitializer"]>[0]): Maybe<Code>;