@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/generators/ts/AbstractDateType.js

@@ -17,7 +17,7 @@ export class AbstractDateType extends AbstractPrimitiveType {
     mutable = false;
     name = "Date";
     schemaType = code `${snippets.DateSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.dateSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.dateSparqlWherePatterns}`;
     typeofs = NonEmptyList(["object"]);
     get conversions() {
         return [
@@ -48,7 +48,7 @@ export class AbstractDateType extends AbstractPrimitiveType {
     jsonType() {
         return new AbstractPrimitiveType.JsonType(code `string`);
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${snippets.literalFactory}.date(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {

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

@@ -1,7 +1,7 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
-import { type Code } from "ts-poet";
 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> {
     abstract readonly fromStringFunction: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;

package/dist/generators/ts/AbstractIdentifierType.js

@@ -4,10 +4,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { code } from "ts-poet";
 import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { imports } from "./imports.js";
+import { code } from "./ts-poet-wrapper.js";
 export class AbstractIdentifierType extends AbstractTermType {
     graphqlType = new AbstractTermType.GraphqlType(code `${imports.GraphQLString}`);
     toStringFunction = // Re-export rdfjsResource.Resource.Identifier.toString

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -1,7 +1,7 @@
 import { Maybe, NonEmptyList } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -13,6 +13,8 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         readonly partialPropertyName: string;
         readonly rawName: Code;
     };
+    readonly abstract = false;
+    readonly declaration: Maybe<Code>;
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;
     readonly typeofs: NonEmptyList<"object">;
@@ -27,10 +29,11 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     get filterType(): Code;
     get graphqlType(): AbstractType.GraphqlType;
     get name(): Code;
+    get recursive(): boolean;
     get schema(): Code;
     get schemaType(): Code;
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
         partial: Code;
         kind: Code;
@@ -38,19 +41,19 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonZodSchema(parameters: Parameters<AbstractType["jsonZodSchema"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractType["toRdfExpression"]>[0]): Code;
-    protected resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }: {
-        resolvedObjectUnionType: ObjectUnionType;
-        partialObjectUnionType: ObjectUnionType;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    protected resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }: {
+        resolvedNamedObjectUnionType: NamedObjectUnionType;
+        partialNamedObjectUnionType: NamedObjectUnionType;
         variables: {
             resolvedObjectUnion: Code;
         };
     }): Code;
 }
 export declare namespace AbstractLazyObjectType {
-    type ObjectTypeConstraint = ObjectType | ObjectUnionType;
+    type ObjectTypeConstraint = NamedObjectType | NamedObjectUnionType;
     type PartialTypeConstraint = ObjectTypeConstraint | OptionType<ObjectTypeConstraint> | SetType<ObjectTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
     type Conversion = AbstractType.Conversion;

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -14,6 +14,8 @@ export class AbstractLazyObjectType extends AbstractType {
     partialType;
     resolveType;
     runtimeClass;
+    abstract = false;
+    declaration = Maybe.empty();
     discriminantProperty = Maybe.empty();
     mutable = false;
     typeofs = NonEmptyList(["object"]);
@@ -48,6 +50,9 @@ export class AbstractLazyObjectType extends AbstractType {
     get name() {
         return this.runtimeClass.name;
     }
+    get recursive() {
+        return this.partialType.recursive;
+    }
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
@@ -58,11 +63,11 @@ export class AbstractLazyObjectType extends AbstractType {
             resolveType: this.resolveType.schemaType,
         }}`;
     }
-    get sparqlConstructTriplesFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partial() }))`;
+    get valueSparqlConstructTriplesFunction() {
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partial() }))`;
     }
-    get sparqlWherePatternsFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partial() }))`;
+    get valueSparqlWherePatternsFunction() {
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partial() }))`;
     }
     get schemaObject() {
         return {
@@ -87,8 +92,8 @@ export class AbstractLazyObjectType extends AbstractType {
     jsonUiSchemaElement(parameters) {
         return this.partialType.jsonUiSchemaElement(parameters);
     }
-    jsonZodSchema(parameters) {
-        return this.partialType.jsonZodSchema(parameters);
+    jsonSchema(parameters) {
+        return this.partialType.jsonSchema(parameters);
     }
     toJsonExpression({ variables, }) {
         return this.partialType.toJsonExpression({
@@ -97,22 +102,22 @@ export class AbstractLazyObjectType extends AbstractType {
             },
         });
     }
-    toRdfExpression({ variables, }) {
-        return this.partialType.toRdfExpression({
+    toRdfResourceValuesExpression({ variables, }) {
+        return this.partialType.toRdfResourceValuesExpression({
             variables: {
                 ...variables,
                 value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
             },
         });
     }
-    resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }) {
-        invariant(resolvedObjectUnionType.memberTypes.length ===
-            partialObjectUnionType.memberTypes.length);
-        const caseBlocks = resolvedObjectUnionType.memberTypes.map((resolvedObjectType, objectTypeI) => {
-            return code `${resolvedObjectType.discriminantPropertyValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectUnionType.memberTypes[objectTypeI].newExpression({ parameters: variables.resolvedObjectUnion })};`;
+    resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }) {
+        invariant(resolvedNamedObjectUnionType.members.length ===
+            partialNamedObjectUnionType.members.length);
+        const caseBlocks = resolvedNamedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.newExpression({ parameters: 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)} }`;
+        return code `switch (${variables.resolvedObjectUnion}.${resolvedNamedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
     }
 }
 __decorate([
@@ -129,10 +134,10 @@ __decorate([
 ], AbstractLazyObjectType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "sparqlConstructTriplesFunction", null);
+], AbstractLazyObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "sparqlWherePatternsFunction", null);
+], AbstractLazyObjectType.prototype, "valueSparqlWherePatternsFunction", null);
 (function (AbstractLazyObjectType) {
     AbstractLazyObjectType.GraphqlType = AbstractType.GraphqlType;
     AbstractLazyObjectType.JsonType = AbstractType.JsonType;

package/dist/generators/ts/AbstractNamedUnionType.d.ts

@@ -0,0 +1,33 @@
+import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../enums/TsFeature.js";
+import { AbstractType } from "./AbstractType.js";
+import { AbstractUnionType } from "./AbstractUnionType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> extends AbstractUnionType<MemberTypeT> {
+    protected readonly _name: string;
+    readonly features: ReadonlySet<TsFeature>;
+    constructor({ features, name, ...superParameters }: {
+        features: ReadonlySet<TsFeature>;
+        name: string;
+    } & ConstructorParameters<typeof AbstractUnionType<MemberTypeT>>[0]);
+    get declaration(): Maybe<Code>;
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get jsonTypeAliasDeclaration(): Code;
+    get jsonSchemaFunctionDeclaration(): Code;
+    get name(): string;
+    get staticModuleName(): string;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    protected get staticModuleDeclarations(): Record<string, Code>;
+    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
+    hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    jsonType(): AbstractType.JsonType;
+    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+}
+//# sourceMappingURL=AbstractNamedUnionType.d.ts.map

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -0,0 +1,195 @@
+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 { AbstractType } from "./AbstractType.js";
+import { AbstractUnionType } from "./AbstractUnionType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code, def, joinCode } from "./ts-poet-wrapper.js";
+export class AbstractNamedUnionType extends AbstractUnionType {
+    _name;
+    features;
+    constructor({ features, name, ...superParameters }) {
+        super(superParameters);
+        this.features = features;
+        this._name = name;
+    }
+    get declaration() {
+        const declarations = [
+            code `export type ${def(this._name)} = ${this.inlineName};`,
+        ];
+        const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
+        if (staticModuleDeclarations.length > 0) {
+            declarations.push(code `\
+export namespace ${def(this.staticModuleName)} {
+${joinCode(staticModuleDeclarations
+                .sort((left, right) => left[0].localeCompare(right[0]))
+                .map((_) => _[1]), { on: "\n\n" })}
+}`);
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+    }
+    get equalsFunction() {
+        if (this.features.has("equals")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}equals`;
+        }
+        return this.inlineEqualsFunction;
+    }
+    get filterFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}filter`;
+    }
+    get filterType() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}Filter`;
+    }
+    get jsonTypeAliasDeclaration() {
+        return code `export type ${syntheticNamePrefix}Json = ${this.inlineJsonType.name}`;
+    }
+    get jsonSchemaFunctionDeclaration() {
+        return code `export const schema = () => ${this.inlineJsonSchema};`;
+    }
+    get name() {
+        return this._name;
+    }
+    get staticModuleName() {
+        return this._name;
+    }
+    get valueSparqlConstructTriplesFunction() {
+        if (this.features.has("sparql")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlConstructTriples`;
+        }
+        return this.inlineValueSparqlConstructTriplesFunction;
+    }
+    get valueSparqlWherePatternsFunction() {
+        if (this.features.has("sparql")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlWherePatterns`;
+        }
+        return this.inlineValueSparqlWherePatternsFunction;
+    }
+    get staticModuleDeclarations() {
+        const staticModuleDeclarations = {};
+        if (this.features.has("equals")) {
+            staticModuleDeclarations[`${syntheticNamePrefix}equals`] =
+                code `export const ${syntheticNamePrefix}equals = ${this.inlineEqualsFunction};`;
+        }
+        staticModuleDeclarations[`${syntheticNamePrefix}Filter`] =
+            code `export type ${syntheticNamePrefix}Filter = ${this.inlineFilterType};`;
+        staticModuleDeclarations[`${syntheticNamePrefix}filter`] =
+            code `export const ${syntheticNamePrefix}filter = ${this.inlineFilterFunction};`;
+        if (this.features.has("hash")) {
+            staticModuleDeclarations[`${syntheticNamePrefix}hash`] =
+                code `export function ${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(value: ${this._name}, hasher: HasherT): HasherT { ${this.inlineHashStatements({ depth: 0, variables: { hasher: code `hasher`, value: code `value` } })} return hasher; }`;
+        }
+        if (this.features.has("json")) {
+            staticModuleDeclarations[`${syntheticNamePrefix}Json`] = code `\
+${this.jsonTypeAliasDeclaration}
+
+export namespace ${syntheticNamePrefix}Json {
+  ${this.jsonSchemaFunctionDeclaration}
+
+  export function ${syntheticNamePrefix}parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
+    const jsonSafeParseResult = schema().safeParse(json);
+    if (!jsonSafeParseResult.success) { return ${imports.Left}(jsonSafeParseResult.error); }
+    return ${imports.Right}(jsonSafeParseResult.data);
+  }
+}`;
+            staticModuleDeclarations[`${syntheticNamePrefix}fromJson`] =
+                code `export const ${syntheticNamePrefix}fromJson = ${this.inlineFromJsonFunction};`;
+            staticModuleDeclarations[`${syntheticNamePrefix}toJson`] =
+                code `export const ${syntheticNamePrefix}toJson = ${this.inlineToJsonFunction};`;
+        }
+        if (this.features.has("rdf")) {
+            staticModuleDeclarations[`${syntheticNamePrefix}fromRdfResourceValues`] =
+                code `export const ${syntheticNamePrefix}fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
+            staticModuleDeclarations[`${syntheticNamePrefix}toRdfResourceValues`] =
+                code `export const ${syntheticNamePrefix}toRdfResourceValues: ${snippets.ToRdfResourceValuesFunction}<${this.name}> = ${this.inlineToRdfResourceValuesFunction};`;
+        }
+        if (this.features.has("sparql")) {
+            staticModuleDeclarations[`${syntheticNamePrefix}valueSparqlConstructTriples`] =
+                code `export const ${syntheticNamePrefix}valueSparqlConstructTriples: ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
+            staticModuleDeclarations[`${syntheticNamePrefix}valueSparqlWherePatterns`] =
+                code `export const ${syntheticNamePrefix}valueSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
+        }
+        return staticModuleDeclarations;
+    }
+    fromJsonExpression({ variables, }) {
+        if (this.features.has("json")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value})`;
+        }
+        return code `${this.inlineFromJsonFunction}(${variables.value})`;
+    }
+    fromRdfResourceValuesExpression({ variables, }) {
+        const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
+        if (this.features.has("rdf")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
+        }
+        return code `${this.inlineFromRdfResourceValuesFunction}(${resourceValuesVariable}, ${otherVariables})`;
+    }
+    hashStatements({ depth, variables, }) {
+        if (this.features.has("hash")) {
+            return [
+                code `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
+            ];
+        }
+        return this.inlineHashStatements({ depth, variables });
+    }
+    jsonType() {
+        if (this.features.has("json")) {
+            return new AbstractType.JsonType(`${this.staticModuleName}.${syntheticNamePrefix}Json`);
+        }
+        return this.inlineJsonType;
+    }
+    jsonSchema({ context, }) {
+        if (this.features.has("json")) {
+            const expression = code `${this.staticModuleName}.${syntheticNamePrefix}Json.schema()`;
+            if (context === "property" && this.recursive) {
+                return code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
+            }
+            return expression;
+        }
+        return this.inlineJsonSchema;
+    }
+    toJsonExpression({ variables, }) {
+        if (this.features.has("json")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
+        }
+        return code `${this.inlineToJsonFunction}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const { value: valueVariable, ...otherVariables } = variables;
+        if (this.features.has("rdf")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}toRdfResourceValues(${valueVariable}, ${otherVariables})`;
+        }
+        return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "name", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "jsonType", null);
+//# sourceMappingURL=AbstractNamedUnionType.js.map

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

@@ -9,14 +9,14 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
     get filterType(): Code;
     get name(): string;
     get schemaType(): Code;
-    get sparqlWherePatternsFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
         in: Code[] | undefined;
         languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
         kind: Code;
     };
-    jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonZodSchema"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfExpression"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonSchema"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>;
     protected abstract fromRdfResourceValueExpression(variables: {
         variables: {

package/dist/generators/ts/AbstractNumericType.js

@@ -29,7 +29,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
     get schemaType() {
         return code `${snippets.NumericSchema}<${this.typeofs[0]}>`;
     }
-    get sparqlWherePatternsFunction() {
+    get valueSparqlWherePatternsFunction() {
         return code `${snippets.numericSparqlWherePatterns}<${this.typeofs[0]}>`;
     }
     get schemaObject() {
@@ -40,7 +40,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
                 : undefined,
         };
     }
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
                 return code `${imports.z}.${this.typeofs[0]}()`;
@@ -50,7 +50,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
                 return code `${imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${imports.z}.literal(${this.literalOf(value)})`), { on: "," })}])`;
         }
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {
@@ -78,7 +78,7 @@ __decorate([
 ], AbstractNumericType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], AbstractNumericType.prototype, "sparqlWherePatternsFunction", null);
+], AbstractNumericType.prototype, "valueSparqlWherePatternsFunction", null);
 (function (AbstractNumericType) {
     AbstractNumericType.JsonType = AbstractPrimitiveType.JsonType;
 })(AbstractNumericType || (AbstractNumericType = {}));

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

@@ -13,12 +13,15 @@ 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 abstract = false;
+    readonly declaration: Maybe<Code>;
     readonly equalsFunction: Code;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly hasValues: readonly ConstantTermT[];
     readonly in_: readonly ConstantTermT[];
     readonly mutable: boolean;
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
+    readonly recursive = false;
     readonly typeofs: AbstractType["typeofs"];
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];
@@ -28,11 +31,11 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     get conversions(): readonly AbstractType.Conversion[];
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get schema(): Code;
-    get sparqlConstructTriplesFunction(): Code;
-    fromRdfExpression(parameters: Parameters<AbstractType["fromRdfExpression"]>[0]): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement(): Maybe<Code>;
-    toRdfExpression({ variables, }: Parameters<AbstractType["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     /**
      * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
      *
@@ -42,7 +45,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
      *
      * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
      */
-    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
+    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfResourceValuesExpression"]>[0]): {
         hasValues?: Code;
         languageIn?: Code;
         preferredLanguages?: Code;

package/dist/generators/ts/AbstractTermType.js

@@ -22,11 +22,14 @@ import { code, joinCode } 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 {
+    abstract = false;
+    declaration = Maybe.empty();
     equalsFunction = code `${snippets.booleanEquals}`;
     graphqlArgs = Maybe.empty();
     hasValues;
     in_;
     mutable = false;
+    recursive = false;
     typeofs = NonEmptyList([
         "object",
     ]);
@@ -87,10 +90,10 @@ export class AbstractTermType extends AbstractType {
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
-    get sparqlConstructTriplesFunction() {
+    get valueSparqlConstructTriplesFunction() {
         return code `((_: object) => [])`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         // invariant(
         //   this.nodeKinds.has("Literal") &&
         //     (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")),
@@ -115,7 +118,7 @@ export class AbstractTermType extends AbstractType {
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${variables.value}]`;
     }
     /**
@@ -163,7 +166,7 @@ __decorate([
 ], AbstractTermType.prototype, "schema", null);
 __decorate([
     Memoize()
-], AbstractTermType.prototype, "sparqlConstructTriplesFunction", null);
+], AbstractTermType.prototype, "valueSparqlConstructTriplesFunction", null);
 (function (AbstractTermType) {
     AbstractTermType.GraphqlType = AbstractType.GraphqlType;
     AbstractTermType.JsonType = AbstractType.JsonType;