rdfjs-resource 2.0.0 → 2.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/LiteralDecoder.js +85 -39
  2. package/dist/literalDatatypeDefinitions.js +2 -1
  3. package/package.json +1 -1
package/dist/LiteralDecoder.js CHANGED
@@ -7,27 +7,40 @@ import { literalDatatypeDefinitions } from "./literalDatatypeDefinitions.js";
7
7
  */
8
8
  export var LiteralDecoder;
9
9
  (function (LiteralDecoder) {
10
+ const BIGINT_NUMBER_MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
11
+ const BIGINT_NUMBER_MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
12
+ function convertBigintToNumber(literal, value) {
13
+ if (value >= BIGINT_NUMBER_MIN_SAFE_INTEGER &&
14
+ value <= BIGINT_NUMBER_MAX_SAFE_INTEGER) {
15
+ return Either.of(Number(value));
16
+ }
17
+ return Left(new LiteralValueError(literal, `bigint ${value} is outside number's safe integer range [${Number.MIN_SAFE_INTEGER}, ${Number.MAX_SAFE_INTEGER}]`));
18
+ }
19
+ function convertNumberToBigint(literal, value) {
20
+ if (Number.isInteger(value)) {
21
+ return Either.of(BigInt(value));
22
+ }
23
+ return Left(new LiteralValueError(literal, `number ${value} is not an integer`));
24
+ }
10
25
  function decodeBigIntLiteral(literal) {
11
- if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "bigint") {
12
- return decodeBigIntLiteralValue(literal);
26
+ const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
27
+ if (!literalDatatypeDefinition) {
28
+ return Left(new LiteralDatatypeError(literal));
29
+ }
30
+ switch (literalDatatypeDefinition.kind) {
31
+ case "bigint":
32
+ return decodeBigIntLiteralValue(literal);
33
+ case "float":
34
+ return decodeFloatLiteralValue(literal).chain((value) => convertNumberToBigint(literal, value));
35
+ case "int":
36
+ return decodeIntLiteralValue(literal).chain((value) => convertNumberToBigint(literal, value));
37
+ default:
38
+ return Left(new LiteralDatatypeError(literal));
13
39
  }
14
- return Left(new LiteralDatatypeError(literal));
15
40
  }
16
41
  LiteralDecoder.decodeBigIntLiteral = decodeBigIntLiteral;
17
42
  function decodeBigIntLiteralValue(literal) {
18
- return Either.encase(() => {
19
- const value = BigInt(literal.value);
20
- const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
21
- if (literalDatatypeDefinition?.kind !== "bigint") {
22
- throw new LiteralDatatypeError(literal);
23
- }
24
- const [min, max] = literalDatatypeDefinition.range;
25
- if ((min !== undefined && value < min) ||
26
- (max !== undefined && value > max)) {
27
- throw new LiteralValueError(literal, `value (${value}) outside range [${min}, ${max}] of ${literal.datatype.value}`);
28
- }
29
- return value;
30
- });
43
+ return Either.encase(() => BigInt(literal.value));
31
44
  }
32
45
  function decodeBooleanLiteral(literal) {
33
46
  if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "boolean") {
@@ -75,45 +88,78 @@ export var LiteralDecoder;
75
88
  return Either.of(new Date(literal.value));
76
89
  }
77
90
  function decodeFloatLiteral(literal) {
78
- if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "float") {
79
- return decodeFloatLiteralValue(literal);
91
+ const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
92
+ if (!literalDatatypeDefinition) {
93
+ return Left(new LiteralDatatypeError(literal));
94
+ }
95
+ switch (literalDatatypeDefinition.kind) {
96
+ case "bigint":
97
+ return decodeBigIntLiteral(literal).chain((value) => convertBigintToNumber(literal, value));
98
+ case "float":
99
+ case "int":
100
+ return decodeFloatLiteralValue(literal);
101
+ default:
102
+ return Left(new LiteralDatatypeError(literal));
80
103
  }
81
- return Left(new LiteralDatatypeError(literal));
82
104
  }
83
105
  LiteralDecoder.decodeFloatLiteral = decodeFloatLiteral;
84
106
  function decodeFloatLiteralValue(literal) {
85
- return Either.encase(() => Number.parseFloat(literal.value));
107
+ return Either.encase(() => {
108
+ switch (literal.value.toUpperCase()) {
109
+ case "NAN":
110
+ return NaN;
111
+ case "INF":
112
+ case "+INF":
113
+ return Infinity;
114
+ case "-INF":
115
+ return -Infinity;
116
+ }
117
+ const value = Number.parseFloat(literal.value);
118
+ if (Number.isNaN(value)) {
119
+ throw new LiteralValueError(literal, "not a number");
120
+ }
121
+ return value;
122
+ });
86
123
  }
87
124
  function decodeIntLiteral(literal) {
88
- if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "int") {
89
- return decodeIntLiteralValue(literal);
125
+ const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
126
+ if (!literalDatatypeDefinition) {
127
+ return Left(new LiteralDatatypeError(literal));
128
+ }
129
+ switch (literalDatatypeDefinition.kind) {
130
+ case "bigint":
131
+ return decodeBigIntLiteral(literal).chain((value) => convertBigintToNumber(literal, value));
132
+ case "float":
133
+ case "int":
134
+ return decodeIntLiteralValue(literal);
135
+ default:
136
+ return Left(new LiteralDatatypeError(literal));
90
137
  }
91
- return Left(new LiteralDatatypeError(literal));
92
138
  }
93
139
  LiteralDecoder.decodeIntLiteral = decodeIntLiteral;
94
140
  function decodeIntLiteralValue(literal) {
95
- return Either.encase(() => {
96
- const value = Number.parseInt(literal.value, 10);
97
- const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
98
- if (literalDatatypeDefinition?.kind !== "int") {
99
- throw new LiteralDatatypeError(literal);
141
+ return decodeFloatLiteralValue(literal).chain((value) => {
142
+ if (Number.isInteger(value)) {
143
+ return Either.of(value);
100
144
  }
101
- const [min, max] = literalDatatypeDefinition.range;
102
- if ((min !== undefined && value < min) ||
103
- (max !== undefined && value > max)) {
104
- throw new LiteralValueError(literal, `value (${value}) outside range [${min}, ${max}] of ${literal.datatype.value}`);
105
- }
106
- return value;
145
+ return Left(new LiteralValueError(literal, `${value} is not an integer`));
107
146
  });
108
147
  }
109
148
  function decodeNumberLiteral(literal) {
110
- if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "float") {
111
- return decodeFloatLiteralValue(literal);
149
+ const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
150
+ if (!literalDatatypeDefinition) {
151
+ return Left(new LiteralDatatypeError(literal));
112
152
  }
113
- if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "int") {
114
- return decodeIntLiteralValue(literal);
153
+ switch (literalDatatypeDefinition.kind) {
154
+ case "bigint":
155
+ return decodeBigIntLiteralValue(literal).chain((value) => convertBigintToNumber(literal, value));
156
+ case "float":
157
+ return decodeFloatLiteralValue(literal);
158
+ case "int":
159
+ return decodeIntLiteralValue(literal);
160
+ default:
161
+ return Left(new LiteralDatatypeError(literal));
115
162
  }
116
- return Left(new LiteralDatatypeError(literal));
117
163
  }
118
164
  LiteralDecoder.decodeNumberLiteral = decodeNumberLiteral;
119
165
  function decodePrimitiveLiteral(literal) {
package/dist/literalDatatypeDefinitions.js CHANGED
@@ -23,7 +23,8 @@ export const literalDatatypeDefinitions = {
23
23
  // 64-bit
24
24
  "http://www.w3.org/2001/XMLSchema#double": {
25
25
  kind: "float",
26
- range: [Number.MIN_VALUE, Number.MAX_VALUE],
26
+ // Number.MIN_VALUE is the smallest positive number greater than 0
27
+ range: [-Number.MAX_VALUE, Number.MAX_VALUE],
27
28
  },
28
29
  // Arbitrary precision decimal
29
30
  "http://www.w3.org/2001/XMLSchema#decimal": {
package/package.json CHANGED
@@ -46,5 +46,5 @@
46
46
  },
47
47
  "type": "module",
48
48
  "types": "dist/index.d.ts",
49
- "version": "2.0.0"
49
+ "version": "2.0.2"
50
50
  }