link-rdflib
Version:
an RDF library for node.js, patched for speed.
308 lines (244 loc) • 10 kB
JavaScript
;
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
var ClassOrder = require('./class-order');
var NamedNode = require('./named-node');
var Term = require('./term');
var XSD = require('./xsd');
var Literal =
/*#__PURE__*/
function (_Term) {
_inherits(Literal, _Term);
function Literal(value, language, datatype) {
var _this;
_classCallCheck(this, Literal);
_this = _possibleConstructorReturn(this, _getPrototypeOf(Literal).call(this));
_this.termType = Literal.termType;
_this.value = value;
if (language) {
_this.lang = language;
datatype = XSD.langString;
} // If not specified, a literal has the implied XSD.string default datatype
_this.datatype = datatype ? NamedNode.find(datatype) : XSD.string;
var existing = Literal.findLiteralByValue(value, language, datatype);
if (existing) {
return _possibleConstructorReturn(_this, existing);
}
Literal.mem(_assertThisInitialized(_assertThisInitialized(_this)));
return _this;
}
_createClass(Literal, [{
key: "copy",
value: function copy() {
return Literal.find(this.value, this.lang, this.datatype);
}
}, {
key: Symbol.toPrimitive,
value: function value(_) {
if ([undefined, XSD.string, XSD.langString].includes(this.datatype)) {
return this.value;
}
if (this.datatype === XSD.boolean) {
return this.value === 'true' || this.value === '1';
}
if ([XSD.date, XSD.dateTime, XSD.dateTimeStamp].includes(this.datatype)) {
return new Date(this.value);
}
if ([XSD.decimal, XSD.double, XSD.integer, XSD.int, XSD.float, XSD.long].includes(this.datatype)) {
return Number(this.value);
}
return undefined;
}
}, {
key: "toNT",
value: function toNT() {
if (typeof this.value === 'number') {
return this.toString();
} else if (typeof this.value !== 'string') {
throw new Error('Value of RDF literal is not string or number: ' + this.value);
}
var str = this.value;
str = str.replace(/\\/g, '\\\\');
str = str.replace(/\"/g, '\\"');
str = str.replace(/\n/g, '\\n');
str = '"' + str + '"';
if (this.language) {
str += '@' + this.language;
} else if (this.datatype !== XSD.string) {
// Only add datatype if it's not a string
str += '^^' + this.datatype.toCanonical();
}
return str;
}
/**
* Assigns an index number and adds a Literal instance to the indices
* @private
* @param lit The Literal instance to register
* @return {Literal} The updated Literal instance
*/
}, {
key: "language",
get: function get() {
return this.lang;
},
set: function set(language) {
this.lang = language || '';
}
}], [{
key: "mem",
value: function mem(lit) {
if (lit.sI) {
throw new Error("Literal ".concat(lit, " already registered"));
}
lit.sI = ++Term.termIndex;
var dtIndex = (lit.datatype || require('./xsd').string).sI;
if (!Term.litMap[dtIndex]) {
Term.litMap[dtIndex] = [];
}
if (lit.language) {
if (!Term.litMap[dtIndex][lit.value]) {
Term.litMap[dtIndex][lit.value] = [];
}
Term.termMap[lit.sI] = Term.litMap[dtIndex][lit.value][lit.language] = lit;
} else {
Term.termMap[lit.sI] = Term.litMap[dtIndex][lit.value] = lit;
}
return lit;
}
/** @private */
}, {
key: "findLiteralByValue",
value: function findLiteralByValue(strValue) {
var lang = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
var datatype = arguments.length > 2 ? arguments[2] : undefined;
var fromMap; // Language strings need an additional index layer
if (lang) {
var langStringIndex = require('./xsd').langString.sI;
if (!Term.litMap[langStringIndex]) {
Term.litMap[langStringIndex] = [];
}
if (!Term.litMap[langStringIndex][strValue]) {
Term.litMap[langStringIndex][strValue] = [];
}
fromMap = Term.litMap[langStringIndex][strValue][lang];
} else {
var dtIndex = (datatype || require('./xsd').string).sI;
fromMap = Term.litMap[dtIndex] && Term.litMap[dtIndex][strValue];
}
return fromMap;
}
/**
* Retrieve or create a Literal by its datatype, value, and language
* @param value {Object} The value of the literal
* @param lang? {string} The language of the literal (will force datatype xsd:langString)
* @param datatype? {NamedNode} The IRI of the datatype
* @return {Literal} The resolved or created Literal
*/
}, {
key: "find",
value: function find(value) {
var lang = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
var datatype = arguments.length > 2 ? arguments[2] : undefined;
var strValue = value.toString();
var existing = Literal.findLiteralByValue(strValue, lang, datatype);
if (existing) {
return existing;
}
return new Literal(strValue, lang, datatype);
}
/**
* @method fromBoolean
* @static
* @param value {Boolean}
* @return {Literal}
*/
}, {
key: "fromBoolean",
value: function fromBoolean(value) {
var strValue = value ? '1' : '0';
return Literal.find(strValue, null, XSD.boolean);
}
/**
* @method fromDate
* @static
* @param value {Date}
* @return {Literal}
*/
}, {
key: "fromDate",
value: function fromDate(value) {
if (!(value instanceof Date)) {
throw new TypeError('Invalid argument to Literal.fromDate()');
}
var d2 = function d2(x) {
return ('' + (100 + x)).slice(1, 3);
};
var date = '' + value.getUTCFullYear() + '-' + d2(value.getUTCMonth() + 1) + '-' + d2(value.getUTCDate()) + 'T' + d2(value.getUTCHours()) + ':' + d2(value.getUTCMinutes()) + ':' + d2(value.getUTCSeconds()) + 'Z';
return Literal.find(date, null, XSD.dateTime);
}
/**
* @method fromNumber
* @static
* @param value {Number}
* @return {Literal}
*/
}, {
key: "fromNumber",
value: function fromNumber(value) {
if (typeof value !== 'number') {
throw new TypeError('Invalid argument to Literal.fromNumber()');
}
var datatype;
var strValue = value.toString();
if (strValue.indexOf('e') < 0 && Math.abs(value) <= Number.MAX_SAFE_INTEGER) {
datatype = Number.isInteger(value) ? XSD.integer : XSD.decimal;
} else {
datatype = XSD.double;
}
return Literal.find(strValue, null, datatype);
}
/**
* @method fromValue
* @param value
* @return {Literal}
*/
}, {
key: "fromValue",
value: function fromValue(value) {
if (typeof value === 'undefined' || value === null) {
return value;
}
if (_typeof(value) === 'object' && value.termType) {
// this is a Node instance
return value;
}
switch (_typeof(value)) {
case 'object':
if (value instanceof Date) {
return Literal.fromDate(value);
}
case 'boolean':
return Literal.fromBoolean(value);
case 'number':
return Literal.fromNumber(value);
case 'string':
return Literal.find(value, null, XSD.string);
}
throw new Error("Can't make literal from " + value + ' of type ' + _typeof(value));
}
}]);
return Literal;
}(Term);
Literal.termType = 'Literal';
Literal.prototype.classOrder = ClassOrder['Literal'];
Literal.prototype.datatype = XSD.string;
Literal.prototype.lang = '';
Literal.prototype.isVar = 0;
module.exports = Literal;