@rdfx/resource 0.0.21 → 0.0.23

package/dist/MistypedValueError.d.ts

@@ -1,13 +1,12 @@
-import type { PropertyPath } from "./PropertyPath.js";
+import { PropertyPath } from "./PropertyPath.js";
 import type { Resource } from "./Resource.js";
 import { ValueError } from "./ValueError.js";
-export declare abstract class MistypedValueError<T> extends ValueError {
+export declare class MistypedValueError<T> extends ValueError {
     readonly actualValue: T;
     readonly expectedValueType: string;
-    constructor({ actualValue, expectedValueType, focusResource, message, propertyPath, }: {
+    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }: {
         actualValue: T;
         expectedValueType: string;
-        message: string;
         focusResource: Resource;
         propertyPath: PropertyPath;
     });

package/dist/MistypedValueError.js

@@ -1,11 +1,12 @@
+import { PropertyPath } from "./PropertyPath.js";
 import { ValueError } from "./ValueError.js";
 export class MistypedValueError extends ValueError {
     actualValue;
     expectedValueType;
-    constructor({ actualValue, expectedValueType, focusResource, message, propertyPath, }) {
+    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }) {
         super({
             focusResource,
-            message,
+            message: `expected ${focusResource.identifier} ${PropertyPath.toString(propertyPath)} to be a ${expectedValueType}, was ${actualValue}`,
             propertyPath,
         });
         this.actualValue = actualValue;

package/dist/Resource.d.ts

@@ -2,7 +2,8 @@ import type { BlankNode, DataFactory, DatasetCore, Literal, NamedNode, Quad_Grap
 import { Either } from "purify-ts";
 import type { Identifier as _Identifier, Identifier } from "./Identifier.js";
 import { ListStructureError as _ListStructureError } from "./ListStructureError.js";
-import { MistypedTermValueError as _MistypedTermValueError } from "./MistypedTermValueError.js";
+import { MissingValueError as _MissingValueError } from "./MissingValueError.js";
+import { MistypedValueError as _MistypedValueError } from "./MistypedValueError.js";
 import type { PropertyPath } from "./PropertyPath.js";
 import type { Term } from "./Term.js";
 import { Value as _Value } from "./Value.js";
@@ -94,8 +95,10 @@ export declare namespace Resource {
     type Identifier = _Identifier;
     const ListStructureError: typeof _ListStructureError;
     type ListStructureError = _ListStructureError;
-    const MistypedTermValueError: typeof _MistypedTermValueError;
-    type MistypedTermValueError = _MistypedTermValueError;
+    const MissingValueError: typeof _MissingValueError;
+    type MissingValueError = _MissingValueError;
+    const MistypedValueError: typeof _MistypedValueError;
+    type MistypedValueError<T> = _MistypedValueError<T>;
     const ValueError: typeof _ValueError;
     type ValueError = _ValueError;
     const Value: typeof _Value;

package/dist/Resource.js

@@ -2,7 +2,8 @@ import TermSet from "@rdfjs/term-set";
 import { Either, Left } from "purify-ts";
 import { DatasetValues } from "./DatasetValues.js";
 import { ListStructureError as _ListStructureError } from "./ListStructureError.js";
-import { MistypedTermValueError as _MistypedTermValueError } from "./MistypedTermValueError.js";
+import { MissingValueError as _MissingValueError } from "./MissingValueError.js";
+import { MistypedValueError as _MistypedValueError } from "./MistypedValueError.js";
 import { Value as _Value } from "./Value.js";
 import { ValueError as _ValueError } from "./ValueError.js";
 import { Values as _Values } from "./Values.js";
@@ -253,7 +254,7 @@ export class Resource {
             case "NamedNode":
                 break;
             default:
-                return Left(new Resource.MistypedTermValueError({
+                return Left(new Resource.MistypedValueError({
                     actualValue: firstObject,
                     expectedValueType: "BlankNode | Literal | NamedNode",
                     focusResource: this,
@@ -283,7 +284,7 @@ export class Resource {
             case "NamedNode":
                 break;
             default:
-                return Left(new Resource.MistypedTermValueError({
+                return Left(new Resource.MistypedValueError({
                     actualValue: restObject,
                     expectedValueType: "BlankNode | NamedNode",
                     focusResource: this,
@@ -324,7 +325,8 @@ export class Resource {
 }
 (function (Resource) {
     Resource.ListStructureError = _ListStructureError;
-    Resource.MistypedTermValueError = _MistypedTermValueError;
+    Resource.MissingValueError = _MissingValueError;
+    Resource.MistypedValueError = _MistypedValueError;
     Resource.ValueError = _ValueError;
     Resource.Value = _Value;
     Resource.Values = _Values;

package/dist/Value.d.ts

@@ -1,5 +1,6 @@
 import type { BlankNode, DataFactory, Literal, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
 import { type Primitive } from "@rdfx/literal";
+import type { Decimal } from "decimal.js";
 import { Either } from "purify-ts";
 import type { Identifier } from "./Identifier.js";
 import type { PropertyPath } from "./PropertyPath.js";
@@ -17,6 +18,10 @@ export declare class Value<TermT extends Term = Term> {
         propertyPath: PropertyPath;
         term: TermT;
     });
+    /**
+     * Try to convert this term to a bigint.
+     */
+    toBigDecimal(in_?: readonly Decimal[]): Either<Error, Decimal>;
     /**
      * Try to convert this term to a bigint.
      */

package/dist/Value.js

@@ -1,9 +1,7 @@
 import { LiteralDecoder } from "@rdfx/literal";
 import { NTriplesTerm } from "@rdfx/string";
 import { Either, Left } from "purify-ts";
-import { MistypedDateValueError } from "./MistypedDateValueError.js";
-import { MistypedPrimitiveValueError } from "./MistypedPrimitiveValueError.js";
-import { MistypedTermValueError } from "./MistypedTermValueError.js";
+import { MistypedValueError } from "./MistypedValueError.js";
 import { Resource } from "./Resource.js";
 import { Values } from "./Values.js";
 import { rdf } from "./vocabularies.js";
@@ -18,6 +16,25 @@ export class Value {
         this.propertyPath = propertyPath;
         this.term = term;
     }
+    /**
+     * Try to convert this term to a bigint.
+     */
+    toBigDecimal(in_) {
+        return this.toLiteral()
+            .chain(LiteralDecoder.decodeBigDecimalLiteral)
+            .mapLeft(() => this.newMistypedTermValueError(in_ ? in_.map((_) => _.toString()).join(" | ") : "Decimal"))
+            .chain((value) => {
+            if (in_ && !in_.some((check) => value.equals(check))) {
+                return Left(new MistypedValueError({
+                    actualValue: value,
+                    expectedValueType: in_.map((_) => _.toString()).join(" | "),
+                    focusResource: this.focusResource,
+                    propertyPath: this.propertyPath,
+                }));
+            }
+            return Either.of(value);
+        });
+    }
     toBigInt(in_) {
         return this.toLiteral()
             .chain(LiteralDecoder.decodeBigIntLiteral)
@@ -152,7 +169,7 @@ export class Value {
     }
     constrainDate(value, in_) {
         if (in_ && !in_.some((check) => value.getTime() === check.getTime())) {
-            return Left(new MistypedDateValueError({
+            return Left(new MistypedValueError({
                 actualValue: value,
                 expectedValueType: in_.map((_) => _.toISOString()).join(" | "),
                 focusResource: this.focusResource,
@@ -163,7 +180,7 @@ export class Value {
     }
     constrainPrimitive(value, in_) {
         if (in_ && !in_.some((check) => value === check)) {
-            return Left(new MistypedPrimitiveValueError({
+            return Left(new MistypedValueError({
                 actualValue: value,
                 expectedValueType: in_.map((_) => _.toString()).join(" | "),
                 focusResource: this.focusResource,
@@ -174,7 +191,7 @@ export class Value {
     }
     constrainTerm(value, in_) {
         if (in_ && !in_.some((check) => value.equals(check))) {
-            return Left(new MistypedTermValueError({
+            return Left(new MistypedValueError({
                 actualValue: value,
                 expectedValueType: in_.map(NTriplesTerm.stringify).join(" | "),
                 focusResource: this.focusResource,
@@ -184,7 +201,7 @@ export class Value {
         return Either.of(value);
     }
     newMistypedTermValueError(expectedValueType) {
-        return new MistypedTermValueError({
+        return new MistypedValueError({
             actualValue: this.term,
             expectedValueType,
             focusResource: this.focusResource,

package/package.json

@@ -1,14 +1,15 @@
 {
   "dependencies": {
-    "@rdfx/literal": "0.0.21",
-    "@rdfx/string": "0.0.21",
+    "@rdfx/literal": "0.0.23",
+    "@rdfx/string": "0.0.23",
     "@rdfjs/term-set": "~2.0.3",
     "@rdfjs/types": "~2.0.1",
     "@types/rdfjs__term-set": "~2.0.9",
+    "decimal.js": "~10.6.0",
     "purify-ts": "~2.1.4"
   },
   "devDependencies": {
-    "@rdfx/data-factory": "0.0.21",
+    "@rdfx/data-factory": "0.0.23",
     "@rdfjs/dataset": "~2.0.2",
     "@tpluscode/rdf-ns-builders": "~4.3.0",
     "@types/rdfjs__dataset": "~2.0.7",
@@ -40,5 +41,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.0.21"
+  "version": "0.0.23"
 }

package/dist/MistypedDateValueError.d.ts

@@ -1,12 +0,0 @@
-import { MistypedValueError } from "./MistypedValueError.js";
-import { PropertyPath } from "./PropertyPath.js";
-import type { Resource } from "./Resource.js";
-export declare class MistypedDateValueError extends MistypedValueError<Date> {
-    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }: {
-        actualValue: Date;
-        expectedValueType: string;
-        focusResource: Resource;
-        propertyPath: PropertyPath;
-    });
-}
-//# sourceMappingURL=MistypedDateValueError.d.ts.map

package/dist/MistypedDateValueError.js

@@ -1,14 +0,0 @@
-import { MistypedValueError } from "./MistypedValueError.js";
-import { PropertyPath } from "./PropertyPath.js";
-export class MistypedDateValueError extends MistypedValueError {
-    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }) {
-        super({
-            actualValue,
-            expectedValueType,
-            focusResource,
-            message: `expected ${focusResource.identifier} ${PropertyPath.toString(propertyPath)} to be a ${expectedValueType}, was ${typeof actualValue}`,
-            propertyPath,
-        });
-    }
-}
-//# sourceMappingURL=MistypedDateValueError.js.map

package/dist/MistypedPrimitiveValueError.d.ts

@@ -1,13 +0,0 @@
-import type { Primitive } from "@rdfx/literal";
-import { MistypedValueError } from "./MistypedValueError.js";
-import { PropertyPath } from "./PropertyPath.js";
-import type { Resource } from "./Resource.js";
-export declare class MistypedPrimitiveValueError extends MistypedValueError<Primitive> {
-    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }: {
-        actualValue: Primitive;
-        expectedValueType: string;
-        focusResource: Resource;
-        propertyPath: PropertyPath;
-    });
-}
-//# sourceMappingURL=MistypedPrimitiveValueError.d.ts.map

package/dist/MistypedPrimitiveValueError.js

@@ -1,14 +0,0 @@
-import { MistypedValueError } from "./MistypedValueError.js";
-import { PropertyPath } from "./PropertyPath.js";
-export class MistypedPrimitiveValueError extends MistypedValueError {
-    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }) {
-        super({
-            actualValue,
-            expectedValueType,
-            focusResource,
-            message: `expected ${focusResource.identifier} ${PropertyPath.toString(propertyPath)} to be a ${expectedValueType}, was ${typeof actualValue}`,
-            propertyPath,
-        });
-    }
-}
-//# sourceMappingURL=MistypedPrimitiveValueError.js.map

package/dist/MistypedTermValueError.d.ts

@@ -1,13 +0,0 @@
-import type { BlankNode, Literal, NamedNode, Quad, Variable } from "@rdfjs/types";
-import { MistypedValueError } from "./MistypedValueError.js";
-import { PropertyPath } from "./PropertyPath.js";
-import type { Resource } from "./Resource.js";
-export declare class MistypedTermValueError extends MistypedValueError<BlankNode | Literal | NamedNode | Quad | Variable> {
-    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }: {
-        actualValue: BlankNode | Literal | NamedNode | Quad | Variable;
-        expectedValueType: string;
-        focusResource: Resource;
-        propertyPath: PropertyPath;
-    });
-}
-//# sourceMappingURL=MistypedTermValueError.d.ts.map

package/dist/MistypedTermValueError.js

@@ -1,14 +0,0 @@
-import { MistypedValueError } from "./MistypedValueError.js";
-import { PropertyPath } from "./PropertyPath.js";
-export class MistypedTermValueError extends MistypedValueError {
-    constructor({ actualValue, expectedValueType, focusResource, propertyPath, }) {
-        super({
-            actualValue,
-            expectedValueType,
-            focusResource,
-            message: `expected ${focusResource.identifier} ${PropertyPath.toString(propertyPath)} to be a ${expectedValueType}, was ${actualValue.termType}`,
-            propertyPath,
-        });
-    }
-}
-//# sourceMappingURL=MistypedTermValueError.js.map