RDF Literal

RDF Literal makes it easier to translate between RDF literals and JavaScript primitives.

This library accepts RDFJS-compliant terms.

Installation

1$ yarn add rdf-literal

This package also works out-of-the-box in browsers via tools such as webpack and browserify.

Require

1import {
2  fromRdf,
3  toRdf,
4  getSupportedJavaScriptPrimitives,
5  getSupportedRdfDatatypes,
6  getTermRaw,
7} from "rdf-literal";

or

1const {
2  fromRdf,
3  toRdf,
4  getSupportedJavaScriptPrimitives,
5  getSupportedRdfDatatypes,
6  getTermRaw,
7} = require("rdf-literal");

Usage

This library offers the following functions:

• fromRdf: Converts an RDF literal to a JavaScript primitive.
• toRdf: Converts a JavaScript primitive to an RDF literal.

Next to that, the following helper functions are provided:

• getSupportedJavaScriptPrimitives: An array of all JavaScript primitive types that can be converted.
• getSupportedRdfDatatypes: An array of all RDF datatypes (as NamedNodes) that can be converted.
• getTermRaw: Converts any RDF term to a JavaScript primitive. If the term is a literal, fromRdf will be called on it. Otherwise, the .value string will be returned.

Examples

Converting JavaScript from RDF

fromRdf(literal, validate?) converts an RDF literal to a JavaScript value.

Optionally, the validate argument can be passed as true to force an error to be thrown if an invalid value for the given datatype is detected.

Converting an RDF string literal

Explicit string datatypes are converted into JS strings.

1fromRdf(literal('abc'); // Returns 'abc'
2fromRdf(literal('abc', 'en-us'); // Returns 'abc'
3fromRdf(literal('abc',
4  namedNode('http://www.w3.org/2001/XMLSchema#normalizedString')); // Returns 'abc'

Converting an RDF number literal

Integer-like and double-like literals are converted into JS numbers.

1// Integers
2fromRdf(literal('123',
3  namedNode('http://www.w3.org/2001/XMLSchema#integer')); // Returns 123
4fromRdf(literal('123',
5  namedNode('http://www.w3.org/2001/XMLSchema#long')); // Returns 123
6
7// Doubles
8fromRdf(literal('123.456',
9  namedNode('http://www.w3.org/2001/XMLSchema#double')); // Returns 123.456
10fromRdf(literal('123.456',
11  namedNode('http://www.w3.org/2001/XMLSchema#float')); // Returns 123.456
12
13// Invalid integers
14fromRdf(literal('123.456',
15  namedNode('http://www.w3.org/2001/XMLSchema#integer')); // Returns 123
16fromRdf(literal('123.456',
17  namedNode('http://www.w3.org/2001/XMLSchema#integer'), true); // Throws error

Converting an RDF boolean literal

Boolean literals are converted into JS booleans.

1fromRdf(literal('true',
2  namedNode('http://www.w3.org/2001/XMLSchema#boolean')); // Returns true
3fromRdf(literal('0',
4  namedNode('http://www.w3.org/2001/XMLSchema#boolean')); // Returns false

Converting an RDF date literal

Date(time) literals are converted into JS Dates.

1fromRdf(literal('2012-03-17T23:00:00.000Z',
2  namedNode('http://www.w3.org/2001/XMLSchema#dateTime'))); // Returns a Date
3fromRdf(literal('2012-03-17',
4  namedNode('http://www.w3.org/2001/XMLSchema#date'))); // Returns a Date
5fromRdf(literal('2012-03',
6  namedNode('http://www.w3.org/2001/XMLSchema#gYearMonth'))); // Returns a Date

Converting an RDF literal with unknown datatype

Unknown datatypes are considered JS strings.

1fromRdf(literal('abc',
2  namedNode('http://example.org/unknown')); // Returns 'abc'

Converting JavaScript to RDF

toRdf(value, options?) converts a JavaScript value to an RDF literal term.

The optional options object can contain the following optional fields:

Name	Description
datatype	A custom NamedNode datatype that can be forced upon the literal value, which may influence the format of literal values.
dataFactory	DataFactory for creating RDF terms.

Converting a string

JS strings are converted to plain RDF literals.

1toRdf('abc'); // Returns literal('abc')

Converting a number

JS numbers are converted to RDF integers or doubles.

1toRdf(123); // Returns literal('123',
2            //           namedNode('http://www.w3.org/2001/XMLSchema#integer')
3
4toRdf(123.456); // Returns literal('123.456',
5                //           namedNode('http://www.w3.org/2001/XMLSchema#double')

Converting a boolean

JS booleans are converted to RDF booleans.

1toRdf(true); // Returns literal('true',
2             //           namedNode('http://www.w3.org/2001/XMLSchema#boolean')

Converting a Date

JS Dates are converted to RDF date times.

1toRdf(new Date('2012-03-17'));
2// Returns literal('2012-03-17T00:00:00.000Z',
3//           namedNode('http://www.w3.org/2001/XMLSchema#dateTime'))
4
5toRdf(new Date('2012-03-17T23:00:00.000Z'));
6// Returns literal('2012-03-17T23:00:00.000Z',
7//           namedNode('http://www.w3.org/2001/XMLSchema#dateTime'))
8
9toRdf(new Date('2012-03-17'),
10  { datatype: namedNode('http://www.w3.org/2001/XMLSchema#date') });
11// Returns literal('2012-03-17',
12// namedNode('http://www.w3.org/2001/XMLSchema#date'))
13
14toRdf(2012,
15  { datatype: namedNode('http://www.w3.org/2001/XMLSchema#gYear') });
16// Returns literal('2012',
17//           namedNode('http://www.w3.org/2001/XMLSchema#gYear'))

Conversion range

The following table shows how RDF datatypes and JavaScript primitives are mapped:

JavaScript primitive	RDF Datatype
string	xsd:string
string	xsd:normalizedString
string	xsd:anyURI
string	xsd:base64Binary
string	xsd:language
string	xsd:Name
string	xsd:NCName
string	xsd:NMTOKEN
string	xsd:token
string	xsd:hexBinary
string	rdf:langString
boolean	xsd:boolean
number	xsd:integer
number	xsd:long
number	xsd:int
number	xsd:byte
number	xsd:short
number	xsd:negativeInteger
number	xsd:nonNegativeInteger
number	xsd:nonPositiveInteger
number	xsd:positiveInteger
number	xsd:unsignedByte
number	xsd:unsignedInt
number	xsd:unsignedLong
number	xsd:unsignedShort
number	xsd:double
number	xsd:decimal
number	xsd:float
Date	xsd:dateTime
Date	xsd:date
Date	xsd:gDay
Date	xsd:gMonthDay
Date	xsd:gYear
Date	xsd:gYearMonth

Used prefixes:

• xsd: <http://www.w3.org/2001/XMLSchema#>
• rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

The following XSD datatypes that are standardized in RDF are not supported, and will therefore be interpreted as plain strings:

• xsd:duration
• xsd:time

Any other unknown datatypes will also be interpreted as plain strings.

License

This software is written by Ruben Taelman.

This code is released under the MIT license.