@shaclmate/compiler 2.0.24 → 3.0.1

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstLiteralType.js

@@ -30,7 +30,7 @@ export function transformShapeToAstLiteralType(shape, shapeStack) {
                 hasValues: literalHasValues,
                 in_: literalIn,
                 kind: "LiteralType",
-                languageIn: shape.constraints.languageIn,
+                languageIn: [...new Set(shape.constraints.languageIn)],
                 maxExclusive: shape.constraints.maxExclusive,
                 maxInclusive: shape.constraints.maxInclusive,
                 minExclusive: shape.constraints.minExclusive,

package/dist/generators/ts/BooleanType.d.ts

@@ -1,4 +1,5 @@
 import { PrimitiveType } from "./PrimitiveType.js";
+import type { TermType } from "./TermType.js";
 import { Type } from "./Type.js";
 export declare class BooleanType extends PrimitiveType<boolean> {
     readonly kind = "BooleanType";
@@ -7,7 +8,7 @@ export declare class BooleanType extends PrimitiveType<boolean> {
     get graphqlName(): Type.GraphqlName;
     get name(): string;
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<boolean>["fromRdfResourceValueExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -43,13 +43,18 @@ export class BooleanType extends PrimitiveType {
         }
         return `${variables.zod}.boolean()`;
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        let expression = `${variables.resourceValue}.toBoolean()`;
+    fromRdfExpressionChain({ variables, }) {
+        let fromRdfResourceValueExpression = "value.toBoolean()";
         if (this.primitiveIn.length === 1) {
             const eitherTypeParameters = `<Error, ${this.name}>`;
-            expression = `${expression}.chain(value => value === ${this.primitiveIn[0]} ? purify.Either.of${eitherTypeParameters}(value) : purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})))`;
+            fromRdfResourceValueExpression = `${fromRdfResourceValueExpression}.chain(value => value === ${this.primitiveIn[0]} ? purify.Either.of${eitherTypeParameters}(value) : purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})))`;
         }
-        return expression;
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            languageIn: undefined,
+            preferredLanguages: undefined,
+            valueTo: `chain(values => values.chainMap(value => ${fromRdfResourceValueExpression}))`,
+        };
     }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue

package/dist/generators/ts/DateTimeType.d.ts

@@ -1,5 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
 import { PrimitiveType } from "./PrimitiveType.js";
+import type { TermType } from "./TermType.js";
 import { Type } from "./Type.js";
 export declare class DateTimeType extends PrimitiveType<Date> {
     protected readonly xsdDatatype: NamedNode;
@@ -15,7 +16,7 @@ export declare class DateTimeType extends PrimitiveType<Date> {
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<number>["fromRdfResourceValueExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
     snippetDeclarations({ features, }: Parameters<PrimitiveType<Date>["snippetDeclarations"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<PrimitiveType<Date>["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<Date>["toRdfExpression"]>[0]): string;

package/dist/generators/ts/DateTimeType.js

@@ -54,13 +54,18 @@ export class DateTimeType extends PrimitiveType {
     jsonZodSchema({ variables, }) {
         return `${variables.zod}.string().${this.zodDatatype}()`;
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        let expression = `${variables.resourceValue}.toDate()`;
+    fromRdfExpressionChain({ variables, }) {
+        let fromRdfResourceValueExpression = "value.toDate()";
         if (this.primitiveIn.length > 0) {
             const eitherTypeParameters = `<Error, ${this.name}>`;
-            expression = `${expression}.chain(value => { ${this.primitiveIn.map((value) => `if (value.getTime() === ${value.getTime()}) { return purify.Either.of${eitherTypeParameters}(value); }`).join(" ")} return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: `rdfLiteral.toRdf(value, ${objectInitializer({ dataFactory: "dataFactory", datatype: rdfjsTermExpression(this.xsdDatatype) })})`, expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); })`;
+            fromRdfResourceValueExpression = `${fromRdfResourceValueExpression}.chain(value => { ${this.primitiveIn.map((value) => `if (value.getTime() === ${value.getTime()}) { return purify.Either.of${eitherTypeParameters}(value); }`).join(" ")} return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: `rdfLiteral.toRdf(value, ${objectInitializer({ dataFactory: "dataFactory", datatype: rdfjsTermExpression(this.xsdDatatype) })})`, expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); })`;
         }
-        return expression;
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            languageIn: undefined,
+            preferredLanguages: undefined,
+            valueTo: `chain(values => values.chainMap(value => ${fromRdfResourceValueExpression}))`,
+        };
     }
     snippetDeclarations({ features, }) {
         const snippetDeclarations = [];

package/dist/generators/ts/IdentifierType.d.ts

@@ -12,12 +12,7 @@ export declare class IdentifierType extends TermType<NamedNode, BlankNode | Name
     get name(): string;
     get toStringFunctionDeclaration(): VariableStatementStructure;
     fromJsonExpression({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): string;
-    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
-        defaultValue?: string;
-        hasValues?: string;
-        languageIn?: string;
-        valueTo?: string;
-    };
+    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
     graphqlResolveExpression({ variables: { value }, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     jsonZodSchema({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): ReturnType<TermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>;
     toJsonExpression({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): string;

package/dist/generators/ts/IdentifierType.js

@@ -137,7 +137,7 @@ export class IdentifierType extends TermType {
             throw new Error("not implemented");
         }
         return {
-            ...super.fromRdfExpressionChain,
+            ...super.fromRdfExpressionChain({ variables }),
             valueTo: `chain(values => values.chainMap(value => ${valueToExpression}))`,
         };
     }

package/dist/generators/ts/Import.d.ts

@@ -4,6 +4,8 @@ export type Import = ImportDeclarationStructure | string;
  * Singleton values for common imports.
  */
 export declare namespace Import {
+    const DATA_FACTORY: Import;
+    const DATASET_FACTORY: Import;
     const GRAPHQL: Import;
     const GRAPHQL_SCALARS: Import;
     const PURIFY: Import;
@@ -14,6 +16,5 @@ export declare namespace Import {
     const SPARQLJS: Import;
     const UUID: Import;
     const ZOD: Import;
-    const ZOD_TO_JSON_SCHEMA: Import;
 }
 //# sourceMappingURL=Import.d.ts.map

package/dist/generators/ts/Import.js

@@ -4,61 +4,66 @@ import { StructureKind } from "ts-morph";
  */
 export var Import;
 (function (Import) {
+    Import.DATA_FACTORY = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["dataFactory"],
+    };
+    Import.DATASET_FACTORY = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["datasetFactory"],
+    };
     Import.GRAPHQL = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "graphql",
-        namespaceImport: "graphql",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["graphql"],
     };
     Import.GRAPHQL_SCALARS = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "graphql-scalars",
-        namespaceImport: "graphqlScalars",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["graphqlScalars"],
     };
     Import.PURIFY = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "purify-ts",
-        namespaceImport: "purify",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["purify"],
     };
     Import.RDF_LITERAL = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "rdf-literal",
-        namespaceImport: "rdfLiteral",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["rdfLiteral"],
     };
     Import.RDFJS_RESOURCE = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "rdfjs-resource",
-        namespaceImport: "rdfjsResource",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["rdfjsResource"],
     };
     Import.RDFJS_TYPES = {
         isTypeOnly: true,
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@rdfjs/types",
-        namespaceImport: "rdfjs",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["rdfjs"],
     };
     Import.SHA256 = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "js-sha256",
+        moduleSpecifier: "@shaclmate/runtime",
         namedImports: ["sha256"],
     };
     Import.SPARQLJS = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "sparqljs",
-        namespaceImport: "sparqljs",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["sparqljs"],
     };
     Import.UUID = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "uuid",
-        namespaceImport: "uuid",
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["uuid"],
     };
     Import.ZOD = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "zod",
-        namedImports: [{ alias: "zod", name: "z" }],
-    };
-    Import.ZOD_TO_JSON_SCHEMA = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "zod-to-json-schema",
-        namedImports: [{ name: "zodToJsonSchema" }],
+        moduleSpecifier: "@shaclmate/runtime",
+        namedImports: ["zod"],
     };
 })(Import || (Import = {}));
 //# sourceMappingURL=Import.js.map

package/dist/generators/ts/ListType.js

@@ -189,7 +189,7 @@ export class ListType extends Type {
                         allowIgnoreRdfType: true,
                         context: "subject",
                         variables: {
-                            languageIn: parameters.variables.languageIn,
+                            preferredLanguages: parameters.variables.preferredLanguages,
                             subject: item0Variable,
                             variablePrefix: variablePrefix("Item0"),
                         },
@@ -223,7 +223,7 @@ export class ListType extends Type {
                         allowIgnoreRdfType: true,
                         context: "subject",
                         variables: {
-                            languageIn: parameters.variables.languageIn,
+                            preferredLanguages: parameters.variables.preferredLanguages,
                             subject: itemNVariable,
                             variablePrefix: variablePrefix("ItemN"),
                         },

package/dist/generators/ts/LiteralType.d.ts

@@ -8,16 +8,12 @@ export declare class LiteralType extends TermType<Literal, Literal> {
     } & Omit<ConstructorParameters<typeof TermType<Literal, Literal>>[0], "nodeKinds">);
     get jsonName(): Type.JsonName;
     fromJsonExpression({ variables, }: Parameters<TermType<Literal, Literal>["fromJsonExpression"]>[0]): string;
-    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
-        defaultValue?: string;
-        hasValues?: string;
-        languageIn?: string;
-        valueTo?: string;
-    };
+    protected fromRdfExpressionChain({ variables, }: Parameters<TermType<Literal>["fromRdfExpressionChain"]>[0]): ReturnType<TermType<Literal>["fromRdfExpressionChain"]>;
     hashStatements({ depth, variables, }: Parameters<TermType<Literal, Literal>["hashStatements"]>[0]): readonly string[];
     jsonZodSchema({ variables, }: Parameters<TermType<Literal, Literal>["jsonZodSchema"]>[0]): ReturnType<TermType<Literal, Literal>["jsonZodSchema"]>;
+    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
     sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0] & {
-        ignoreLanguageIn?: boolean;
+        ignoreLiteralLanguage?: boolean;
     }): readonly string[];
     toJsonExpression({ variables, }: Parameters<TermType<Literal, Literal>["toJsonExpression"]>[0]): string;
 }

package/dist/generators/ts/LiteralType.js

@@ -5,10 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { xsd } from "@tpluscode/rdf-ns-builders";
-import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { TermType } from "./TermType.js";
 import { Type } from "./Type.js";
+import { objectInitializer } from "./objectInitializer.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export class LiteralType extends TermType {
     languageIn;
     constructor({ languageIn, ...superParameters }) {
@@ -27,44 +29,34 @@ export class LiteralType extends TermType {
     fromRdfExpressionChain({ variables, }) {
         return {
             ...super.fromRdfExpressionChain({ variables }),
-            languageIn: `chain(values => {
-      const literalValuesEither = values.chainMap(value => value.toLiteral());
-      if (literalValuesEither.isLeft()) {
-        return literalValuesEither;
-      }
-      const literalValues = literalValuesEither.unsafeCoerce();
-
-      const nonUniqueLanguageIn = ${variables.languageIn} ?? ${JSON.stringify(this.languageIn)};
-      if (nonUniqueLanguageIn.length === 0) {
-        return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjs.Literal>>(literalValues);
-      }
+            languageIn: this.languageIn.length > 0
+                ? `chain(values => values.chainMap(value => value.toLiteral().chain(literalValue => { switch (literalValue.language) { ${this.languageIn.map((languageIn) => `case "${languageIn}":`).join(" ")} return purify.Either.of(value); default: return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "literalValue", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })))`
+                : undefined,
+            preferredLanguages: `chain(values => {
+        if (!${variables.preferredLanguages} || ${variables.preferredLanguages}.length === 0) {
+          return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(values);
+        }
 
-      let uniqueLanguageIn: string[];
-      if (nonUniqueLanguageIn.length === 1) {
-        uniqueLanguageIn = [nonUniqueLanguageIn[0]];
-      } else {
-        uniqueLanguageIn = [];
-        for (const languageIn of nonUniqueLanguageIn) {
-          if (uniqueLanguageIn.indexOf(languageIn) === -1) {
-            uniqueLanguageIn.push(languageIn);
-          }
+        const literalValuesEither = values.chainMap(value => value.toLiteral());
+        if (literalValuesEither.isLeft()) {
+          return literalValuesEither;
         }
-      }
+        const literalValues = literalValuesEither.unsafeCoerce();
 
-      // Return all literals for the first languageIn, then all literals for the second languageIn, etc.
-      // Within a languageIn the literals may be in any order.
-      let filteredLiteralValues: rdfjsResource.Resource.Values<rdfjs.Literal> | undefined;
-      for (const languageIn of uniqueLanguageIn) {
-        if (!filteredLiteralValues) {
-          filteredLiteralValues = literalValues.filter(value => value.language === languageIn);
-        } else {
-          filteredLiteralValues = filteredLiteralValues.concat(...literalValues.filter(value => value.language === languageIn).toArray());
+        // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
+        // Within a preferredLanguage the literals may be in any order.
+        let filteredLiteralValues: rdfjsResource.Resource.Values<rdfjs.Literal> | undefined;
+        for (const preferredLanguage of ${variables.preferredLanguages}) {
+          if (!filteredLiteralValues) {
+            filteredLiteralValues = literalValues.filter(value => value.language === preferredLanguage);
+          } else {
+            filteredLiteralValues = filteredLiteralValues.concat(...literalValues.filter(value => value.language === preferredLanguage).toArray());
+          }
         }
-      }
 
-      return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjs.Literal>>(filteredLiteralValues!);
-    })`,
-            valueTo: undefined,
+        return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(filteredLiteralValues!.map(literalValue => new rdfjsResource.Resource.Value({ object: literalValue, predicate: ${variables.predicate}, subject: ${variables.resource} })));
+      })`,
+            valueTo: "chain(values => values.chainMap(value => value.toLiteral()))",
         };
     }
     hashStatements({ depth, variables, }) {
@@ -76,23 +68,32 @@ export class LiteralType extends TermType {
     jsonZodSchema({ variables, }) {
         return `${variables.zod}.object({ "@language": ${variables.zod}.string().optional(), "@type": ${variables.zod}.string().optional(), "@value": ${variables.zod}.string() })`;
     }
+    snippetDeclarations(parameters) {
+        let snippetDeclarations = super.snippetDeclarations(parameters);
+        const { features } = parameters;
+        if (features.has("sparql") && this.languageIn.length > 0) {
+            snippetDeclarations = snippetDeclarations.concat(SnippetDeclarations.arrayIntersection);
+        }
+        return snippetDeclarations;
+    }
     sparqlWherePatterns(parameters) {
-        const { context, ignoreLanguageIn, variables } = parameters;
+        const { context, ignoreLiteralLanguage, variables } = parameters;
         const superPatterns = super.sparqlWherePatterns(parameters);
-        if (ignoreLanguageIn || context === "subject") {
+        if (ignoreLiteralLanguage || context === "subject") {
             return superPatterns;
         }
-        invariant(this.name.indexOf("rdfjs.Literal") !== -1, this.name);
-        return superPatterns.concat(`...[(${variables.languageIn} && ${variables.languageIn}.length > 0) ? ${variables.languageIn} : ${JSON.stringify(this.languageIn)}]
-        .filter(languagesIn => languagesIn.length > 0)
-        .map(languagesIn =>
-          languagesIn.map(languageIn => 
+        return superPatterns.concat(`...[${this.languageIn.length > 0
+            ? `[...${syntheticNamePrefix}arrayIntersection(${JSON.stringify(this.languageIn)}, ${variables.preferredLanguages} ?? [])]`
+            : `(${variables.preferredLanguages} ?? [])`}]
+        .filter(languages => languages.length > 0)
+        .map(languages =>
+          languages.map(language => 
             ({
               type: "operation" as const,
               operator: "=",
               args: [
                 { type: "operation" as const, operator: "lang", args: [${variables.object}] },
-                dataFactory.literal(languageIn)
+                dataFactory.literal(language)
               ]
             })
           )
@@ -100,15 +101,16 @@ export class LiteralType extends TermType {
         .map(langEqualsExpressions => 
           ({
             type: "filter" as const,
-            expression:
-              langEqualsExpressions.length === 1
-                ? langEqualsExpressions[0]
-                :
-                  {
-                    type: "operation" as const,
-                    operator: "||",
-                    args: langEqualsExpressions
-                  },
+            expression: langEqualsExpressions.reduce((reducedExpression, langEqualsExpression) => {
+              if (reducedExpression === null) {
+                return langEqualsExpression;
+              }
+              return {
+                type: "operation" as const,
+                operator: "||",
+                args: [reducedExpression, langEqualsExpression]
+              };
+            }, null as sparqljs.Expression | null) as sparqljs.Expression
           })
         )`);
     }

package/dist/generators/ts/NumberType.d.ts

@@ -1,4 +1,5 @@
 import { PrimitiveType } from "./PrimitiveType.js";
+import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 export declare abstract class NumberType extends PrimitiveType<number> {
     readonly kind = "NumberType";
@@ -6,7 +7,7 @@ export declare abstract class NumberType extends PrimitiveType<number> {
     get conversions(): readonly Type.Conversion[];
     get name(): string;
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    protected fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<number>["fromRdfResourceValueExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=NumberType.d.ts.map

package/dist/generators/ts/NumberType.js

@@ -43,13 +43,18 @@ export class NumberType extends PrimitiveType {
                 return `${variables.zod}.union([${this.primitiveIn.map((value) => `${variables.zod}.literal(${value})`).join(", ")}])`;
         }
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        let expression = `${variables.resourceValue}.toNumber()`;
+    fromRdfExpressionChain({ variables, }) {
+        let fromRdfResourceValueExpression = "value.toNumber()";
         if (this.primitiveIn.length > 0) {
             const eitherTypeParameters = `<Error, ${this.name}>`;
-            expression = `${expression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case ${value}:`).join(" ")} return purify.Either.of${eitherTypeParameters}(value); default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
+            fromRdfResourceValueExpression = `${fromRdfResourceValueExpression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case ${value}:`).join(" ")} return purify.Either.of${eitherTypeParameters}(value); default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
         }
-        return expression;
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            languageIn: undefined,
+            preferredLanguages: undefined,
+            valueTo: `chain(values => values.chainMap(value => ${fromRdfResourceValueExpression}))`,
+        };
     }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue

package/dist/generators/ts/ObjectType.d.ts

@@ -44,6 +44,8 @@ export declare class ObjectType extends DeclaredType {
     get conversions(): readonly Type.Conversion[];
     get declarationImports(): readonly Import[];
     get declarations(): (ClassDeclarationStructure | InterfaceDeclarationStructure | ModuleDeclarationStructure)[];
+    get descendantFromRdfTypes(): readonly NamedNode[];
+    get descendantFromRdfTypeVariables(): readonly string[];
     get descendantObjectTypes(): readonly ObjectType[];
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get discriminatorValue(): string;

package/dist/generators/ts/ObjectType.js

@@ -83,7 +83,6 @@ export class ObjectType extends DeclaredType {
         }
         if (this.features.has("json")) {
             imports.push(Import.ZOD);
-            imports.push(Import.ZOD_TO_JSON_SCHEMA);
         }
         if (this.features.has("rdf")) {
             imports.push(Import.PURIFY);
@@ -122,6 +121,12 @@ export class ObjectType extends DeclaredType {
         }
         return declarations;
     }
+    get descendantFromRdfTypes() {
+        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfType.toList());
+    }
+    get descendantFromRdfTypeVariables() {
+        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
+    }
     get descendantObjectTypes() {
         return this.lazyDescendantObjectTypes();
     }
@@ -221,7 +226,7 @@ export class ObjectType extends DeclaredType {
         return `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value}).unsafeCoerce()`;
     }
     fromRdfExpression({ variables, }) {
-        return `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...${variables.context}, ${variables.ignoreRdfType ? "ignoreRdfType: true, " : ""}languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet} }))))`;
+        return `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...${variables.context}, ${variables.ignoreRdfType ? "ignoreRdfType: true, " : ""}objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages} }))))`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -299,7 +304,7 @@ export class ObjectType extends DeclaredType {
                 return [
                     `...${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${objectInitializer({
                         ignoreRdfType: parameters.allowIgnoreRdfType ? true : undefined, // Can ignore the rdf:type when the object is nested
-                        languageIn: parameters.variables.languageIn,
+                        preferredLanguages: parameters.variables.preferredLanguages,
                         subject: parameters.variables.subject,
                         variablePrefix: parameters.variables.variablePrefix,
                     })})`,
@@ -348,6 +353,12 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "descendantFromRdfTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "descendantFromRdfTypeVariables", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "descendantObjectTypes", null);

package/dist/generators/ts/ObjectUnionType.d.ts

@@ -13,6 +13,7 @@ declare class MemberType {
         universe: readonly ObjectType[];
     });
     get declarationType(): import("../../enums/TsObjectDeclarationType.js").TsObjectDeclarationType;
+    get descendantFromRdfTypeVariables(): readonly string[];
     get discriminatorPropertyValues(): readonly string[];
     get features(): Set<import("../../enums/TsFeature.js").TsFeature>;
     get fromRdfType(): Maybe<import("@rdfjs/types").NamedNode<string>>;

package/dist/generators/ts/ObjectUnionType.js

@@ -28,6 +28,9 @@ class MemberType {
     get declarationType() {
         return this.delegate.declarationType;
     }
+    get descendantFromRdfTypeVariables() {
+        return this.delegate.descendantFromRdfTypeVariables;
+    }
     get discriminatorPropertyValues() {
         // A member type's combined discriminator property values are its "own" values plus any descendant values that are
         // not the "own" values of some other member type.
@@ -279,7 +282,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
                 {
                     hasQuestionToken: true,
                     name: "options",
-                    type: `{ [_index: string]: any; ignoreRdfType?: boolean; languageIn?: readonly string[]; objectSet?: ${syntheticNamePrefix}ObjectSet }`,
+                    type: `{ [_index: string]: any; ignoreRdfType?: boolean; objectSet?: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[] }`,
                 },
             ],
             returnType: `purify.Either<Error, ${this.name}>`,
@@ -435,7 +438,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
                     {
                         hasQuestionToken: true,
                         name: "parameters",
-                        type: '{ ignoreRdfType?: boolean; languageIn?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                        type: '{ ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                     },
                 ],
                 returnType: "readonly sparqljs.Pattern[]",
@@ -546,7 +549,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
     }
     fromRdfExpression({ variables, }) {
         // Don't ignoreRdfType, we may need it to distinguish the union members
-        return `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...${variables.context}, ignoreRdfType: false, languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet} }))))`;
+        return `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...${variables.context}, ignoreRdfType: false, objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages} }))))`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -599,7 +602,7 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
             case "subject":
                 return [
                     `...${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${objectInitializer({
-                        languageIn: parameters.variables.languageIn,
+                        preferredLanguages: parameters.variables.preferredLanguages,
                         subject: parameters.variables.subject,
                         variablePrefix: parameters.variables.variablePrefix,
                     })})`,

package/dist/generators/ts/PrimitiveType.d.ts

@@ -12,28 +12,10 @@ export declare abstract class PrimitiveType<ValueT extends boolean | Date | stri
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get jsonName(): Type.JsonName;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
-        defaultValue?: string;
-        hasValues?: string;
-        languageIn?: string;
-        valueTo?: string;
-    };
     graphqlResolveExpression({ variables, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     snippetDeclarations({ features, }: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
-    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<LiteralType["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
-    /**
-     * Convert an rdfjsResource.Resource.Value to a value of this type.
-     * @param variables
-     * @protected
-     */
-    protected abstract fromRdfResourceValueExpression({ variables, }: {
-        variables: {
-            predicate: string;
-            resource: string;
-            resourceValue: string;
-        };
-    }): string;
 }
 //# sourceMappingURL=PrimitiveType.d.ts.map