@rdfx/literal 0.0.21 → 0.0.22

package/dist/LiteralDecoder.d.ts

@@ -1,4 +1,5 @@
 import type { Literal } from "@rdfjs/types";
+import { Decimal } from "decimal.js";
 import { Either } from "purify-ts";
 import type { Primitive } from "./Primitive.js";
 /**
@@ -7,6 +8,7 @@ import type { Primitive } from "./Primitive.js";
  * Partially adapted from rdf-literal.js (https://github.com/rubensworks/rdf-literal.js), MIT license.
  */
 export declare namespace LiteralDecoder {
+    function decodeBigDecimalLiteral(literal: Literal): Either<Error, Decimal>;
     function decodeBigIntLiteral(literal: Literal): Either<Error, bigint>;
     function decodeBooleanLiteral(literal: Literal): Either<Error, boolean>;
     function decodeDateLiteral(literal: Literal): Either<Error, Date>;

package/dist/LiteralDecoder.js

@@ -1,3 +1,4 @@
+import { Decimal } from "decimal.js";
 import { Either, Left } from "purify-ts";
 import { literalDatatypeDefinitions } from "./literalDatatypeDefinitions.js";
 /**
@@ -9,6 +10,19 @@ export var LiteralDecoder;
 (function (LiteralDecoder) {
     const BIGINT_NUMBER_MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
     const BIGINT_NUMBER_MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
+    function convertBigDecimalToBigInt(literal, value) {
+        if (value.isInt()) {
+            return Either.of(BigInt(value.toFixed(0)));
+        }
+        return Left(new LiteralValueError(literal, `Decimal ${value} is not an integer`));
+    }
+    function convertBigDecimalToNumber(literal, value) {
+        const valueToNumber = value.toNumber();
+        if (new Decimal(valueToNumber).equals(value)) {
+            return Either.of(valueToNumber);
+        }
+        return Left(new LiteralValueError(literal, `Decimal ${value} is outside number's safe range [-${Number.MAX_VALUE}, ${Number.MAX_VALUE}]`));
+    }
     function convertBigIntToNumber(literal, value) {
         if (value >= BIGINT_NUMBER_MIN_SAFE_INTEGER &&
             value <= BIGINT_NUMBER_MAX_SAFE_INTEGER) {
@@ -22,12 +36,36 @@ export var LiteralDecoder;
         }
         return Left(new LiteralValueError(literal, `number ${value} is not an integer`));
     }
+    function decodeBigDecimalLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigdecimal":
+                return decodeBigDecimalLiteralValue(literal);
+            case "bigint":
+                return decodeBigIntLiteralValue(literal).map((value) => new Decimal(value));
+            case "float":
+                return decodeFloatLiteralValue(literal).map((value) => new Decimal(value));
+            case "int":
+                return decodeIntLiteralValue(literal).map((value) => new Decimal(value));
+            default:
+                return Left(new LiteralDatatypeError(literal));
+        }
+    }
+    LiteralDecoder.decodeBigDecimalLiteral = decodeBigDecimalLiteral;
+    function decodeBigDecimalLiteralValue(literal) {
+        return Either.encase(() => Decimal(literal.value));
+    }
     function decodeBigIntLiteral(literal) {
         const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
         if (!literalDatatypeDefinition) {
             return Left(new LiteralDatatypeError(literal));
         }
         switch (literalDatatypeDefinition.kind) {
+            case "bigdecimal":
+                return decodeBigDecimalLiteral(literal).chain((value) => convertBigDecimalToBigInt(literal, value));
             case "bigint":
                 return decodeBigIntLiteralValue(literal);
             case "float":
@@ -93,6 +131,8 @@ export var LiteralDecoder;
             return Left(new LiteralDatatypeError(literal));
         }
         switch (literalDatatypeDefinition.kind) {
+            case "bigdecimal":
+                return decodeBigDecimalLiteral(literal).chain((value) => convertBigDecimalToNumber(literal, value));
             case "bigint":
                 return decodeBigIntLiteral(literal).chain((value) => convertBigIntToNumber(literal, value));
             case "float":
@@ -127,6 +167,8 @@ export var LiteralDecoder;
             return Left(new LiteralDatatypeError(literal));
         }
         switch (literalDatatypeDefinition.kind) {
+            case "bigdecimal":
+                return decodeBigDecimalLiteral(literal).chain((value) => convertBigDecimalToNumber(literal, value));
             case "bigint":
                 return decodeBigIntLiteral(literal).chain((value) => convertBigIntToNumber(literal, value));
             case "float":
@@ -151,6 +193,8 @@ export var LiteralDecoder;
             return Left(new LiteralDatatypeError(literal));
         }
         switch (literalDatatypeDefinition.kind) {
+            case "bigdecimal":
+                return decodeBigDecimalLiteral(literal).chain((value) => convertBigDecimalToNumber(literal, value));
             case "bigint":
                 return decodeBigIntLiteralValue(literal).chain((value) => convertBigIntToNumber(literal, value));
             case "float":

package/dist/LiteralFactory.d.ts

@@ -1,4 +1,5 @@
 import type { DataFactory, Literal, NamedNode } from "@rdfjs/types";
+import type { Decimal } from "decimal.js";
 import type { Primitive } from "./Primitive.js";
 /**
  * Factory with methods for creating RDF/JS Literals from other types.
@@ -9,12 +10,13 @@ export declare class LiteralFactory {
     constructor({ dataFactory }: {
         dataFactory: DataFactory;
     });
+    bigdecimal(value: Decimal, datatype?: NamedNode): Literal;
     bigint(value: bigint, datatype?: NamedNode): Literal;
     boolean(value: boolean, datatype?: NamedNode): Literal;
     date(value: Date, datatype?: NamedNode): Literal;
     number(value: number, datatype?: NamedNode): Literal;
-    private numeric;
     primitive(value: Primitive, datatype?: NamedNode): Literal;
     string(value: string, datatype?: NamedNode): Literal;
+    private numeric;
 }
 //# sourceMappingURL=LiteralFactory.d.ts.map

package/dist/LiteralFactory.js

@@ -34,6 +34,9 @@ export class LiteralFactory {
             unsignedShort: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedShort"),
         };
     }
+    bigdecimal(value, datatype) {
+        return this.numeric(value, datatype ?? this.xsd.decimal);
+    }
     bigint(value, datatype) {
         return this.numeric(value, datatype ?? this.xsd.integer);
     }
@@ -119,6 +122,27 @@ export class LiteralFactory {
         }
         return this.numeric(value, datatype);
     }
+    primitive(value, datatype) {
+        switch (typeof value) {
+            case "bigint":
+                return this.bigint(value, datatype);
+            case "boolean":
+                return this.boolean(value, datatype);
+            case "number":
+                return this.number(value, datatype);
+            case "string":
+                return this.string(value, datatype);
+        }
+    }
+    string(value, datatype) {
+        if (datatype) {
+            const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
+            if (datatypeDefinition && datatypeDefinition.kind !== "string") {
+                throw new DatatypeRangeError(datatype);
+            }
+        }
+        return this.dataFactory.literal(value, datatype);
+    }
     numeric(value, datatype) {
         let valueString;
         const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
@@ -131,13 +155,30 @@ export class LiteralFactory {
             else {
                 switch (datatypeDefinition.kind) {
                     case "bigdecimal":
+                        break;
                     case "bigint":
                     case "float":
                     case "int": {
                         const [min, max] = datatypeDefinition.range;
-                        if ((min !== undefined && value < min) ||
-                            (max !== undefined && value > max)) {
-                            throw new RangeError(`value (${value}) outside range [${min}, ${max}] of ${datatype.value}`);
+                        if (max !== undefined) {
+                            if (typeof value === "object") {
+                                if (value.gt(max)) {
+                                    throw new RangeError(`value (${value}) above maximum (${max}) of ${datatype.value}`);
+                                }
+                            }
+                            else if (value > max) {
+                                throw new RangeError(`value (${value}) above maximum (${max}) of ${datatype.value}`);
+                            }
+                        }
+                        if (min !== undefined) {
+                            if (typeof value === "object") {
+                                if (value.lt(min)) {
+                                    throw new RangeError(`value (${value}) below minimum (${min}) of ${datatype.value}`);
+                                }
+                            }
+                            else if (value < min) {
+                                throw new RangeError(`value (${value}) below minimum (${min}) of ${datatype.value}`);
+                            }
                         }
                         break;
                     }
@@ -172,26 +213,5 @@ export class LiteralFactory {
         }
         return this.dataFactory.literal(valueString, datatype);
     }
-    primitive(value, datatype) {
-        switch (typeof value) {
-            case "bigint":
-                return this.bigint(value, datatype);
-            case "boolean":
-                return this.boolean(value, datatype);
-            case "number":
-                return this.number(value, datatype);
-            case "string":
-                return this.string(value, datatype);
-        }
-    }
-    string(value, datatype) {
-        if (datatype) {
-            const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
-            if (datatypeDefinition && datatypeDefinition.kind !== "string") {
-                throw new DatatypeRangeError(datatype);
-            }
-        }
-        return this.dataFactory.literal(value, datatype);
-    }
 }
 //# sourceMappingURL=LiteralFactory.js.map

package/package.json

@@ -1,10 +1,11 @@
 {
   "dependencies": {
     "@rdfjs/types": "~2.0.1",
+    "decimal.js": "~10.6.0",
     "purify-ts": "~2.1.4"
   },
   "devDependencies": {
-    "@rdfx/data-factory": "0.0.21",
+    "@rdfx/data-factory": "0.0.22",
     "@tpluscode/rdf-ns-builders": "~4.3.0"
   },
   "files": [
@@ -30,5 +31,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.0.21"
+  "version": "0.0.22"
 }