@shaclmate/compiler 4.0.98 → 4.0.99

package/dist/generators/ts/AbstractLazyType.js

@@ -7,10 +7,11 @@ 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 { AbstractType } from "./AbstractType.js";
+import { AbstractBuiltinType } from "./AbstractBuiltinType.js";
 import { InlineCallable } from "./InlineCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
-export class AbstractLazyType extends AbstractType {
+export class AbstractLazyType extends AbstractBuiltinType {
     discriminatedType = Maybe.empty();
     mutable = false;
     partialType;
@@ -37,13 +38,13 @@ export class AbstractLazyType extends AbstractType {
     get fromJsonObjectFunction() {
         return new InlineCallable(code `(jsonObject, fromJsonObjectOptions) => ${this.partialType.fromJsonObjectFunction.annotatedUsage}(jsonObject, { ...fromJsonObjectOptions, schema: fromJsonObjectOptions.schema.partialType })
         .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.resolverFunctionExpression({ variables: { factoryFunctionOptions: code `fromJsonObjectOptions` } })} }))`, {
-            type: code `${this.reusables.snippets.FromJsonFunction}<${this.jsonObjectType.expression}, ${this.expression}, ${this.schema}>`,
+            type: code `${this.reusables.snippets.FromJsonFunction}<${this.jsonObjectType.expression}, ${this.expression}, ${this.schema.expression}>`,
         });
     }
     get fromJsonValueFunction() {
         return new InlineCallable(code `(jsonValue, fromJsonValueOptions) => ${this.partialType.fromJsonValueFunction.annotatedUsage}(jsonValue, { ...fromJsonValueOptions, schema: fromJsonValueOptions.schema.partialType })
         .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.resolverFunctionExpression({ variables: { factoryFunctionOptions: code `fromJsonValueOptions` } })} }))`, {
-            type: code `${this.reusables.snippets.FromJsonFunction}<${this.jsonValueType.expression}, ${this.expression}, ${this.schema}>`,
+            type: code `${this.reusables.snippets.FromJsonFunction}<${this.jsonValueType.expression}, ${this.expression}, ${this.schema.expression}>`,
         });
     }
     get fromRdfResourceValuesFunction() {
@@ -51,7 +52,7 @@ export class AbstractLazyType extends AbstractType {
   (values, fromRdfResourceValuesOptions) =>
     ${this.partialType.fromRdfResourceValuesFunction.annotatedUsage}(values, { ...fromRdfResourceValuesOptions, schema: fromRdfResourceValuesOptions.schema.partialType })
       .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.resolverFunctionExpression({ variables: { factoryFunctionOptions: code `fromRdfResourceValuesOptions` } })} })))`, {
-            type: code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>`,
+            type: code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schema.type.expression}>`,
         });
     }
     get graphqlType() {
@@ -84,12 +85,6 @@ export class AbstractLazyType extends AbstractType {
     get referencesNamedType() {
         return this.partialType.referencesNamedType;
     }
-    get schemaType() {
-        return code `${{
-            kind: this.kind,
-            partialType: this.partialType.schemaType,
-        }}`;
-    }
     get toJsonObjectFunction() {
         return new InlineCallable(code `(value) => ${this.partialType.toJsonObjectFunction.unannotatedUsage}(value.${this.runtimeClass.partialPropertyName})`, {
             type: code `${this.reusables.snippets.ToJsonFunction}<${this.expression}, ${this.jsonValueType.expression}>`,
@@ -105,16 +100,23 @@ export class AbstractLazyType extends AbstractType {
     }
     get valueSparqlConstructTriplesFunction() {
         return new InlineCallable(code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction.annotatedUsage}({ ...otherParameters, schema: schema.partialType }))`, {
-            type: code `${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>`,
+            type: code `${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schema.type.expression}>`,
         });
     }
     get valueSparqlWherePatternsFunction() {
         return new InlineCallable(code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlWherePatternsFunction.annotatedUsage}({ ...otherParameters, schema: schema.partialType }))`, {
-            type: code `${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>`,
+            type: code `${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schema.type.expression}>`,
         });
     }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `get partialType() { return ${this.partialType.schema}; }`);
+    get schema() {
+        return new SchemaObject({
+            properties: {
+                ...super.schema.properties,
+                partialType: code `get partialType() { return ${this.partialType.schema.expression}; }`,
+            },
+            type: new SchemaObject.BuiltinType(code `${this.reusables.snippets.LazySchema}<${this.partialType.schema.type.expression}>`),
+            variable: super.schema.variable,
+        });
     }
     toLoggableExpression({ variables, }) {
         return this.partialType.toLoggableExpression({
@@ -189,16 +191,16 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractLazyType.prototype, "jsTypes", null);
-__decorate([
-    Memoize()
-], AbstractLazyType.prototype, "schemaType", null);
 __decorate([
     Memoize()
 ], AbstractLazyType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
 ], AbstractLazyType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyType.prototype, "schema", null);
 (function (AbstractLazyType) {
-    AbstractLazyType.GraphqlType = AbstractType.GraphqlType;
+    AbstractLazyType.GraphqlType = AbstractBuiltinType.GraphqlType;
 })(AbstractLazyType || (AbstractLazyType = {}));
 //# sourceMappingURL=AbstractLazyType.js.map

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -1,16 +1,17 @@
 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";
 /**
  * Abstract base class for TypeScript numeric types (bigint | number).
  */
 export declare abstract class AbstractNumericType<ValueT extends bigint | number> extends AbstractPrimitiveType<ValueT> {
-    readonly hashFunction: ReferenceCallable;
+    readonly hashFunction: BuiltinCallable;
     abstract readonly kind: "BigInt" | "Float" | "Int";
     get filterFunction(): Callable;
     get filterType(): Code;
-    get schemaType(): Code;
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     get valueSparqlWherePatternsFunction(): Callable;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
 }

package/dist/generators/ts/AbstractNumericType.js

@@ -6,24 +6,29 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 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 { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for TypeScript numeric types (bigint | number).
  */
 export class AbstractNumericType extends AbstractPrimitiveType {
-    hashFunction = new ReferenceCallable(this.reusables.snippets.hashNumeric);
+    hashFunction = new BuiltinCallable(this.reusables.snippets.hashNumeric);
     get filterFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.filterNumeric}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.filterNumeric}<${this.expression}>`);
     }
     get filterType() {
         return code `${this.reusables.snippets.NumericFilter}<${this.expression}>`;
     }
-    get schemaType() {
-        return code `${this.reusables.snippets.NumericSchema}<${this.expression}>`;
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.BuiltinType(code `${this.reusables.snippets.NumericSchema}<${this.expression}>`),
+            variable: super.schema.variable,
+        });
     }
     get valueSparqlWherePatternsFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.expression}>`);
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.${this.jsTypes[0].typeof}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
@@ -37,7 +42,7 @@ __decorate([
 ], AbstractNumericType.prototype, "filterType", null);
 __decorate([
     Memoize()
-], AbstractNumericType.prototype, "schemaType", null);
+], AbstractNumericType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], AbstractNumericType.prototype, "valueSparqlWherePatternsFunction", null);

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -1,14 +1,14 @@
 import type { Primitive } from "@rdfx/literal";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class of typed literals whose datatype corresponds to a JavaScript primitive type.
  */
 export declare abstract class AbstractPrimitiveType<ValueT extends Primitive> extends AbstractTypedLiteralType<ValueT> {
     protected abstract readonly decodedIn: readonly ValueT[];
-    readonly equalsFunction: ReferenceCallable;
+    readonly equalsFunction: BuiltinCallable;
     get toJsonObjectFunction(): AbstractTypedLiteralType<ValueT>["toJsonObjectFunction"];
     get toJsonValueFunction(): AbstractTypedLiteralType<ValueT>["toJsonValueFunction"];
     protected get inlineExpression(): Code;

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -7,18 +7,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class of typed literals whose datatype corresponds to a JavaScript primitive type.
  */
 export class AbstractPrimitiveType extends AbstractTypedLiteralType {
-    equalsFunction = new ReferenceCallable(this.reusables.snippets.strictEquals);
+    equalsFunction = new BuiltinCallable(this.reusables.snippets.strictEquals);
     get toJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.primitiveToJsonObject}<${this.expression}>(${this.rdfjsTermExpression(this.datatype)})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.primitiveToJsonObject}<${this.expression}>(${this.rdfjsTermExpression(this.datatype)})`);
     }
     get toJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.primitiveToJsonValue}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.primitiveToJsonValue}<${this.expression}>`);
     }
     get inlineExpression() {
         if (this.in_.length > 0) {

package/dist/generators/ts/AbstractTermType.d.ts

@@ -1,8 +1,9 @@
 import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 import { NodeKind } from "@shaclmate/shacl-ast";
-import { AbstractType } from "./AbstractType.js";
+import { AbstractBuiltinType } from "./AbstractBuiltinType.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";
 /**
  * Abstract base class for all types that are terms in RDF (i.e., identifiers, literals).
@@ -12,27 +13,27 @@ import { type Code } from "./ts-poet-wrapper.js";
  *
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
-export declare abstract class AbstractTermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractType {
-    readonly equalsFunction: ReferenceCallable;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
+export declare abstract class AbstractTermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractBuiltinType {
+    readonly equalsFunction: BuiltinCallable;
+    readonly graphqlArgs: AbstractBuiltinType["graphqlArgs"];
     readonly hasValues: readonly ConstantTermT[];
-    readonly hashFunction: ReferenceCallable;
+    readonly hashFunction: BuiltinCallable;
     readonly in_: readonly ConstantTermT[];
     readonly mutable: boolean;
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly recursive = false;
-    readonly validationFunction: AbstractType["validationFunction"];
+    readonly validationFunction: AbstractBuiltinType["validationFunction"];
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];
         in_: readonly ConstantTermT[];
-    } & ConstructorParameters<typeof AbstractType>[0]);
+    } & ConstructorParameters<typeof AbstractBuiltinType>[0]);
     get referencesNamedType(): boolean;
     get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
     get toRdfResourceValueTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
     get valueSparqlConstructTriplesFunction(): Callable;
-    protected get schemaInitializers(): readonly Code[];
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    get schema(): SchemaObject<SchemaObject.AbstractType | SchemaObject.BuiltinType>;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractBuiltinType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractBuiltinType["toStringExpression"]>[0]): Code;
     /**
      * An expression that converts a compile-time RDF/JS term into a runtime TypeScript value.
      *
@@ -41,11 +42,11 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     valueExpression(term: ConstantTermT): Code;
 }
 export declare namespace AbstractTermType {
-    type ConversionFunction = AbstractType.ConversionFunction;
-    type DiscriminatedType = AbstractType.DiscriminatedType;
+    type ConversionFunction = AbstractBuiltinType.ConversionFunction;
+    type DiscriminatedType = AbstractBuiltinType.DiscriminatedType;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    type GraphqlType = AbstractType.GraphqlType;
-    type JsType = AbstractType.JsType;
-    type JsonType = AbstractType.JsonType;
+    type GraphqlType = AbstractBuiltinType.GraphqlType;
+    type JsType = AbstractBuiltinType.JsType;
+    type JsonType = AbstractBuiltinType.JsonType;
 }
 //# sourceMappingURL=AbstractTermType.d.ts.map

package/dist/generators/ts/AbstractTermType.js

@@ -7,9 +7,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { AbstractType } from "./AbstractType.js";
+import { AbstractBuiltinType } from "./AbstractBuiltinType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { InlineCallable } from "./InlineCallable.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for all types that are terms in RDF (i.e., identifiers, literals).
@@ -19,11 +20,11 @@ import { arrayOf, code } from "./ts-poet-wrapper.js";
  *
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
-export class AbstractTermType extends AbstractType {
-    equalsFunction = new ReferenceCallable(this.reusables.snippets.booleanEquals);
+export class AbstractTermType extends AbstractBuiltinType {
+    equalsFunction = new BuiltinCallable(this.reusables.snippets.booleanEquals);
     graphqlArgs = Maybe.empty();
     hasValues;
-    hashFunction = new ReferenceCallable(this.reusables.snippets.hashTerm);
+    hashFunction = new BuiltinCallable(this.reusables.snippets.hashTerm);
     in_;
     mutable = false;
     recursive = false;
@@ -45,15 +46,21 @@ export class AbstractTermType extends AbstractType {
     get valueSparqlConstructTriplesFunction() {
         return new InlineCallable(code `((_: object) => [])`);
     }
-    get schemaInitializers() {
-        let initializers = super.schemaInitializers;
+    get schema() {
+        const thisProperties = {};
         if (this.hasValues.length > 0) {
-            initializers = initializers.concat(code `hasValues: ${arrayOf(...this.hasValues.map((hasValue) => this.rdfjsTermExpression(hasValue)))}`);
+            thisProperties["hasValues"] =
+                code `hasValues: ${arrayOf(...this.hasValues.map((hasValue) => this.rdfjsTermExpression(hasValue)))}`;
         }
         if (this.in_.length > 0) {
-            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.valueExpression(in_)))} as const`);
+            thisProperties["in"] =
+                code `in: ${arrayOf(...this.in_.map((in_) => this.valueExpression(in_)))} as const`;
         }
-        return initializers;
+        return new SchemaObject({
+            properties: { ...super.schema.properties, ...thisProperties },
+            type: new SchemaObject.AbstractType("AbstractTermType"),
+            variable: super.schema.variable,
+        });
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${variables.value}]`;
@@ -79,7 +86,10 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "schema", null);
 (function (AbstractTermType) {
-    AbstractTermType.GraphqlType = AbstractType.GraphqlType;
+    AbstractTermType.GraphqlType = AbstractBuiltinType.GraphqlType;
 })(AbstractTermType || (AbstractTermType = {}));
 //# sourceMappingURL=AbstractTermType.js.map

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

@@ -7,6 +7,7 @@ import type { AbstractType_JsonType, AbstractType_JsonTypeFactory } from "./_Abs
 import { AbstractType_JsType } from "./_AbstractType/AbstractType_JsType.js";
 import { AbstractConstruct } from "./AbstractConstruct.js";
 import type { Callable } from "./Callable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
@@ -126,9 +127,9 @@ export declare abstract class AbstractType extends AbstractConstruct {
      */
     abstract readonly referencesNamedType: boolean;
     /**
-     * TypeScript type describing .schema.
+     * TypeScript object describing this type, for runtime use.
      */
-    abstract readonly schemaType: Code;
+    get schema(): SchemaObject<SchemaObject.Type>;
     /**
      * Identifier of the shape this type was derived from.
      */
@@ -147,7 +148,7 @@ export declare abstract class AbstractType extends AbstractConstruct {
     abstract readonly toRdfResourceValueTypes: ReadonlySet<"BlankNode" | "NamedNode" | "Literal">;
     /**
      * Function that takes
-     * - a schema of this.schemaType
+     * - a schema of this.schema.type
      * - a value of this.type
      *
      * and validates the value against the schema, returning
@@ -163,7 +164,7 @@ export declare abstract class AbstractType extends AbstractConstruct {
      * The function takes a parameters object with the following parameters:
      * - filter: an instance of filterType | undefined
      * - ignoreRdfType: boolean
-     * - schema: instance of this.schemaType
+     * - schema: instance of this.schema.type
      * - valueVariable: rdfjs.Variable of the value of this type
      * - variablePrefix: string prefix to use for new variables
      */
@@ -175,7 +176,7 @@ export declare abstract class AbstractType extends AbstractConstruct {
      * - filter: an instance of filterType | undefined
      * - preferredLanguages: array of preferred language code (strings) | undefined
      * - propertyPatterns: array of sparqljs.Pattern's for the property; may be empty
-     * - schema: instance of this.schemaType
+     * - schema: instance of this.schema.type
      * - valueVariable: rdfjs.Variable of the value of this type
      * - variablePrefix: string prefix to use for new variables
      */
@@ -193,15 +194,6 @@ export declare abstract class AbstractType extends AbstractConstruct {
      * Expression of this type. If the type has a name it will be that name (a reference). Otherwise it will be the .inlineExpression.
      */
     get expression(): Code;
-    /**
-     * TypeScript object describing this type, for runtime use.
-     */
-    get schema(): Code;
-    get schemaVariable(): Maybe<Code>;
-    /**
-     * Helper to compose the result of schema along the type hierarchy.
-     */
-    protected get schemaInitializers(): readonly Code[];
     /**
      * An expression that resolves a value of this type in the GraphQL server.
      */
@@ -247,7 +239,6 @@ export declare abstract class AbstractType extends AbstractConstruct {
             value: Code;
         };
     }): Code;
-    protected schemaExpression(): Code;
     protected staticModuleDeclarations(_name: string): Record<string, Code>;
 }
 export declare namespace AbstractType {

package/dist/generators/ts/AbstractType.js

@@ -10,6 +10,7 @@ import { AbstractType_ConversionFunction } from "./_AbstractType/AbstractType_Co
 import { AbstractType_GraphqlType } from "./_AbstractType/AbstractType_GraphqlType.js";
 import { AbstractType_JsType } from "./_AbstractType/AbstractType_JsType.js";
 import { AbstractConstruct } from "./AbstractConstruct.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code, def, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 import { tsComment } from "./tsComment.js";
 /**
@@ -24,6 +25,18 @@ export class AbstractType extends AbstractConstruct {
      * Name for this type.
      */
     name;
+    /**
+     * TypeScript object describing this type, for runtime use.
+     */
+    get schema() {
+        return new SchemaObject({
+            properties: {
+                kind: code `kind: ${literalOf(this.kind)}`,
+            },
+            type: new SchemaObject.AbstractType(this.kind),
+            variable: this.name.map((name) => code `${name}.schema`),
+        });
+    }
     /**
      * Identifier of the shape this type was derived from.
      */
@@ -68,34 +81,11 @@ ${joinCode(staticModuleDeclarations
             .map((name) => code `${name}`)
             .orDefaultLazy(() => this.inlineExpression);
     }
-    /**
-     * TypeScript object describing this type, for runtime use.
-     */
-    get schema() {
-        return this.name
-            .map((name) => code `${name}.schema`)
-            .orDefaultLazy(() => this.schemaExpression());
-    }
-    get schemaVariable() {
-        if (!this.configuration.features.has("Object.schema")) {
-            return Maybe.empty();
-        }
-        return this.name.map((name) => code `${name}.schema`);
-    }
-    /**
-     * Helper to compose the result of schema along the type hierarchy.
-     */
-    get schemaInitializers() {
-        return [code `kind: ${literalOf(this.kind)} as const`];
-    }
-    schemaExpression() {
-        return code `{ ${joinCode(this.schemaInitializers.concat(), { on: ", " })} }`;
-    }
     staticModuleDeclarations(_name) {
         const staticModuleDeclarations = {};
         if (this.configuration.features.has("Object.schema")) {
             staticModuleDeclarations["schema"] =
-                code `export const schema = ${this.schemaExpression()}`;
+                code `export const schema = ${this.schema.literalExpression};`;
             staticModuleDeclarations["Schema"] =
                 code `export type Schema = typeof schema;`;
         }
@@ -108,15 +98,6 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractType.prototype, "expression", null);
-__decorate([
-    Memoize()
-], AbstractType.prototype, "schema", null);
-__decorate([
-    Memoize()
-], AbstractType.prototype, "schemaVariable", null);
-__decorate([
-    Memoize()
-], AbstractType.prototype, "schemaExpression", null);
 (function (AbstractType) {
     let ConversionFunction;
     (function (ConversionFunction) {

package/dist/generators/ts/AbstractTypedLiteralType.d.ts

@@ -2,6 +2,7 @@ import type { Literal, NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTermType } from "./AbstractTermType.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class of all types that are typed literals in RDF. In RDF every literal is either
@@ -15,7 +16,7 @@ export declare abstract class AbstractTypedLiteralType<ValueT> extends AbstractL
     constructor({ datatype, ...superParameters }: {
         datatype: NamedNode;
     } & ConstructorParameters<typeof AbstractLiteralType>[0]);
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): SchemaObject<SchemaObject.AbstractType | SchemaObject.BuiltinType>;
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     abstract valueExpression(literal: Literal | ValueT): Code;
 }

package/dist/generators/ts/AbstractTypedLiteralType.js

@@ -1,6 +1,14 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTermType } from "./AbstractTermType.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class of all types that are typed literals in RDF. In RDF every literal is either
@@ -24,13 +32,23 @@ export class AbstractTypedLiteralType extends AbstractLiteralType {
         super(superParameters);
         this.datatype = datatype;
     }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `datatype: ${this.rdfjsTermExpression(this.datatype)}`);
+    get schema() {
+        return new SchemaObject({
+            properties: {
+                ...super.schema.properties,
+                datatype: code `datatype: ${this.rdfjsTermExpression(this.datatype)}`,
+            },
+            type: new SchemaObject.AbstractType("AbstractTypedLiteralType"),
+            variable: super.schema.variable,
+        });
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
 }
+__decorate([
+    Memoize()
+], AbstractTypedLiteralType.prototype, "schema", null);
 (function (AbstractTypedLiteralType) {
     AbstractTypedLiteralType.GraphqlType = AbstractTermType.GraphqlType;
 })(AbstractTypedLiteralType || (AbstractTypedLiteralType = {}));

package/dist/generators/ts/BigDecimalType.d.ts

@@ -2,29 +2,30 @@ import type { Literal } from "@rdfjs/types";
 import type { Decimal } from "decimal.js";
 import { Maybe } from "purify-ts";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractTypedLiteralType<Decimal> {
     protected readonly inlineExpression: Code;
-    readonly jsonValueType: AbstractTypedLiteralType.JsonType;
     readonly jsTypes: readonly [{
         readonly className: Code;
         readonly instanceof: "class";
         readonly typeof: "object";
     }];
     readonly conversionFunction: Maybe<AbstractTypedLiteralType.ConversionFunction>;
-    readonly filterFunction: ReferenceCallable;
+    readonly filterFunction: BuiltinCallable;
     readonly filterType: Code;
-    readonly fromJsonValueFunction: ReferenceCallable;
-    readonly fromJsonObjectFunction: ReferenceCallable;
-    readonly fromRdfResourceValuesFunction: ReferenceCallable;
+    readonly fromJsonObjectFunction: BuiltinCallable;
+    readonly fromJsonValueFunction: BuiltinCallable;
+    readonly fromRdfResourceValuesFunction: BuiltinCallable;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    readonly hashFunction: ReferenceCallable;
+    readonly hashFunction: BuiltinCallable;
+    readonly jsonValueType: AbstractTypedLiteralType.JsonType;
     readonly kind = "BigDecimal";
-    readonly schemaType: Code;
-    readonly toJsonValueFunction: ReferenceCallable;
-    readonly toJsonObjectFunction: ReferenceCallable;
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly toJsonObjectFunction: BuiltinCallable;
+    readonly toJsonValueFunction: BuiltinCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     graphqlResolveExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["graphqlResolveExpression"]>[0]): Code;
     toLoggableExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toLoggableExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toRdfResourceValuesExpression"]>[0]): Code;