@shaclmate/compiler 4.0.99 → 4.0.100

package/dist/generators/ts/AbstractBuiltinType.d.ts

@@ -0,0 +1,23 @@
+import { AbstractType } from "./AbstractType.js";
+import type { SchemaObject } from "./SchemaObject.js";
+/**
+ * Abstract base class for built-in types (container types, term types, et al.) -- anything that is not user-defined.
+ */
+export declare abstract class AbstractBuiltinType extends AbstractType {
+    get schema(): SchemaObject<SchemaObject.AbstractType | SchemaObject.BuiltinType>;
+}
+export declare namespace AbstractBuiltinType {
+    type ConversionFunction = AbstractType.ConversionFunction;
+    namespace ConversionFunction {
+        const SourceType: typeof import("./_AbstractType/AbstractType_ConversionFunction.js").AbstractType_ConversionFunction.SourceType;
+        type SourceType = AbstractType.ConversionFunction.SourceType;
+    }
+    type DiscriminatedType = AbstractType.DiscriminatedType;
+    const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
+    type GraphqlType = AbstractType.GraphqlType;
+    type JsType = AbstractType.JsType;
+    const JsType: typeof import("./_AbstractType/AbstractType_JsType.js").AbstractType_JsType;
+    type JsonType = AbstractType.JsonType;
+    type JsonTypeFactory = AbstractType.JsonTypeFactory;
+}
+//# sourceMappingURL=AbstractBuiltinType.d.ts.map

package/dist/generators/ts/AbstractBuiltinType.js

@@ -0,0 +1,18 @@
+import { AbstractType } from "./AbstractType.js";
+/**
+ * Abstract base class for built-in types (container types, term types, et al.) -- anything that is not user-defined.
+ */
+export class AbstractBuiltinType extends AbstractType {
+    get schema() {
+        return super.schema;
+    }
+}
+(function (AbstractBuiltinType) {
+    let ConversionFunction;
+    (function (ConversionFunction) {
+        ConversionFunction.SourceType = AbstractType.ConversionFunction.SourceType;
+    })(ConversionFunction = AbstractBuiltinType.ConversionFunction || (AbstractBuiltinType.ConversionFunction = {}));
+    AbstractBuiltinType.GraphqlType = AbstractType.GraphqlType;
+    AbstractBuiltinType.JsType = AbstractType.JsType;
+})(AbstractBuiltinType || (AbstractBuiltinType = {}));
+//# sourceMappingURL=AbstractBuiltinType.js.map

package/dist/generators/ts/AbstractUserDefinedType.d.ts

@@ -0,0 +1,71 @@
+import { AbstractType } from "./AbstractType.js";
+import type { Callable } from "./Callable.js";
+import type { CodeThunk } from "./CodeThunk.js";
+import { SchemaObject } from "./SchemaObject.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for user-defined types (compound types, object types).
+ */
+export declare abstract class AbstractUserDefinedType extends AbstractType {
+    get equalsFunction(): Callable;
+    get filterFunction(): Callable;
+    get schema(): SchemaObject<SchemaObject.UserDefinedType>;
+    get filterType(): Code;
+    get fromJsonValueFunction(): Callable;
+    get fromJsonObjectFunction(): Callable;
+    get fromRdfResourceValuesFunction(): Callable;
+    get hashFunction(): Callable;
+    get toJsonValueFunction(): Callable;
+    get toJsonObjectFunction(): Callable;
+    get toLoggableFunction(): Callable;
+    get toRdfResourceValuesFunction(): Callable;
+    get toStringFunction(): Callable;
+    get valueSparqlConstructTriplesFunction(): Callable;
+    get valueSparqlWherePatternsFunction(): Callable;
+    protected get toRdfResourceValueTypesExpression(): Code;
+    graphqlResolveExpression({ variables, }: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+    toLoggableExpression({ variables, }: Parameters<AbstractType["toLoggableExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    protected _function({ type, unannotatedExpression, unqualifiedName, }: {
+        type: CodeThunk;
+        unannotatedExpression: CodeThunk;
+        unqualifiedName: string;
+    }): Callable;
+    protected abstract equalsFunctionExpression(): Code;
+    protected equalsFunctionType(): Code;
+    protected abstract filterFunctionExpression(): Code;
+    protected filterFunctionType(): Code;
+    protected abstract filterTypeExpression(): Code;
+    protected abstract fromJsonObjectFunctionExpression(): Code;
+    protected fromJsonObjectFunctionType(): Code;
+    protected abstract fromRdfResourceValuesFunctionExpression(): Code;
+    protected fromRdfResourceValuesFunctionType(): Code;
+    protected abstract hashFunctionExpression(): Code;
+    protected hashFunctionType(): Code;
+    protected staticModuleDeclarations(name: string): Record<string, Code>;
+    protected abstract toJsonObjectFunctionExpression(): Code;
+    protected toJsonObjectFunctionType(): Code;
+    protected abstract toLoggableFunctionExpression(): Code;
+    protected toLoggableFunctionType(): Code;
+    protected abstract toRdfResourceValuesFunctionExpression(): Code;
+    protected toRdfResourceValuesFunctionType(): Code;
+    protected abstract toStringFunctionExpression(): Code;
+    protected toStringFunctionType(): Code;
+    protected abstract valueSparqlConstructTriplesFunctionExpression(): Code;
+    protected valueSparqlConstructTriplesType(): Code;
+    protected abstract valueSparqlWherePatternsFunctionExpression(): Code;
+    protected valueSparqlWherePatternsFunctionType(): Code;
+}
+export declare namespace AbstractUserDefinedType {
+    type ConversionFunction = AbstractType.ConversionFunction;
+    type DiscriminatedType = AbstractType.DiscriminatedType;
+    type GraphqlType = AbstractType.GraphqlType;
+    type JsonType = AbstractType.JsonType;
+    type JsType = AbstractType.JsType;
+}
+//# sourceMappingURL=AbstractUserDefinedType.d.ts.map

package/dist/generators/ts/AbstractUserDefinedType.js

@@ -0,0 +1,285 @@
+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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.js";
+import { DeclaredCallable } from "./DeclaredCallable.js";
+import { InlineCallable } from "./InlineCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for user-defined types (compound types, object types).
+ */
+export class AbstractUserDefinedType extends AbstractType {
+    get equalsFunction() {
+        return this._function({
+            type: () => this.equalsFunctionType(),
+            unannotatedExpression: () => this.equalsFunctionExpression(),
+            unqualifiedName: "equals",
+        });
+    }
+    get filterFunction() {
+        return this._function({
+            type: () => this.filterFunctionType(),
+            unannotatedExpression: () => this.filterFunctionExpression(),
+            unqualifiedName: "filter",
+        });
+    }
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.UserDefinedType({
+                members: { kind: code `kind: ${literalOf(this.kind)}` },
+                name: this.name.map((name) => code `${name}.Schema`),
+            }),
+            variable: this.name.map((name) => code `${name}.schema`),
+        });
+    }
+    get filterType() {
+        return this.name
+            .map((name) => code `${name}.Filter`)
+            .orDefaultLazy(() => this.filterTypeExpression());
+    }
+    get fromJsonValueFunction() {
+        return this.fromJsonObjectFunction;
+    }
+    get fromJsonObjectFunction() {
+        return this._function({
+            type: () => this.fromJsonObjectFunctionType(),
+            unannotatedExpression: () => this.fromJsonObjectFunctionExpression(),
+            unqualifiedName: "fromJson",
+        });
+    }
+    get fromRdfResourceValuesFunction() {
+        return this._function({
+            type: () => this.fromRdfResourceValuesFunctionType(),
+            unannotatedExpression: () => this.fromRdfResourceValuesFunctionExpression(),
+            unqualifiedName: "fromRdfResourceValues",
+        });
+    }
+    get hashFunction() {
+        return this._function({
+            type: () => this.hashFunctionType(),
+            unannotatedExpression: () => this.hashFunctionExpression(),
+            unqualifiedName: "hash",
+        });
+    }
+    get toJsonValueFunction() {
+        return this.toJsonObjectFunction;
+    }
+    get toJsonObjectFunction() {
+        return this._function({
+            type: () => this.toJsonObjectFunctionType(),
+            unannotatedExpression: () => this.toJsonObjectFunctionExpression(),
+            unqualifiedName: "toJson",
+        });
+    }
+    get toLoggableFunction() {
+        return this._function({
+            type: () => this.toLoggableFunctionType(),
+            unannotatedExpression: () => this.toLoggableFunctionExpression(),
+            unqualifiedName: "toLoggable",
+        });
+    }
+    get toRdfResourceValuesFunction() {
+        return this._function({
+            type: () => this.toRdfResourceValuesFunctionType(),
+            unannotatedExpression: () => this.toRdfResourceValuesFunctionExpression(),
+            unqualifiedName: "toRdfResourceValues",
+        });
+    }
+    get toStringFunction() {
+        return this._function({
+            type: () => this.toStringFunctionType(),
+            unannotatedExpression: () => this.toStringFunctionExpression(),
+            unqualifiedName: `${this.configuration.syntheticNamePrefix}toString`,
+        });
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return this._function({
+            type: () => this.valueSparqlConstructTriplesType(),
+            unannotatedExpression: () => this.valueSparqlConstructTriplesFunctionExpression(),
+            unqualifiedName: "valueSparqlConstructTriples",
+        });
+    }
+    get valueSparqlWherePatternsFunction() {
+        return this._function({
+            type: () => this.valueSparqlWherePatternsFunctionType(),
+            unannotatedExpression: () => this.valueSparqlWherePatternsFunctionExpression(),
+            unqualifiedName: "valueSparqlWherePatterns",
+        });
+    }
+    get toRdfResourceValueTypesExpression() {
+        return joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
+            switch (toRdfResourceValueType) {
+                case "BlankNode":
+                    return code `${this.reusables.imports.BlankNode}`;
+                case "Literal":
+                    return code `${this.reusables.imports.Literal}`;
+                case "NamedNode":
+                    return code `${this.reusables.imports.NamedNode}`;
+                default:
+                    toRdfResourceValueType;
+                    throw new Error();
+            }
+        }), { on: " | " });
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    toLoggableExpression({ variables, }) {
+        return code `${this.toLoggableFunction.unannotatedUsage}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const { value: valueVariable, ...otherVariables } = variables;
+        return code `${this.toRdfResourceValuesFunction.unannotatedUsage}(${valueVariable}, ${otherVariables})`;
+    }
+    toStringExpression({ variables, }) {
+        return code `${this.toStringFunction.unannotatedUsage}(${variables.value})`;
+    }
+    _function({ type, unannotatedExpression, unqualifiedName, }) {
+        return this.name
+            .map((name) => new DeclaredCallable({
+            qualifiedName: [name, unqualifiedName],
+            type,
+            unannotatedExpression,
+        }))
+            .orDefault(new InlineCallable(unannotatedExpression, { type }));
+    }
+    equalsFunctionType() {
+        return code `${this.reusables.snippets.EqualsFunction}<${this.expression}>`;
+    }
+    filterFunctionType() {
+        return code `${this.reusables.snippets.FilterFunction}<${this.filterType}, ${this.expression}>`;
+    }
+    fromJsonObjectFunctionType() {
+        return code `${this.reusables.snippets.FromJsonFunction}<${this.jsonObjectType.expression}, ${this.expression}, undefined>`;
+    }
+    fromRdfResourceValuesFunctionType() {
+        return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schema.type.expression}>`;
+    }
+    hashFunctionType() {
+        return code `${this.reusables.snippets.HashFunction}<${this.expression}>`;
+    }
+    staticModuleDeclarations(name) {
+        const staticModuleDeclarations = {
+            ...super.staticModuleDeclarations(name),
+        };
+        function addFunctionDeclaration(function_) {
+            invariant(function_ instanceof DeclaredCallable);
+            staticModuleDeclarations[function_.unqualifiedName] =
+                code `export ${function_.declaration}`;
+        }
+        if (this.configuration.features.has("Object.equals")) {
+            addFunctionDeclaration(this.equalsFunction);
+        }
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations["Filter"] =
+                code `export type Filter = ${this.filterTypeExpression()};`;
+            addFunctionDeclaration(this.filterFunction);
+        }
+        if (this.configuration.features.has("Object.hash")) {
+            // Hash functions take a generic parameter and const declaration like this can't have type parameters.
+            addFunctionDeclaration(this.hashFunction);
+        }
+        if (this.configuration.features.has("Object.JSON.type")) {
+            this.jsonObjectType.declaration.ifJust((jsonTypeDeclaration) => {
+                staticModuleDeclarations["JSON"] = jsonTypeDeclaration;
+            });
+        }
+        if (this.configuration.features.has("Object.fromJson")) {
+            addFunctionDeclaration(this.fromJsonObjectFunction);
+        }
+        if (this.configuration.features.has("Object.fromRdf")) {
+            addFunctionDeclaration(this.fromRdfResourceValuesFunction);
+        }
+        if (this.configuration.features.has("Object.schema")) {
+            staticModuleDeclarations["schema"] =
+                code `export const schema = ${this.schema.literalExpression};`;
+            staticModuleDeclarations["Schema"] =
+                code `export type Schema = typeof schema;`;
+        }
+        if (this.configuration.features.has("Object.SPARQL")) {
+            addFunctionDeclaration(this.valueSparqlConstructTriplesFunction);
+            addFunctionDeclaration(this.valueSparqlWherePatternsFunction);
+        }
+        if (this.configuration.features.has("Object.toJson")) {
+            addFunctionDeclaration(this.toJsonObjectFunction);
+        }
+        if (this.configuration.features.has("Object.toLoggable")) {
+            addFunctionDeclaration(this.toLoggableFunction);
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
+            addFunctionDeclaration(this.toRdfResourceValuesFunction);
+        }
+        if (this.configuration.features.has("Object.toString")) {
+            addFunctionDeclaration(this.toStringFunction);
+        }
+        return staticModuleDeclarations;
+    }
+    toJsonObjectFunctionType() {
+        return code `${this.reusables.snippets.ToJsonFunction}<${this.expression}, ${this.jsonObjectType.expression}>`;
+    }
+    toLoggableFunctionType() {
+        return code `${this.reusables.snippets.ToLoggableFunction}<${this.expression}>`;
+    }
+    toRdfResourceValuesFunctionType() {
+        return code `${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}, ${this.toRdfResourceValueTypesExpression}>`;
+    }
+    toStringFunctionType() {
+        return code `${this.reusables.snippets.ToStringFunction}<${this.expression}>`;
+    }
+    valueSparqlConstructTriplesType() {
+        return code `${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schema.type.expression}>`;
+    }
+    valueSparqlWherePatternsFunctionType() {
+        return code `${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schema.type.expression}>`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "fromJsonObjectFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "toJsonObjectFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "toLoggableFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "toRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "toStringFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], AbstractUserDefinedType.prototype, "toRdfResourceValueTypesExpression", null);
+//# sourceMappingURL=AbstractUserDefinedType.js.map

package/dist/generators/ts/BuiltinCallable.d.ts

@@ -0,0 +1,14 @@
+import { AbstractCallable } from "./AbstractCallable.js";
+import type { Snippet } from "./Snippet.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * A callable that's a reference to a built-in snippet, an import, or a global function.
+ *
+ * Callers assume the referent carries its own type annotations, so there's no distinction between annotated and unannotated usage.
+ */
+export declare class BuiltinCallable extends AbstractCallable {
+    readonly annotatedUsage: Code;
+    readonly unannotatedUsage: Code;
+    constructor(reference: Code | Snippet);
+}
+//# sourceMappingURL=BuiltinCallable.d.ts.map

package/dist/generators/ts/BuiltinCallable.js

@@ -0,0 +1,16 @@
+import { AbstractCallable } from "./AbstractCallable.js";
+import { code } from "./ts-poet-wrapper.js";
+/**
+ * A callable that's a reference to a built-in snippet, an import, or a global function.
+ *
+ * Callers assume the referent carries its own type annotations, so there's no distinction between annotated and unannotated usage.
+ */
+export class BuiltinCallable extends AbstractCallable {
+    annotatedUsage;
+    unannotatedUsage;
+    constructor(reference) {
+        super();
+        this.annotatedUsage = this.unannotatedUsage = code `${reference}`;
+    }
+}
+//# sourceMappingURL=BuiltinCallable.js.map

package/dist/generators/ts/SchemaObject.d.ts

@@ -0,0 +1,98 @@
+import type { Maybe } from "purify-ts";
+import { CodeThunk } from "./CodeThunk.js";
+import type { Snippet } from "./Snippet.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Runtime schema/metadata objects for types and properties.
+ */
+export declare class SchemaObject<TypeT extends SchemaObject.Type> {
+    /**
+     * Object literal properties, usually property assignments like name: value
+     * without a terminating comma.
+     *
+     * Note the name is repeated between the key and the value:
+     *   { name: code`name: value` }
+     * Only the value is incorporated into generated code. The keys are used to sort properties.
+     *
+     * This enables overwriting in the *Type tree while also supporting non-property assignments such as
+     *   { name: code`get name() { return value; }` }
+     * or
+     *   { shorthand: code `shorthand` }
+     */
+    readonly properties: Readonly<Record<string, CodeThunk>>;
+    /**
+     * Type of the schema object.
+     */
+    readonly type: TypeT;
+    /**
+     * Variable pointing to the schema object.
+     */
+    readonly variable: Maybe<Code>;
+    constructor({ properties, type, variable, }: {
+        properties: Readonly<Record<string, CodeThunk>>;
+        type: TypeT;
+        variable: Maybe<Code>;
+    });
+    /**
+     * Expression for this schema object, either the variable or a literal expression.
+     */
+    get expression(): Code;
+    /**
+     * Literal expression of the schema object e.g., { name1: value1, name2: value2 }
+     */
+    get literalExpression(): Code;
+    toString(): string;
+}
+export declare namespace SchemaObject {
+    /**
+     * Placeholder for abstract base classes.
+     */
+    class AbstractType {
+        private readonly ownerKind;
+        constructor(ownerKind: string);
+        get expression(): Code;
+        toString(): string;
+    }
+    /**
+     * A built-in schema object type from a snippet or import.
+     */
+    class BuiltinType {
+        readonly expression: Code;
+        constructor(expression: Code | Snippet);
+        toString(): string;
+    }
+    /**
+     * A user-defined schema object type, typically corresponding to user-defined types.
+     */
+    class UserDefinedType {
+        /**
+         * Members of the schema object type, usually property signatures like name: string.
+         *
+         * Note the name is repeated between the key and the value:
+         *   { name: code`name: string` }
+         * This enables overwriting in the *Type tree. Unlike property assignments (above),
+         * we don't really need to support other member types (index signatures, methods, et al.).
+         * Rather, the name is repeated here for consistency with property assignments.
+         */
+        readonly members: Readonly<Record<string, CodeThunk>>;
+        /**
+         * Name of the type, can be used in type annotations.
+         */
+        readonly name: Maybe<Code>;
+        constructor({ members, name, }: {
+            members: Readonly<Record<string, CodeThunk>>;
+            name: Maybe<Code>;
+        });
+        /**
+         * Expression of the schema object type, either the name or a literal expression.
+         */
+        get expression(): Code;
+        /**
+         * Literal expression of the schema object type e.g., { name1: string, name2: string }.
+         */
+        get literalExpression(): Code;
+        toString(): string;
+    }
+    type Type = AbstractType | BuiltinType | UserDefinedType;
+}
+//# sourceMappingURL=SchemaObject.d.ts.map

package/dist/generators/ts/SchemaObject.js

@@ -0,0 +1,143 @@
+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 { Memoize } from "typescript-memoize";
+import { CodeThunk } from "./CodeThunk.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * Runtime schema/metadata objects for types and properties.
+ */
+export class SchemaObject {
+    /**
+     * Object literal properties, usually property assignments like name: value
+     * without a terminating comma.
+     *
+     * Note the name is repeated between the key and the value:
+     *   { name: code`name: value` }
+     * Only the value is incorporated into generated code. The keys are used to sort properties.
+     *
+     * This enables overwriting in the *Type tree while also supporting non-property assignments such as
+     *   { name: code`get name() { return value; }` }
+     * or
+     *   { shorthand: code `shorthand` }
+     */
+    properties;
+    /**
+     * Type of the schema object.
+     */
+    type;
+    /**
+     * Variable pointing to the schema object.
+     */
+    variable;
+    constructor({ properties, type, variable, }) {
+        this.properties = properties;
+        this.type = type;
+        this.variable = variable;
+    }
+    /**
+     * Expression for this schema object, either the variable or a literal expression.
+     */
+    get expression() {
+        return this.variable.orDefaultLazy(() => this.literalExpression);
+    }
+    /**
+     * Literal expression of the schema object e.g., { name1: value1, name2: value2 }
+     */
+    get literalExpression() {
+        return code `{ ${joinCode(Object.keys(this.properties)
+            .sort()
+            .map((key) => CodeThunk.evaluate(this.properties[key])), { on: ", " })} } as const`;
+    }
+    toString() {
+        throw new Error("should never be called");
+    }
+}
+__decorate([
+    Memoize()
+], SchemaObject.prototype, "expression", null);
+__decorate([
+    Memoize()
+], SchemaObject.prototype, "literalExpression", null);
+(function (SchemaObject) {
+    /**
+     * Placeholder for abstract base classes.
+     */
+    class AbstractType {
+        ownerKind;
+        constructor(ownerKind) {
+            this.ownerKind = ownerKind;
+        }
+        get expression() {
+            throw new Error(`should never be called (instantiated by ${this.ownerKind})`);
+        }
+        toString() {
+            throw new Error("should never be called");
+        }
+    }
+    SchemaObject.AbstractType = AbstractType;
+    /**
+     * A built-in schema object type from a snippet or import.
+     */
+    class BuiltinType {
+        expression;
+        constructor(expression) {
+            this.expression = code `${expression}`;
+        }
+        toString() {
+            throw new Error("should never be called");
+        }
+    }
+    SchemaObject.BuiltinType = BuiltinType;
+    /**
+     * A user-defined schema object type, typically corresponding to user-defined types.
+     */
+    class UserDefinedType {
+        /**
+         * Members of the schema object type, usually property signatures like name: string.
+         *
+         * Note the name is repeated between the key and the value:
+         *   { name: code`name: string` }
+         * This enables overwriting in the *Type tree. Unlike property assignments (above),
+         * we don't really need to support other member types (index signatures, methods, et al.).
+         * Rather, the name is repeated here for consistency with property assignments.
+         */
+        members;
+        /**
+         * Name of the type, can be used in type annotations.
+         */
+        name;
+        constructor({ members, name, }) {
+            this.members = members;
+            this.name = name;
+        }
+        /**
+         * Expression of the schema object type, either the name or a literal expression.
+         */
+        get expression() {
+            return this.name.orDefaultLazy(() => this.literalExpression);
+        }
+        /**
+         * Literal expression of the schema object type e.g., { name1: string, name2: string }.
+         */
+        get literalExpression() {
+            return code `{ ${joinCode(Object.keys(this.members)
+                .sort()
+                .map((key) => code `${CodeThunk.evaluate(this.members[key])};`))} }`;
+        }
+        toString() {
+            throw new Error("should never be called");
+        }
+    }
+    __decorate([
+        Memoize()
+    ], UserDefinedType.prototype, "expression", null);
+    __decorate([
+        Memoize()
+    ], UserDefinedType.prototype, "literalExpression", null);
+    SchemaObject.UserDefinedType = UserDefinedType;
+})(SchemaObject || (SchemaObject = {}));
+//# sourceMappingURL=SchemaObject.js.map

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

@@ -0,0 +1,4 @@
+import type { AbstractUserDefinedType } from "../AbstractUserDefinedType.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType_jsonObjectType(this: ObjectType): AbstractUserDefinedType["jsonObjectType"];
+//# sourceMappingURL=ObjectType_jsonObjectType.d.ts.map

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

@@ -0,0 +1,26 @@
+import { InlineCallable } from "../InlineCallable.js";
+import { code, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonObjectType() {
+    // If the JSON object type is { "@id": string }, allow a shorthand of string => that type.
+    let shorthand;
+    this.identifierProperty.ifJust((identifierProperty) => {
+        const fromJsonObjectInitializerParameters = {
+            variables: { context: code ``, jsonObject: code ``, options: code `` },
+        };
+        if (this.properties.some((property) => !Object.is(property, identifierProperty) &&
+            property
+                .fromJsonObjectInitializer(fromJsonObjectInitializerParameters)
+                .isJust())) {
+            return;
+        }
+        shorthand = {
+            transformer: new InlineCallable(code `(id) => ({ ${literalOf(identifierProperty.jsonObjectMember.unsafeCoerce().name)}: id })`),
+            type: identifierProperty.type.jsonValueType,
+        };
+    });
+    return this.jsonTypeFactory.createJsonObjectType(this.properties.flatMap((property) => property.jsonObjectMember.toList()), {
+        name: this.name.map((name) => [name, "Json"]).extract(),
+        shorthand,
+    });
+}
+//# sourceMappingURL=ObjectType_jsonObjectType.js.map

package/dist/generators/ts/_snippets/snippets_LazySchema.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_LazySchema: SnippetFactory;
+//# sourceMappingURL=snippets_LazySchema.d.ts.map

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_LazySchema = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}LazySchema`, code `\
+interface ${syntheticNamePrefix}LazySchema<PartialSchemaT>{
+  readonly kind: "Lazy" | "LazyOption" | "LazySet";
+  readonly partialType: PartialSchemaT;
+}`);
+//# sourceMappingURL=snippets_LazySchema.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.99",
+    "@shaclmate/shacl-ast": "4.0.100",
     "@rdfjs/types": "~2.0.1",
     "@rdfx/collection": "0.0.59",
     "@rdfx/curie": "0.0.59",
@@ -136,6 +136,8 @@
     "dist/generators/index.js",
     "dist/generators/transformAstToLabeledPropertyGraph.d.ts",
     "dist/generators/transformAstToLabeledPropertyGraph.js",
+    "dist/generators/ts/AbstractBuiltinType.d.ts",
+    "dist/generators/ts/AbstractBuiltinType.js",
     "dist/generators/ts/AbstractCallable.d.ts",
     "dist/generators/ts/AbstractCallable.js",
     "dist/generators/ts/AbstractCollectionType.d.ts",
@@ -164,14 +166,14 @@
     "dist/generators/ts/AbstractObjectSetType.js",
     "dist/generators/ts/AbstractPrimitiveType.d.ts",
     "dist/generators/ts/AbstractPrimitiveType.js",
-    "dist/generators/ts/AbstractStructuredType.d.ts",
-    "dist/generators/ts/AbstractStructuredType.js",
     "dist/generators/ts/AbstractTermType.d.ts",
     "dist/generators/ts/AbstractTermType.js",
     "dist/generators/ts/AbstractType.d.ts",
     "dist/generators/ts/AbstractType.js",
     "dist/generators/ts/AbstractTypedLiteralType.d.ts",
     "dist/generators/ts/AbstractTypedLiteralType.js",
+    "dist/generators/ts/AbstractUserDefinedType.d.ts",
+    "dist/generators/ts/AbstractUserDefinedType.js",
     "dist/generators/ts/BigDecimalType.d.ts",
     "dist/generators/ts/BigDecimalType.js",
     "dist/generators/ts/BigIntType.d.ts",
@@ -180,6 +182,8 @@
     "dist/generators/ts/BlankNodeType.js",
     "dist/generators/ts/BooleanType.d.ts",
     "dist/generators/ts/BooleanType.js",
+    "dist/generators/ts/BuiltinCallable.d.ts",
+    "dist/generators/ts/BuiltinCallable.js",
     "dist/generators/ts/Callable.d.ts",
     "dist/generators/ts/Callable.js",
     "dist/generators/ts/CodeThunk.d.ts",
@@ -234,10 +238,10 @@
     "dist/generators/ts/OptionType.js",
     "dist/generators/ts/RdfjsDatasetObjectSetType.d.ts",
     "dist/generators/ts/RdfjsDatasetObjectSetType.js",
-    "dist/generators/ts/ReferenceCallable.d.ts",
-    "dist/generators/ts/ReferenceCallable.js",
     "dist/generators/ts/Reusables.d.ts",
     "dist/generators/ts/Reusables.js",
+    "dist/generators/ts/SchemaObject.d.ts",
+    "dist/generators/ts/SchemaObject.js",
     "dist/generators/ts/Service.d.ts",
     "dist/generators/ts/Service.js",
     "dist/generators/ts/SetType.d.ts",
@@ -288,8 +292,6 @@
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inferDiscriminant.js",
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inlineExpression.d.ts",
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inlineExpression.js",
-    "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.d.ts",
-    "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.js",
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonObjectFunction.d.ts",
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonObjectFunction.js",
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toLoggableFunction.d.ts",
@@ -412,12 +414,10 @@
     "dist/generators/ts/_ObjectType/ObjectType_hashFunction.js",
     "dist/generators/ts/_ObjectType/ObjectType_identifierTypeDeclarations.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_identifierTypeDeclarations.js",
+    "dist/generators/ts/_ObjectType/ObjectType_jsonObjectType.d.ts",
+    "dist/generators/ts/_ObjectType/ObjectType_jsonObjectType.js",
     "dist/generators/ts/_ObjectType/ObjectType_objectSetMethodNames.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_objectSetMethodNames.js",
-    "dist/generators/ts/_ObjectType/ObjectType_schemaExpression.d.ts",
-    "dist/generators/ts/_ObjectType/ObjectType_schemaExpression.js",
-    "dist/generators/ts/_ObjectType/ObjectType_schemaTypeExpression.d.ts",
-    "dist/generators/ts/_ObjectType/ObjectType_schemaTypeExpression.js",
     "dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryFunction.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryFunction.js",
     "dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryStringFunction.d.ts",
@@ -500,6 +500,8 @@
     "dist/generators/ts/_snippets/snippets_Lazy.js",
     "dist/generators/ts/_snippets/snippets_LazyOption.d.ts",
     "dist/generators/ts/_snippets/snippets_LazyOption.js",
+    "dist/generators/ts/_snippets/snippets_LazySchema.d.ts",
+    "dist/generators/ts/_snippets/snippets_LazySchema.js",
     "dist/generators/ts/_snippets/snippets_LazySet.d.ts",
     "dist/generators/ts/_snippets/snippets_LazySet.js",
     "dist/generators/ts/_snippets/snippets_LiteralFilter.d.ts",
@@ -976,5 +978,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.99"
+  "version": "4.0.100"
 }