@rdfx/resource 0.0.1

package/dist/LiteralDecoder.js

@@ -0,0 +1,213 @@
+import { Either, Left } from "purify-ts";
+import { literalDatatypeDefinitions } from "./literalDatatypeDefinitions.js";
+/**
+ * Decode other types from RDF/JS Literals.
+ *
+ * Partially adapted from rdf-literal.js (https://github.com/rubensworks/rdf-literal.js), MIT license.
+ */
+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 convertBigIntToNumber(literal, value) {
+        if (value >= BIGINT_NUMBER_MIN_SAFE_INTEGER &&
+            value <= BIGINT_NUMBER_MAX_SAFE_INTEGER) {
+            return Either.of(Number(value));
+        }
+        return Left(new LiteralValueError(literal, `bigint ${value} is outside number's safe integer range [${Number.MIN_SAFE_INTEGER}, ${Number.MAX_SAFE_INTEGER}]`));
+    }
+    function convertNumberToBigInt(literal, value) {
+        if (Number.isInteger(value)) {
+            return Either.of(BigInt(value));
+        }
+        return Left(new LiteralValueError(literal, `number ${value} is not an integer`));
+    }
+    function decodeBigIntLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigint":
+                return decodeBigIntLiteralValue(literal);
+            case "float":
+                return decodeFloatLiteralValue(literal).chain((value) => convertNumberToBigInt(literal, value));
+            case "int":
+                return decodeIntLiteralValue(literal).chain((value) => convertNumberToBigInt(literal, value));
+            default:
+                return Left(new LiteralDatatypeError(literal));
+        }
+    }
+    LiteralDecoder.decodeBigIntLiteral = decodeBigIntLiteral;
+    function decodeBigIntLiteralValue(literal) {
+        return Either.encase(() => BigInt(literal.value));
+    }
+    function decodeBooleanLiteral(literal) {
+        if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "boolean") {
+            return decodeBooleanLiteralValue(literal);
+        }
+        return Left(new LiteralDatatypeError(literal));
+    }
+    LiteralDecoder.decodeBooleanLiteral = decodeBooleanLiteral;
+    function decodeBooleanLiteralValue(literal) {
+        switch (literal.value) {
+            case "false":
+            case "0":
+                return Either.of(false);
+            case "true":
+            case "1":
+                return Either.of(true);
+            default:
+                return Left(new LiteralValueError(literal));
+        }
+    }
+    function decodeDateLiteral(literal) {
+        if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "date") {
+            return decodeDateLiteralValue(literal);
+        }
+        return Left(new LiteralDatatypeError(literal));
+    }
+    LiteralDecoder.decodeDateLiteral = decodeDateLiteral;
+    function decodeDateLiteralValue(literal) {
+        if (!literal.value.match(/^[0-9]+-[0-9][0-9]-[0-9][0-9]Z?$/)) {
+            return Left(new LiteralValueError(literal));
+        }
+        return Either.of(new Date(literal.value));
+    }
+    function decodeDateTimeLiteral(literal) {
+        if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "datetime") {
+            return decodeDateTimeLiteralValue(literal);
+        }
+        return Left(new LiteralDatatypeError(literal));
+    }
+    LiteralDecoder.decodeDateTimeLiteral = decodeDateTimeLiteral;
+    function decodeDateTimeLiteralValue(literal) {
+        if (!literal.value.match(/^[0-9]+-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9](\.[0-9][0-9][0-9])?((Z?)|([+-][0-9][0-9]:[0-9][0-9]))$/)) {
+            return Left(new LiteralValueError(literal));
+        }
+        return Either.of(new Date(literal.value));
+    }
+    function decodeFloatLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigint":
+                return decodeBigIntLiteral(literal).chain((value) => convertBigIntToNumber(literal, value));
+            case "float":
+            case "int":
+                return decodeFloatLiteralValue(literal);
+            default:
+                return Left(new LiteralDatatypeError(literal));
+        }
+    }
+    LiteralDecoder.decodeFloatLiteral = decodeFloatLiteral;
+    function decodeFloatLiteralValue(literal) {
+        return Either.encase(() => {
+            switch (literal.value.toUpperCase()) {
+                case "NAN":
+                    return NaN;
+                case "INF":
+                case "+INF":
+                    return Infinity;
+                case "-INF":
+                    return -Infinity;
+            }
+            const value = Number.parseFloat(literal.value);
+            if (Number.isNaN(value)) {
+                throw new LiteralValueError(literal, "not a number");
+            }
+            return value;
+        });
+    }
+    function decodeIntLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigint":
+                return decodeBigIntLiteral(literal).chain((value) => convertBigIntToNumber(literal, value));
+            case "float":
+            case "int":
+                return decodeIntLiteralValue(literal);
+            default:
+                return Left(new LiteralDatatypeError(literal));
+        }
+    }
+    LiteralDecoder.decodeIntLiteral = decodeIntLiteral;
+    function decodeIntLiteralValue(literal) {
+        return decodeFloatLiteralValue(literal).chain((value) => {
+            if (Number.isInteger(value)) {
+                return Either.of(value);
+            }
+            return Left(new LiteralValueError(literal, `${value} is not an integer`));
+        });
+    }
+    function decodeNumberLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigint":
+                return decodeBigIntLiteralValue(literal).chain((value) => convertBigIntToNumber(literal, value));
+            case "float":
+                return decodeFloatLiteralValue(literal);
+            case "int":
+                return decodeIntLiteralValue(literal);
+            default:
+                return Left(new LiteralDatatypeError(literal));
+        }
+    }
+    LiteralDecoder.decodeNumberLiteral = decodeNumberLiteral;
+    function decodePrimitiveLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigdecimal":
+                return Left(new LiteralDatatypeError(literal, "unable to decode bigdecimal Literal"));
+            case "bigint":
+                return decodeBigIntLiteralValue(literal);
+            case "boolean":
+                return decodeBooleanLiteralValue(literal);
+            case "date":
+                return decodeDateLiteralValue(literal);
+            case "datetime":
+                return decodeDateTimeLiteralValue(literal);
+            case "float":
+                return decodeFloatLiteralValue(literal);
+            case "int":
+                return decodeIntLiteralValue(literal);
+            case "string":
+                return decodeStringLiteralValue(literal);
+        }
+    }
+    LiteralDecoder.decodePrimitiveLiteral = decodePrimitiveLiteral;
+    function decodeStringLiteral(literal) {
+        if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "string") {
+            return decodeStringLiteralValue(literal);
+        }
+        return Left(new LiteralDatatypeError(literal));
+    }
+    LiteralDecoder.decodeStringLiteral = decodeStringLiteral;
+    function decodeStringLiteralValue(literal) {
+        return Either.of(literal.value);
+    }
+    class LiteralDatatypeError extends Error {
+        constructor(literal, message) {
+            super(message ?? `unrecognized Literal datatype: ${literal.datatype.value}`);
+            this.literal = literal;
+        }
+    }
+    class LiteralValueError extends Error {
+        constructor(literal, message) {
+            super(message);
+            this.literal = literal;
+        }
+    }
+})(LiteralDecoder || (LiteralDecoder = {}));
+//# sourceMappingURL=LiteralDecoder.js.map

package/dist/LiteralFactory.d.ts

@@ -0,0 +1,19 @@
+import type { DataFactory, Literal, NamedNode } from "@rdfjs/types";
+import type { Primitive } from "./Primitive.js";
+/**
+ * Factory with methods for creating RDF/JS Literals from other types.
+ */
+export declare class LiteralFactory {
+    private readonly dataFactory;
+    constructor(options?: {
+        dataFactory?: DataFactory;
+    });
+    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;
+}
+//# sourceMappingURL=LiteralFactory.d.ts.map

package/dist/LiteralFactory.js

@@ -0,0 +1,183 @@
+import DefaultDataFactory from "@rdfjs/data-model";
+import { literalDatatypeDefinitions } from "./literalDatatypeDefinitions.js";
+import { xsd } from "./vocabularies.js";
+class DatatypeRangeError extends RangeError {
+    constructor(datatype) {
+        super(`datatype out of range: ${datatype.value}`);
+        this.datatype = datatype;
+    }
+}
+/**
+ * Factory with methods for creating RDF/JS Literals from other types.
+ */
+export class LiteralFactory {
+    constructor(options) {
+        this.dataFactory = options?.dataFactory ?? DefaultDataFactory;
+    }
+    bigint(value, datatype) {
+        return this.numeric(value, datatype ?? xsd.integer);
+    }
+    boolean(value, datatype) {
+        if (!datatype) {
+            datatype = xsd.boolean;
+        }
+        const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
+        if (datatypeDefinition && datatypeDefinition.kind !== "boolean") {
+            throw new DatatypeRangeError(datatype);
+        }
+        return this.dataFactory.literal(value.toString(), datatype);
+    }
+    date(value, datatype) {
+        if (!datatype) {
+            datatype = xsd.dateTime;
+        }
+        const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
+        if (datatypeDefinition) {
+            switch (datatypeDefinition.kind) {
+                case "date":
+                    return this.dataFactory.literal(value.toISOString().replace(/T.*$/, ""), datatype);
+                case "datetime":
+                    return this.dataFactory.literal(value.toISOString(), datatype);
+                default:
+                    throw new DatatypeRangeError(datatype);
+            }
+        }
+        // case "http://www.w3.org/2001/XMLSchema#gDay":
+        //   return this.dataFactory.literal(
+        //     value.getUTCDate().toString(),
+        //     datatype,
+        //   );
+        // case "http://www.w3.org/2001/XMLSchema#gMonthDay":
+        //   return this.dataFactory.literal(
+        //     `${value.getUTCMonth() + 1}-${value.getUTCDate()}`,
+        //     datatype,
+        //   );
+        // case "http://www.w3.org/2001/XMLSchema#gYear":
+        //   return this.dataFactory.literal(
+        //     value.getUTCFullYear().toString(),
+        //     datatype,
+        //   );
+        // case "http://www.w3.org/2001/XMLSchema#gYearMonth":
+        //   return this.dataFactory.literal(
+        //     `${value.getUTCFullYear()}-${value.getUTCMonth() + 1}`,
+        //     datatype,
+        //   );
+        return this.dataFactory.literal(value.toISOString(), datatype);
+    }
+    number(value, datatype) {
+        if (!datatype) {
+            if (Number.isInteger(value)) {
+                if (value < 0) {
+                    datatype = [xsd.byte, xsd.short, xsd.int].find((checkDatatype) => {
+                        const checkDatatypeDefinition = literalDatatypeDefinitions[checkDatatype.value];
+                        if (checkDatatypeDefinition?.kind !== "int") {
+                            throw new Error("should never happen");
+                        }
+                        return value >= checkDatatypeDefinition.range[0];
+                    });
+                }
+                else {
+                    datatype = [
+                        xsd.unsignedByte,
+                        xsd.unsignedShort,
+                        xsd.unsignedInt,
+                    ].find((checkDatatype) => {
+                        const checkDatatypeDefinition = literalDatatypeDefinitions[checkDatatype.value];
+                        if (checkDatatypeDefinition?.kind !== "int") {
+                            throw new Error("should never happen");
+                        }
+                        return value <= checkDatatypeDefinition.range[1];
+                    });
+                }
+                if (!datatype) {
+                    datatype = xsd.integer;
+                }
+            }
+            else {
+                datatype = xsd.double;
+            }
+        }
+        return this.numeric(value, datatype);
+    }
+    numeric(value, datatype) {
+        let valueString;
+        const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
+        if (datatypeDefinition) {
+            if (Number.isNaN(value) || value === Infinity || value === -Infinity) {
+                if (datatypeDefinition.kind !== "float") {
+                    throw new RangeError(`NaN/INF/-INF values only supported by xsd:double and xsd:float`);
+                }
+            }
+            else {
+                switch (datatypeDefinition.kind) {
+                    case "bigdecimal":
+                    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}`);
+                        }
+                        break;
+                    }
+                    default:
+                        throw new DatatypeRangeError(datatype);
+                }
+                if (datatypeDefinition.kind === "float") {
+                    // Convert the number to scientific notation so Turtle will recognize it as an double without ^^
+                    // Example: 1 -> 1e0
+                    // Assume this coercion to number won't lose anything since we checked the range above.
+                    let [mantissa, exponent] = Number(value).toExponential().split("e");
+                    exponent = exponent.replace(/^\+/, "").replace(/^(-?)0+(\d)/, "$1$2");
+                    valueString = `${mantissa}e${exponent}`;
+                }
+            }
+        }
+        if (!valueString) {
+            if (typeof value === "number") {
+                if (Number.isNaN(value)) {
+                    valueString = "NaN";
+                }
+                else if (value === Infinity) {
+                    valueString = "INF";
+                }
+                else if (value === -Infinity) {
+                    valueString = "-INF";
+                }
+            }
+            if (!valueString) {
+                valueString = value.toString(10);
+            }
+        }
+        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 "object": {
+                if (value instanceof Date) {
+                    return this.date(value, datatype);
+                }
+                throw new Error("not implemented");
+            }
+            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/dist/MissingValueError.d.ts

@@ -0,0 +1,10 @@
+import { PropertyPath } from "./PropertyPath.js";
+import type { Resource } from "./Resource.js";
+import { ValueError } from "./ValueError.js";
+export declare class MissingValueError extends ValueError {
+    constructor({ focusResource, propertyPath, }: {
+        focusResource: Resource;
+        propertyPath: PropertyPath;
+    });
+}
+//# sourceMappingURL=MissingValueError.d.ts.map

package/dist/MissingValueError.js

@@ -0,0 +1,13 @@
+import { Identifier } from "./Identifier.js";
+import { PropertyPath } from "./PropertyPath.js";
+import { ValueError } from "./ValueError.js";
+export class MissingValueError extends ValueError {
+    constructor({ focusResource, propertyPath, }) {
+        super({
+            focusResource,
+            message: `${Identifier.toString(focusResource.identifier)} missing ${PropertyPath.toString(propertyPath)}`,
+            propertyPath,
+        });
+    }
+}
+//# sourceMappingURL=MissingValueError.js.map

package/dist/MistypedPrimitiveValueError.d.ts

@@ -0,0 +1,13 @@
+import { MistypedValueError } from "./MistypedValueError.js";
+import type { Primitive } from "./Primitive.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

@@ -0,0 +1,15 @@
+import { Identifier } from "./Identifier.js";
+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 ${Identifier.toString(focusResource.identifier)} ${PropertyPath.toString(propertyPath)} to be a ${expectedValueType}, was ${typeof actualValue}`,
+            propertyPath,
+        });
+    }
+}
+//# sourceMappingURL=MistypedPrimitiveValueError.js.map

package/dist/MistypedTermValueError.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,15 @@
+import { Identifier } from "./Identifier.js";
+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 ${Identifier.toString(focusResource.identifier)} ${PropertyPath.toString(propertyPath)} to be a ${expectedValueType}, was ${actualValue.termType}`,
+            propertyPath,
+        });
+    }
+}
+//# sourceMappingURL=MistypedTermValueError.js.map

package/dist/MistypedValueError.d.ts

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

package/dist/MistypedValueError.js

@@ -0,0 +1,13 @@
+import { ValueError } from "./ValueError.js";
+export class MistypedValueError extends ValueError {
+    constructor({ actualValue, expectedValueType, focusResource, message, propertyPath, }) {
+        super({
+            focusResource,
+            message,
+            propertyPath,
+        });
+        this.actualValue = actualValue;
+        this.expectedValueType = expectedValueType;
+    }
+}
+//# sourceMappingURL=MistypedValueError.js.map

package/dist/Primitive.d.ts

@@ -0,0 +1,2 @@
+export type Primitive = bigint | boolean | Date | number | string;
+//# sourceMappingURL=Primitive.d.ts.map

package/dist/Primitive.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Primitive.js.map

package/dist/PropertyPath.d.ts

@@ -0,0 +1,46 @@
+import type { NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
+import { Either } from "purify-ts";
+import { Resource } from "./Resource.js";
+import { ResourceSet } from "./ResourceSet.js";
+interface AlternativePath {
+    readonly termType: "AlternativePath";
+    readonly members: readonly PropertyPath[];
+}
+interface InversePath {
+    readonly termType: "InversePath";
+    readonly path: PropertyPath;
+}
+interface OneOrMorePath {
+    readonly termType: "OneOrMorePath";
+    readonly path: PropertyPath;
+}
+type PredicatePath = NamedNode;
+interface SequencePath {
+    readonly termType: "SequencePath";
+    readonly members: readonly PropertyPath[];
+}
+interface ZeroOrMorePath {
+    readonly termType: "ZeroOrMorePath";
+    readonly path: PropertyPath;
+}
+interface ZeroOrOnePath {
+    readonly termType: "ZeroOrOnePath";
+    readonly path: PropertyPath;
+}
+/**
+ * A SHACL property path.
+ */
+export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
+export declare namespace PropertyPath {
+    function equals(left: PropertyPath, right: PropertyPath): boolean;
+    function fromResource(resource: Resource, options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+    }): Either<Error, PropertyPath>;
+    function toResource(propertyPath: PropertyPath, options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+    function toString(propertyPath: PropertyPath): string;
+}
+export {};
+//# sourceMappingURL=PropertyPath.d.ts.map