@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -2,64 +2,67 @@ import { Maybe } from "purify-ts";
 export function transformAstToLabeledPropertyGraph(ast) {
     const nodes = [];
     const relationships = [];
-    for (const namedObjectType of ast.namedObjectTypes) {
-        const id = typeId(namedObjectType);
-        const properties = {
-            name: { type: "string", value: typeName(namedObjectType) },
-        };
-        for (const namedObjectTypeProperty of namedObjectType.properties) {
-            let itemType;
-            switch (namedObjectTypeProperty.type.kind) {
-                case "DefaultValue":
-                case "List":
-                case "Option":
-                case "Set":
-                    itemType = namedObjectTypeProperty.type.itemType;
-                    break;
-                case "LazyObject":
-                    itemType = namedObjectTypeProperty.type.resolveType;
-                    break;
-                case "LazyObjectOption":
-                case "LazyObjectSet":
-                    itemType = namedObjectTypeProperty.type.resolveType.itemType;
-                    break;
-                default:
-                    itemType = namedObjectTypeProperty.type;
-                    break;
-            }
-            switch (itemType.kind) {
-                case "Intersection":
-                case "Object":
-                case "Union":
-                    if (itemType.name.isJust()) {
-                        relationships.push({
-                            id: namedObjectTypeProperty.shapeIdentifier.toString(),
-                            label: Maybe.of(namedObjectTypeProperty.name),
-                            properties: {},
-                            sourceNodeId: id,
-                            targetNodeId: typeId(itemType),
-                        });
-                    }
-                    break;
-                default:
-                    properties[namedObjectTypeProperty.name] = {
-                        type: "string",
-                        value: namedObjectTypeProperty.toString(),
-                    };
+    for (const namedType of ast.namedTypes) {
+        if (namedType.kind === "Struct") {
+            const namedStructType = namedType;
+            const id = typeId(namedType);
+            const properties = {
+                name: { type: "string", value: typeName(namedType) },
+            };
+            for (const namedObjectTypeProperty of namedStructType.fields) {
+                let itemType;
+                switch (namedObjectTypeProperty.type.kind) {
+                    case "DefaultValue":
+                    case "List":
+                    case "Option":
+                    case "Set":
+                        itemType = namedObjectTypeProperty.type.itemType;
+                        break;
+                    case "Lazy":
+                        itemType = namedObjectTypeProperty.type.resolveType;
+                        break;
+                    case "LazyOption":
+                    case "LazySet":
+                        itemType = namedObjectTypeProperty.type.resolveType.itemType;
+                        break;
+                    default:
+                        itemType = namedObjectTypeProperty.type;
+                        break;
+                }
+                switch (itemType.kind) {
+                    case "Intersection":
+                    case "Struct":
+                    case "Union":
+                        if (itemType.name.isJust()) {
+                            relationships.push({
+                                id: namedObjectTypeProperty.shapeIdentifier.toString(),
+                                label: Maybe.of(namedObjectTypeProperty.name),
+                                properties: {},
+                                sourceNodeId: id,
+                                targetNodeId: typeId(itemType),
+                            });
+                        }
+                        break;
+                    default:
+                        properties[namedObjectTypeProperty.name] = {
+                            type: "string",
+                            value: namedObjectTypeProperty.toString(),
+                        };
+                }
             }
+            nodes.push({
+                id,
+                label: typeName(namedStructType),
+                properties: properties,
+            });
+        }
+        else if (namedType.kind === "Union") {
+            nodes.push({
+                id: typeId(namedType),
+                label: typeName(namedType),
+                properties: {},
+            });
         }
-        nodes.push({
-            id,
-            label: typeName(namedObjectType),
-            properties: properties,
-        });
-    }
-    for (const namedUnionType of ast.namedUnionTypes) {
-        nodes.push({
-            id: typeId(namedUnionType),
-            label: typeName(namedUnionType),
-            properties: {},
-        });
     }
     return {
         nodes,

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -1,21 +1,16 @@
 import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import type { AbstractType } from "./AbstractType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
  */
 export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractCollectionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     protected readonly _mutable: boolean;
-    protected readonly minCount: bigint;
     readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
-    readonly typeofs: "object"[];
-    constructor({ minCount, mutable, ...superParameters }: {
-        minCount: bigint;
+    constructor({ mutable, ...superParameters }: {
         mutable: boolean;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
-    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     get equalsFunction(): Code;
     get expression(): Code;
     get filterFunction(): Code;
@@ -25,20 +20,18 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     get mutable(): boolean;
     get schemaType(): Code;
     get validationFunction(): Maybe<Code>;
-    protected get schemaInitializers(): readonly Code[];
-    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
 }
 export declare namespace AbstractCollectionType {
+    type ConversionFunction = AbstractContainerType.ConversionFunction;
     type DiscriminantProperty = AbstractContainerType.DiscriminantProperty;
-    const GraphqlType: typeof AbstractType.GraphqlType;
+    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     type GraphqlType = AbstractContainerType.GraphqlType;
     const isItemType: typeof AbstractContainerType.isItemType;
     type ItemType = AbstractContainerType.ItemType;
-    const JsonType: typeof AbstractType.JsonType;
+    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
     type JsonType = AbstractContainerType.JsonType;
 }
 //# sourceMappingURL=AbstractCollectionType.d.ts.map

package/dist/generators/ts/AbstractCollectionType.js

@@ -5,46 +5,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
  */
 export class AbstractCollectionType extends AbstractContainerType {
     _mutable;
-    minCount;
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
-    typeofs = ["object"];
-    constructor({ minCount, mutable, ...superParameters }) {
+    constructor({ mutable, ...superParameters }) {
         super(superParameters);
-        this.minCount = minCount;
-        invariant(this.minCount >= 0n);
         this._mutable = mutable;
-        if (mutable) {
-            invariant(this.minCount === 0n);
-        }
-    }
-    get conversionFunction() {
-        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
-        const sourceTypes = [
-            {
-                expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
-                typeof: "object",
-            },
-        ];
-        if (this.minCount === 0n) {
-            sourceTypes.push({
-                expression: code `undefined`,
-                typeof: "undefined",
-            });
-        }
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToArray}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
-            sourceTypes,
-        });
     }
     get equalsFunction() {
         return code `((left, right) => ${this.reusables.snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction}))`;
@@ -59,7 +32,7 @@ export class AbstractCollectionType extends AbstractContainerType {
         return code `${this.reusables.snippets.CollectionFilter}<${this.itemType.filterType}>`;
     }
     get graphqlType() {
-        return new AbstractContainerType.GraphqlType(code `new ${this.reusables.imports.GraphQLList}(${this.itemType.graphqlType.name})`, this.reusables);
+        return new AbstractContainerType.GraphqlType(code `new ${this.reusables.imports.GraphQLList}(${this.itemType.graphqlType.expression})`, this.reusables);
     }
     get hashFunction() {
         return code `${this.reusables.snippets.hashArray}(${this.itemType.hashFunction})`;
@@ -73,38 +46,9 @@ export class AbstractCollectionType extends AbstractContainerType {
     get validationFunction() {
         return Maybe.of(code `${this.reusables.snippets.validateArray}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)}, ${literalOf(!this._mutable)})`);
     }
-    get schemaInitializers() {
-        let schemaInitializers = super.schemaInitializers;
-        if (this.minCount > 0n) {
-            schemaInitializers = schemaInitializers.concat(code `minCount: ${Number(this.minCount)}`);
-        }
-        return schemaInitializers;
-    }
-    fromJsonExpression({ variables, }) {
-        let expression = variables.value;
-        if (this.minCount === 0n) {
-            expression = code `(${expression} ?? [])`;
-        }
-        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${expression}.map(item => (${this.itemType.fromJsonExpression({
-            variables: { value: code `item` },
-        })})))`;
-    }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
-    jsonSchema(parameters) {
-        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
-        if (this.minCount > 0n) {
-            schema = code `${schema}.nonempty().min(${this.minCount})`;
-        }
-        else {
-            schema = code `${schema}.optional()`;
-        }
-        if (!this._mutable) {
-            schema = code `${schema}.readonly()`;
-        }
-        return schema;
-    }
     jsonUiSchemaElement(parameters) {
         return this.itemType.jsonUiSchemaElement(parameters);
     }
@@ -112,9 +56,6 @@ export class AbstractCollectionType extends AbstractContainerType {
         return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })}))`;
     }
 }
-__decorate([
-    Memoize()
-], AbstractCollectionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "equalsFunction", null);

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -35,8 +35,7 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
         itemType: ItemTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get recursive(): boolean;
-    get referencesObjectType(): boolean;
-    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
+    get referencesNamedType(): boolean;
     protected get itemConversionFunctionDefault(): AbstractType.ConversionFunction;
     protected get itemValidationFunctionDefault(): Code;
     protected get schemaInitializers(): readonly Code[];

package/dist/generators/ts/AbstractContainerType.js

@@ -26,11 +26,8 @@ export class AbstractContainerType extends AbstractType {
     get recursive() {
         return this.itemType.recursive;
     }
-    get referencesObjectType() {
-        return this.itemType.referencesObjectType;
-    }
-    get toRdfResourceValueTypes() {
-        return this.itemType.toRdfResourceValueTypes;
+    get referencesNamedType() {
+        return this.name.isJust() || this.itemType.referencesNamedType;
     }
     get itemConversionFunctionDefault() {
         return {
@@ -38,7 +35,7 @@ export class AbstractContainerType extends AbstractType {
             sourceTypes: [
                 {
                     expression: this.itemType.expression,
-                    typeof: this.itemType.typeofs[0],
+                    jsType: this.itemType.jsTypes[0],
                 },
             ],
         };
@@ -48,7 +45,7 @@ export class AbstractContainerType extends AbstractType {
     }
     get schemaInitializers() {
         const initializers = super.schemaInitializers.concat();
-        if (this.recursive || this.itemType.referencesObjectType) {
+        if (this.recursive || this.referencesNamedType) {
             initializers.push(code `get itemType() { return ${this.itemType.schema}; }`);
         }
         else {
@@ -86,9 +83,9 @@ __decorate([
             case "Union":
                 return true;
             case "DefaultValue":
-            case "LazyObjectOption":
-            case "LazyObjectSet":
-            case "LazyObject":
+            case "LazyOption":
+            case "LazySet":
+            case "Lazy":
             case "Option":
             case "Set":
                 return false;

package/dist/generators/ts/AbstractDateType.d.ts

@@ -1,24 +1,21 @@
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractDateType extends AbstractPrimitiveType<Date> {
+    protected readonly inlineExpression: Code;
     readonly equalsFunction: Code;
-    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Date";
+        readonly typeof: "object";
+    }];
     abstract readonly kind: "DateTime" | "Date";
     readonly mutable = false;
     readonly schemaType: Code;
-    readonly typeofs: "object"[];
     readonly valueSparqlWherePatternsFunction: Code;
     fromJsonExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromJsonExpression"]>[0]): Code;
     jsonType(): AbstractPrimitiveType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
-    protected abstract fromRdfResourceValueExpression(variables: {
-        variables: {
-            value: Code;
-        };
-    }): Code;
-    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>;
 }
 export declare namespace AbstractDateType {
     type ConversionFunction = AbstractPrimitiveType.ConversionFunction;

package/dist/generators/ts/AbstractDateType.js

@@ -8,13 +8,18 @@ import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractDateType extends AbstractPrimitiveType {
+    inlineExpression = code `Date`;
     equalsFunction = code `${this.reusables.snippets.dateEquals}`;
-    expression = code `Date`;
     filterFunction = code `${this.reusables.snippets.filterDate}`;
     filterType = code `${this.reusables.snippets.DateFilter}`;
+    jsTypes = [
+        {
+            instanceof: "Date",
+            typeof: "object",
+        },
+    ];
     mutable = false;
     schemaType = code `${this.reusables.snippets.DateSchema}`;
-    typeofs = ["object"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.Either}.of<Error, Date>(new Date(${variables.value}))`;
@@ -25,16 +30,6 @@ export class AbstractDateType extends AbstractPrimitiveType {
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.date(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
-    fromRdfResourceValuesExpressionChain({ variables, }) {
-        return {
-            ...super.fromRdfResourceValuesExpressionChain({ variables }),
-            languageIn: undefined,
-            preferredLanguages: undefined,
-            valueTo: code `chain(values => values.chainMap(value => ${this.fromRdfResourceValueExpression({
-                variables: { value: code `value` },
-            })}))`,
-        };
-    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/AbstractIdentifierType.d.ts

@@ -3,6 +3,10 @@ import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNode | NamedNode> extends AbstractTermType<NamedNode, IdentifierT> {
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     abstract readonly kind: "BlankNode" | "Identifier" | "Iri";
     abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     abstract readonly parseFunction: Code;

package/dist/generators/ts/AbstractIdentifierType.js

@@ -8,6 +8,9 @@ import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractIdentifierType extends AbstractTermType {
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     stringifyFunction = code `${this.reusables.imports.NTriplesTerm}.stringify`;
     get graphqlType() {
         return new AbstractTermType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);

package/dist/generators/ts/{AbstractLazyObjectType.d.ts → AbstractLazyType.d.ts}

@@ -5,7 +5,7 @@ import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractLazyObjectType<PartialTypeT extends AbstractLazyObjectType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyObjectType.ResolveTypeConstraint> extends AbstractType {
+export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazyType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyType.ResolveTypeConstraint> extends AbstractType {
     protected readonly partialType: PartialTypeT;
     protected readonly resolveType: ResolveTypeT;
     protected abstract readonly runtimeClass: {
@@ -16,8 +16,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     readonly declaration: Maybe<Code>;
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;
-    readonly referencesObjectType = true;
-    readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;
     constructor({ partialType, resolveType, ...superParameters }: {
         partialType: PartialTypeT;
@@ -29,7 +27,9 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     get filterType(): Code;
     get graphqlType(): AbstractType.GraphqlType;
     get hashFunction(): Code;
+    get jsTypes(): readonly AbstractType.JsType[];
     get recursive(): boolean;
+    get referencesNamedType(): boolean;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
@@ -41,7 +41,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    protected resolveToPartialFunction<ObjectTypeT extends AbstractLazyObjectType.ObjectTypeConstraint>({ partialType, resolveType, }: {
+    protected resolveToPartialFunction<ObjectTypeT extends AbstractLazyType.ItemTypeConstraint>({ partialType, resolveType, }: {
         partialType: ObjectTypeT;
         resolveType: ObjectTypeT;
     }): Code;
@@ -53,9 +53,9 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         };
     }): Code;
 }
-export declare namespace AbstractLazyObjectType {
-    type ObjectTypeConstraint = ObjectType | ObjectUnionType;
-    type PartialTypeConstraint = ObjectTypeConstraint | OptionType<ObjectTypeConstraint> | SetType<ObjectTypeConstraint>;
+export declare namespace AbstractLazyType {
+    type ItemTypeConstraint = ObjectType | ObjectUnionType;
+    type PartialTypeConstraint = ItemTypeConstraint | OptionType<ItemTypeConstraint> | SetType<ItemTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
     type ConversionFunction = AbstractType.ConversionFunction;
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
@@ -64,4 +64,4 @@ export declare namespace AbstractLazyObjectType {
     const JsonType: typeof AbstractType.JsonType;
     type JsonType = AbstractType.JsonType;
 }
-//# sourceMappingURL=AbstractLazyObjectType.d.ts.map
+//# sourceMappingURL=AbstractLazyType.d.ts.map

package/dist/generators/ts/{AbstractLazyObjectType.js → AbstractLazyType.js}

@@ -9,14 +9,12 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
-export class AbstractLazyObjectType extends AbstractType {
+export class AbstractLazyType extends AbstractType {
     partialType;
     resolveType;
     declaration = Maybe.empty();
     discriminantProperty = Maybe.empty();
     mutable = false;
-    referencesObjectType = true;
-    typeofs = ["object"];
     validationFunction = Maybe.empty();
     constructor({ partialType, resolveType, ...superParameters }) {
         super(superParameters);
@@ -41,9 +39,21 @@ export class AbstractLazyObjectType extends AbstractType {
     get hashFunction() {
         return code `((hasher, value) => ${this.partialType.hashFunction}(hasher, value.${this.runtimeClass.partialPropertyName}))`;
     }
+    get jsTypes() {
+        return [
+            {
+                className: this.runtimeClass.rawName,
+                instanceof: "class",
+                typeof: "object",
+            },
+        ];
+    }
     get recursive() {
         return this.partialType.recursive;
     }
+    get referencesNamedType() {
+        return this.partialType.referencesNamedType;
+    }
     get schemaType() {
         return code `${{
             kind: this.kind,
@@ -95,13 +105,13 @@ export class AbstractLazyObjectType extends AbstractType {
     }
     resolveToPartialFunction({ partialType, resolveType, }) {
         if (partialType.kind === "Object") {
-            return code `${partialType.alias.unsafeCoerce()}.createUnsafe`;
+            return code `${partialType.name.unsafeCoerce()}.createUnsafe`;
         }
         invariant(partialType.kind === "ObjectUnion");
         invariant(resolveType.kind === "ObjectUnion");
         invariant(partialType.members.length === resolveType.members.length);
         const caseBlocks = resolveType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialType.members[memberI].type.alias.unsafeCoerce()}.createUnsafe(resolved);`;
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialType.members[memberI].type.name.unsafeCoerce()}.createUnsafe(resolved);`;
         });
         caseBlocks.push(code `default: resolved satisfies never; throw new Error("unrecognized type");`);
         return code `((resolved: ${resolveType.expression}) => { switch (resolved.${resolveType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} } })`;
@@ -110,7 +120,7 @@ export class AbstractLazyObjectType extends AbstractType {
         invariant(resolvedObjectUnionType.members.length ===
             partialObjectUnionType.members.length);
         const caseBlocks = resolvedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectUnionType.members[memberI].type.alias.unsafeCoerce()}.create(${variables.resolvedObjectUnion});`;
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectUnionType.members[memberI].type.name.unsafeCoerce()}.create(${variables.resolvedObjectUnion});`;
         });
         caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
         return code `switch (${variables.resolvedObjectUnion}.${resolvedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
@@ -118,24 +128,27 @@ export class AbstractLazyObjectType extends AbstractType {
 }
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "equalsFunction", null);
+], AbstractLazyType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyType.prototype, "filterFunction", null);
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "filterFunction", null);
+], AbstractLazyType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "hashFunction", null);
+], AbstractLazyType.prototype, "jsTypes", null);
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "schemaType", null);
+], AbstractLazyType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
+], AbstractLazyType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "valueSparqlWherePatternsFunction", null);
-(function (AbstractLazyObjectType) {
-    AbstractLazyObjectType.GraphqlType = AbstractType.GraphqlType;
-    AbstractLazyObjectType.JsonType = AbstractType.JsonType;
-})(AbstractLazyObjectType || (AbstractLazyObjectType = {}));
-//# sourceMappingURL=AbstractLazyObjectType.js.map
+], AbstractLazyType.prototype, "valueSparqlWherePatternsFunction", null);
+(function (AbstractLazyType) {
+    AbstractLazyType.GraphqlType = AbstractType.GraphqlType;
+    AbstractLazyType.JsonType = AbstractType.JsonType;
+})(AbstractLazyType || (AbstractLazyType = {}));
+//# sourceMappingURL=AbstractLazyType.js.map

package/dist/generators/ts/AbstractLiteralType.d.ts

@@ -1,27 +1,25 @@
 import type { Literal } from "@rdfjs/types";
 import { AbstractTermType } from "./AbstractTermType.js";
-import { type Code } from "./ts-poet-wrapper.js";
+import type { Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractLiteralType extends AbstractTermType<Literal, Literal> {
     protected readonly languageIn: readonly string[];
     readonly nodeKinds: ReadonlySet<"Literal">;
     constructor({ languageIn, ...superParameters }: {
         languageIn: readonly string[];
     } & ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0]);
-    get constrained(): boolean;
-    protected get schemaInitializers(): readonly Code[];
     /**
      * An expression that converts a compile-time RDF/JS Literal into a runtime TypeScript literal.
      *
      * For example, a string would be converted to "thestring".
      */
-    abstract literalExpression(literal: Literal): Code;
-    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractTermType<Literal, Literal>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractTermType<Literal, Literal>["fromRdfResourceValuesExpressionChain"]>;
+    abstract literalValueExpression(literal: Literal): Code;
 }
 export declare namespace AbstractLiteralType {
     type ConversionFunction = AbstractTermType.ConversionFunction;
     type DiscriminantProperty = AbstractTermType.DiscriminantProperty;
     const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     type GraphqlType = AbstractTermType.GraphqlType;
+    type JsType = AbstractTermType.JsType;
     const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
     type JsonType = AbstractTermType.JsonType;
 }

package/dist/generators/ts/AbstractLiteralType.js

@@ -1,5 +1,4 @@
 import { AbstractTermType } from "./AbstractTermType.js";
-import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class AbstractLiteralType extends AbstractTermType {
     languageIn;
     nodeKinds = nodeKinds;
@@ -7,26 +6,6 @@ export class AbstractLiteralType extends AbstractTermType {
         super(superParameters);
         this.languageIn = languageIn;
     }
-    get constrained() {
-        return super.constrained || this.languageIn.length > 0;
-    }
-    get schemaInitializers() {
-        let initializers = super.schemaInitializers;
-        if (this.languageIn.length > 0) {
-            initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
-        }
-        return initializers;
-    }
-    fromRdfResourceValuesExpressionChain({ variables, }) {
-        return {
-            ...super.fromRdfResourceValuesExpressionChain({ variables }),
-            languageIn: this.languageIn.length > 0
-                ? code `chain(values => ${this.reusables.snippets.fromRdfLanguageIn}(values, ${JSON.stringify(this.languageIn)}))`
-                : undefined,
-            preferredLanguages: code `chain(values => ${this.reusables.snippets.fromRdfPreferredLanguages}(values, ${variables.preferredLanguages}))`,
-            valueTo: code `chain(values => values.chainMap(value => value.toLiteral()))`,
-        };
-    }
 }
 (function (AbstractLiteralType) {
     AbstractLiteralType.GraphqlType = AbstractTermType.GraphqlType;