@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/generators/ts/ListType.js

@@ -1,18 +1,28 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
+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 { rdf } from "@tpluscode/rdf-ns-builders";
+import { Memoize } from "typescript-memoize";
 import { Import } from "./Import.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export class ListType extends Type {
-    itemType;
-    kind = "ListType";
-    identifierNodeKind;
-    identifierMintingStrategy;
     _mutable;
+    identifierMintingStrategy;
+    identifierNodeKind;
     toRdfTypes;
-    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, ...superParameters }) {
-        super(superParameters);
+    itemType;
+    kind = "ListType";
+    typeof = "object";
+    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, }) {
+        super();
         this.identifierNodeKind = identifierNodeKind;
         this.itemType = itemType;
         this.identifierMintingStrategy = identifierMintingStrategy.orDefault(identifierNodeKind === "BlankNode" ? "blankNode" : "sha256");
@@ -22,8 +32,11 @@ export class ListType extends Type {
     get conversions() {
         return [
             {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
+                // Defensive copy
+                conversionExpression: (value) => `${value}${this.mutable ? ".concat()" : ""}`,
+                // Array.isArray doesn't narrow correctly
+                // sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
                 sourceTypeName: this.name,
             },
         ];
@@ -32,10 +45,13 @@ export class ListType extends Type {
         return Maybe.empty();
     }
     get equalsFunction() {
-        return `((left, right) => arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
+        return `((left, right) => ${syntheticNamePrefix}arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
+    }
+    get graphqlName() {
+        return new Type.GraphqlName(`new graphql.GraphQLList(${this.itemType.graphqlName})`);
     }
     get jsonName() {
-        return `readonly (${this.itemType.jsonName})[]`;
+        return new Type.JsonName(`readonly (${this.itemType.jsonName})[]`);
     }
     get mutable() {
         return this._mutable || this.itemType.mutable;
@@ -44,18 +60,30 @@ export class ListType extends Type {
         return `${this._mutable ? "" : "readonly "}${this.itemType.name}[]`;
     }
     fromJsonExpression({ variables, }) {
-        return `${variables.value}.map(_item => (${this.itemType.fromJsonExpression({ variables: { value: "_item" } })}))`;
+        return `${variables.value}.map(item => (${this.itemType.fromJsonExpression({ variables: { value: "item" } })}))`;
     }
     fromRdfExpression({ variables, }) {
-        const chain = [variables.resourceValues];
-        chain.push("head()");
-        chain.push("chain(value => value.toList())");
-        chain.push(`map(values => values.flatMap(_value => ${this.itemType.fromRdfExpression({ variables: { ...variables, resourceValues: "_value.toValues()" } })}.toMaybe().toList()))`);
-        return chain.join(".");
+        return [
+            variables.resourceValues,
+            "chain(values => values.chainMap(value => value.toList()))", // Resource.Values<Resource.Value> to Resource.Values<Resource.Value[]>
+            `chain(valueLists =>
+        valueLists.chainMap(
+          valueList => ${this.itemType.fromRdfExpression({
+                variables: {
+                    ...variables,
+                    resourceValues: `purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(rdfjsResource.Resource.Values.fromArray({ objects: valueList, predicate: ${variables.predicate}, subject: ${variables.resource} }))`,
+                },
+            })}
+      ))`, // Resource.Values<Resource.Value[]> to Resource.Values<item type arrays>
+            `map(valueLists => valueLists.map(valueList => valueList.toArray()${this.mutable ? ".concat()" : ""}))`, // Convert inner Resource.Values to arrays
+        ].join(".");
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
     }
     hashStatements({ depth, variables, }) {
         return [
-            `for (const _element${depth} of ${variables.value}) { ${this.itemType.hashStatements({ depth: depth + 1, variables: { ...variables, value: `_element${depth}` } }).join("\n")} }`,
+            `for (const item${depth} of ${variables.value}) { ${this.itemType.hashStatements({ depth: depth + 1, variables: { ...variables, value: `item${depth}` } }).join("\n")} }`,
         ];
     }
     jsonUiSchemaElement(parameters) {
@@ -64,33 +92,35 @@ export class ListType extends Type {
     jsonZodSchema(parameters) {
         return `${this.itemType.jsonZodSchema(parameters)}.array()`;
     }
-    snippetDeclarations(features) {
+    snippetDeclarations(parameters) {
         const snippetDeclarations = this.itemType
-            .snippetDeclarations(features)
+            .snippetDeclarations(parameters)
             .concat();
-        if (features.has("equals")) {
+        if (parameters.features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.arrayEquals);
         }
         return snippetDeclarations;
     }
-    sparqlConstructTemplateTriples({ variables, context, }) {
-        switch (context) {
-            case "property":
-                return super.sparqlConstructTemplateTriples({ context, variables });
-            case "type": {
+    sparqlConstructTemplateTriples(parameters) {
+        switch (parameters.context) {
+            case "object":
+                return super.sparqlConstructTemplateTriples(parameters);
+            case "subject": {
+                const { variables } = parameters;
                 const triples = [];
                 const listVariable = variables.subject;
-                const variable = (suffix) => `${this.dataFactoryVariable}.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
+                const variable = (suffix) => `dataFactory.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
                 const variablePrefix = (suffix) => `\`\${${variables.variablePrefix}}${suffix}\``;
                 {
                     // ?list rdf:first ?item0
                     const item0Variable = variable("Item0");
                     triples.push(objectInitializer({
                         subject: listVariable,
-                        predicate: this.rdfjsTermExpression(rdf.first),
+                        predicate: rdfjsTermExpression(rdf.first),
                         object: item0Variable,
                     }), ...this.itemType.sparqlConstructTemplateTriples({
-                        context: "type",
+                        allowIgnoreRdfType: true,
+                        context: "subject",
                         variables: {
                             subject: item0Variable,
                             variablePrefix: variablePrefix("Item0"),
@@ -102,7 +132,7 @@ export class ListType extends Type {
                     const rest0Variable = variable("Rest0");
                     triples.push(objectInitializer({
                         subject: listVariable,
-                        predicate: this.rdfjsTermExpression(rdf.rest),
+                        predicate: rdfjsTermExpression(rdf.rest),
                         object: rest0Variable,
                     }));
                 }
@@ -113,10 +143,11 @@ export class ListType extends Type {
                     const itemNVariable = variable("ItemN");
                     triples.push(objectInitializer({
                         subject: restNVariable,
-                        predicate: this.rdfjsTermExpression(rdf.first),
+                        predicate: rdfjsTermExpression(rdf.first),
                         object: itemNVariable,
                     }), ...this.itemType.sparqlConstructTemplateTriples({
-                        context: "type",
+                        allowIgnoreRdfType: true,
+                        context: "subject",
                         variables: {
                             subject: itemNVariable,
                             variablePrefix: variablePrefix("ItemN"),
@@ -126,36 +157,39 @@ export class ListType extends Type {
                 // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
                 triples.push(objectInitializer({
                     subject: restNVariable,
-                    predicate: this.rdfjsTermExpression(rdf.rest),
+                    predicate: rdfjsTermExpression(rdf.rest),
                     object: variable("RestNBasic"),
                 }));
                 return triples;
             }
         }
     }
-    sparqlWherePatterns({ variables, context, }) {
+    sparqlWherePatterns(parameters) {
         // Need to handle two cases:
         // (1) (?s, ?p, ?list) where ?list binds to rdf:nil
         // (2) (?s, ?p, ?list) (?list, rdf:first, "element") (?list, rdf:rest, rdf:nil) etc. where list binds to the head of a list
         // Case (2) is case (1) with OPTIONAL graph patterns to handle actual list elements.
-        switch (context) {
-            case "property":
-                return super.sparqlWherePatterns({ context, variables });
-            case "type": {
+        switch (parameters.context) {
+            case "object":
+                return super.sparqlWherePatterns(parameters);
+            case "subject": {
+                const { variables } = parameters;
                 const patterns = [];
                 const listVariable = variables.subject;
-                const variable = (suffix) => `${this.dataFactoryVariable}.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
+                const variable = (suffix) => `dataFactory.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
                 const variablePrefix = (suffix) => `\`\${${variables.variablePrefix}}${suffix}\``;
                 {
                     // ?list rdf:first ?item0
                     const item0Variable = variable("Item0");
                     patterns.push(`{ type: "bgp", triples: [${objectInitializer({
                         subject: listVariable,
-                        predicate: this.rdfjsTermExpression(rdf.first),
+                        predicate: rdfjsTermExpression(rdf.first),
                         object: item0Variable,
                     })}] }`, ...this.itemType.sparqlWherePatterns({
-                        context: "type",
+                        allowIgnoreRdfType: true,
+                        context: "subject",
                         variables: {
+                            languageIn: parameters.variables.languageIn,
                             subject: item0Variable,
                             variablePrefix: variablePrefix("Item0"),
                         },
@@ -166,7 +200,7 @@ export class ListType extends Type {
                     const rest0Variable = variable("Rest0");
                     patterns.push(`{ type: "bgp", triples: [${objectInitializer({
                         subject: listVariable,
-                        predicate: this.rdfjsTermExpression(rdf.rest),
+                        predicate: rdfjsTermExpression(rdf.rest),
                         object: rest0Variable,
                     })}] }`);
                 }
@@ -175,7 +209,7 @@ export class ListType extends Type {
                 // ?list rdf:rest+ ?restN
                 optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
                     subject: listVariable,
-                    predicate: `{ type: "path", pathType: "*", items: [${this.rdfjsTermExpression(rdf.rest)}] }`,
+                    predicate: `{ type: "path", pathType: "*", items: [${rdfjsTermExpression(rdf.rest)}] }`,
                     object: restNVariable,
                 })}] }`);
                 {
@@ -183,11 +217,13 @@ export class ListType extends Type {
                     const itemNVariable = variable("ItemN");
                     optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
                         subject: restNVariable,
-                        predicate: this.rdfjsTermExpression(rdf.first),
+                        predicate: rdfjsTermExpression(rdf.first),
                         object: itemNVariable,
                     })}] }`, ...this.itemType.sparqlWherePatterns({
-                        context: "type",
+                        allowIgnoreRdfType: true,
+                        context: "subject",
                         variables: {
+                            languageIn: parameters.variables.languageIn,
                             subject: itemNVariable,
                             variablePrefix: variablePrefix("ItemN"),
                         },
@@ -196,7 +232,7 @@ export class ListType extends Type {
                 // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
                 optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
                     subject: restNVariable,
-                    predicate: this.rdfjsTermExpression(rdf.rest),
+                    predicate: rdfjsTermExpression(rdf.rest),
                     object: variable("RestNBasic"),
                 })}] }`);
                 patterns.push(`{ type: "optional", patterns: [${optionalPatterns.join(", ")}] }`);
@@ -208,12 +244,12 @@ export class ListType extends Type {
     toJsonExpression({ variables, }) {
         let expression = variables.value;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: "_item" },
+            variables: { value: "item" },
         });
-        if (itemFromJsonExpression !== "_item") {
-            expression = `${expression}.map(_item => (${itemFromJsonExpression}))`;
+        if (itemFromJsonExpression !== "item") {
+            expression = `${expression}.map(item => (${itemFromJsonExpression}))`;
         }
-        return `${variables.value}.map(_item => (${this.itemType.toJsonExpression({ variables: { value: "_item" } })}))`;
+        return `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: "item" } })}))`;
     }
     toRdfExpression({ variables, }) {
         let listIdentifier;
@@ -233,9 +269,9 @@ export class ListType extends Type {
                         throw new RangeError(this.identifierMintingStrategy);
                     case "sha256":
                         listIdentifier = `dataFactory.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
-        (_hasher, _item) => {
-          ${this.itemType.hashStatements({ depth: 0, variables: { hasher: "_hasher", value: "_item" } }).join("\n")}
-          return _hasher;
+        (hasher, item) => {
+          ${this.itemType.hashStatements({ depth: 0, variables: { hasher: "hasher", value: "item" } }).join("\n")}
+          return hasher;
         },
         sha256.create(),
       )}\`)`;
@@ -260,16 +296,16 @@ export class ListType extends Type {
       const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}(${subListIdentifier}, ${objectInitializer({
             mutateGraph: variables.mutateGraph,
         })});
-      currentSubListResource!.add(dataFactory.namedNode("${rdf.rest.value}"), newSubListResource.identifier);
+      currentSubListResource!.add(${rdfjsTermExpression(rdf.rest)}, newSubListResource.identifier);
       currentSubListResource = newSubListResource;
     }
     
-    ${this.toRdfTypes.map((rdfType) => `currentSubListResource.add(dataFactory.namedNode("${rdf.type.value}"), dataFactory.namedNode("${rdfType.value}"))`).join("\n")}
+    ${this.toRdfTypes.map((rdfType) => `currentSubListResource.add(${rdfjsTermExpression(rdf.type)}, dataFactory.namedNode("${rdfType.value}"))`).join("\n")}
         
-    currentSubListResource.add(dataFactory.namedNode("${rdf.first.value}"), ${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: `dataFactory.namedNode("${rdf.first.value}")`, resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
+    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: rdfjsTermExpression(rdf.first), resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
 
     if (itemIndex + 1 === list.length) {
-      currentSubListResource.add(dataFactory.namedNode("${rdf.rest.value}"), dataFactory.namedNode("${rdf.nil.value}"));
+      currentSubListResource.add(${rdfjsTermExpression(rdf.rest)}, ${rdfjsTermExpression(rdf.nil)});
     }
     
     return { currentSubListResource, listResource };
@@ -283,14 +319,30 @@ export class ListType extends Type {
     currentSubListResource: ${mutableResourceTypeName} | null;
     listResource: ${mutableResourceTypeName};
   },
-).listResource.identifier : dataFactory.namedNode("${rdf.nil.value}")`;
+).listResource.identifier : ${rdfjsTermExpression(rdf.nil)}`;
     }
-    useImports(features) {
-        const imports = this.itemType.useImports(features).concat();
-        if (features.has("hash") && this.identifierNodeKind === "NamedNode") {
+    useImports(parameters) {
+        const imports = this.itemType.useImports(parameters).concat();
+        if (parameters.features.has("hash") &&
+            this.identifierNodeKind === "NamedNode") {
             imports.push(Import.SHA256);
         }
         return imports;
     }
 }
+__decorate([
+    Memoize()
+], ListType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "graphqlName", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "jsonName", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "name", null);
 //# sourceMappingURL=ListType.js.map

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

@@ -1,16 +1,24 @@
 import type { Literal } from "@rdfjs/types";
 import { TermType } from "./TermType.js";
-export declare class LiteralType extends TermType<Literal> {
+import { Type } from "./Type.js";
+export declare class LiteralType extends TermType<Literal, Literal> {
     private readonly languageIn;
     constructor({ languageIn, ...superParameters }: {
         languageIn: readonly string[];
-    } & Omit<ConstructorParameters<typeof TermType<Literal>>[0], "nodeKinds">);
-    get jsonName(): string;
-    fromJsonExpression({ variables, }: Parameters<TermType<Literal>["fromJsonExpression"]>[0]): string;
-    hashStatements({ depth, variables, }: Parameters<TermType<Literal>["hashStatements"]>[0]): readonly string[];
-    jsonZodSchema({ variables, }: Parameters<TermType<Literal>["jsonZodSchema"]>[0]): ReturnType<TermType<Literal>["jsonZodSchema"]>;
-    propertyFromRdfResourceValueExpression({ variables, }: Parameters<TermType<Literal>["propertyFromRdfResourceValueExpression"]>[0]): string;
-    toJsonExpression({ variables, }: Parameters<TermType<Literal>["toJsonExpression"]>[0]): string;
-    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<TermType<Literal>["propertyFilterRdfResourceValuesExpression"]>[0]): string;
+    } & 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;
+    };
+    hashStatements({ depth, variables, }: Parameters<TermType<Literal, Literal>["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<TermType<Literal, Literal>["jsonZodSchema"]>[0]): ReturnType<TermType<Literal, Literal>["jsonZodSchema"]>;
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0] & {
+        ignoreLanguageIn?: boolean;
+    }): readonly string[];
+    toJsonExpression({ variables, }: Parameters<TermType<Literal, Literal>["toJsonExpression"]>[0]): string;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -1,5 +1,14 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { xsd } from "@tpluscode/rdf-ns-builders";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
 import { TermType } from "./TermType.js";
+import { Type } from "./Type.js";
 export class LiteralType extends TermType {
     languageIn;
     constructor({ languageIn, ...superParameters }) {
@@ -10,10 +19,53 @@ export class LiteralType extends TermType {
         this.languageIn = languageIn;
     }
     get jsonName() {
-        return '{ readonly "@language": string | undefined, readonly "@type": string | undefined, readonly "@value": string }';
+        return new Type.JsonName('{ readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string }');
     }
     fromJsonExpression({ variables, }) {
-        return `${this.dataFactoryVariable}.literal(${variables.value}["@value"], typeof ${variables.value}["@language"] !== "undefined" ? ${variables.value}["@language"] : (typeof ${variables.value}["@type"] !== "undefined" ? dataFactory.namedNode(${variables.value}["@type"]) : undefined))`;
+        return `dataFactory.literal(${variables.value}["@value"], typeof ${variables.value}["@language"] !== "undefined" ? ${variables.value}["@language"] : (typeof ${variables.value}["@type"] !== "undefined" ? dataFactory.namedNode(${variables.value}["@type"]) : undefined))`;
+    }
+    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);
+      }
+
+      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);
+          }
+        }
+      }
+
+      // 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 purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjs.Literal>>(filteredLiteralValues!);
+    })`,
+            valueTo: undefined,
+        };
     }
     hashStatements({ depth, variables, }) {
         return [
@@ -24,24 +76,47 @@ 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() })`;
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        return `${variables.resourceValue}.toLiteral()`;
+    sparqlWherePatterns(parameters) {
+        const { context, ignoreLanguageIn, variables } = parameters;
+        const superPatterns = super.sparqlWherePatterns(parameters);
+        if (ignoreLanguageIn || 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 => 
+            ({
+              type: "operation" as const,
+              operator: "=",
+              args: [
+                { type: "operation" as const, operator: "lang", args: [${variables.object}] },
+                dataFactory.literal(languageIn)
+              ]
+            })
+          )
+        )
+        .map(langEqualsExpressions => 
+          ({
+            type: "filter" as const,
+            expression:
+              langEqualsExpressions.length === 1
+                ? langEqualsExpressions[0]
+                :
+                  {
+                    type: "operation" as const,
+                    operator: "||",
+                    args: langEqualsExpressions
+                  },
+          })
+        )`);
     }
     toJsonExpression({ variables, }) {
         return `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value }`;
     }
-    propertyFilterRdfResourceValuesExpression({ variables, }) {
-        return `${variables.resourceValues}.filter(_value => {
-  const _languageInOrDefault = ${variables.languageIn} ?? ${JSON.stringify(this.languageIn)};
-  if (_languageInOrDefault.length === 0) {
-    return true;
-  }
-  const _valueLiteral = _value.toLiteral().toMaybe().extract();
-  if (typeof _valueLiteral === "undefined") {
-    return false;
-  }
-  return _languageInOrDefault.some(_languageIn => _languageIn === _valueLiteral.language);
-})`;
-    }
 }
+__decorate([
+    Memoize()
+], LiteralType.prototype, "jsonName", null);
 //# sourceMappingURL=LiteralType.js.map

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

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

package/dist/generators/ts/NumberType.js

@@ -9,6 +9,7 @@ import { PrimitiveType } from "./PrimitiveType.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class NumberType extends PrimitiveType {
     kind = "NumberType";
+    typeof = "number";
     get conversions() {
         const conversions = [
             {
@@ -30,7 +31,7 @@ export class NumberType extends PrimitiveType {
         if (this.primitiveIn.length > 0) {
             return this.primitiveIn.map((value) => value.toString()).join(" | ");
         }
-        return "number";
+        return this.typeof;
     }
     jsonZodSchema({ variables, }) {
         switch (this.primitiveIn.length) {
@@ -42,10 +43,11 @@ export class NumberType extends PrimitiveType {
                 return `${variables.zod}.union([${this.primitiveIn.map((value) => `${variables.zod}.literal(${value})`).join(", ")}])`;
         }
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
+    fromRdfResourceValueExpression({ variables, }) {
         let expression = `${variables.resourceValue}.toNumber()`;
         if (this.primitiveIn.length > 0) {
-            expression = `${expression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case ${value}:`).join(" ")} return purify.Either.of(value); default: return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
+            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 })})); } })`;
         }
         return expression;
     }
@@ -55,6 +57,9 @@ export class NumberType extends PrimitiveType {
             .orDefault(variables.value);
     }
 }
+__decorate([
+    Memoize()
+], NumberType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], NumberType.prototype, "name", null);