@comunica/utils-expression-evaluator 3.2.4-alpha.47.0

package/lib/index.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangStringLiteral = exports.TimeLiteral = exports.DurationLiteral = exports.DateLiteral = exports.DayTimeDurationLiteral = exports.DateTimeLiteral = exports.yearMonthDurationsToMonths = exports.toUTCDate = exports.toDateTimeRepresentation = exports.negateDuration = exports.extractRawTimeZone = exports.defaultedYearMonthDurationRepresentation = exports.defaultedDurationRepresentation = exports.defaultedDayTimeDurationRepresentation = exports.defaultedDateTimeRepresentation = exports.dayTimeDurationsToSeconds = exports.isSubTypeOf = exports.SparqlOperator = exports.TypeAlias = exports.TypeURL = exports.typedLiteral = exports.InvalidArity = exports.InvalidLexicalForm = exports.ExtensionFunctionError = exports.CastError = exports.UnboundVariableError = exports.NoAggregator = exports.InError = exports.CoalesceError = exports.InvalidArgumentTypes = exports.InvalidTimezoneCall = exports.IncompatibleLanguageOperation = exports.RDFEqualTypeError = exports.EmptyAggregateError = exports.isExpressionError = exports.ExpressionError = exports.Builder = exports.expressionToVar = exports.float = exports.decimal = exports.langString = exports.dateTime = exports.integer = exports.double = exports.string = exports.bool = exports.declare = exports.prepareEvaluatorActionContext = exports.OverloadTree = exports.TermTransformer = void 0;
+exports.trimToDayTimeDuration = exports.trimToYearMonthDuration = exports.parseDate = exports.parseXSDFloat = exports.parseXSDDecimal = exports.parseYearMonthDuration = exports.parseTime = exports.parseDuration = exports.parseDayTimeDuration = exports.parseDateTime = exports.elapsedDuration = exports.addDurationToDateTime = exports.isNonLexicalLiteral = exports.StringLiteral = exports.NonLexicalLiteral = exports.FloatLiteral = exports.IntegerLiteral = exports.Literal = exports.Existence = exports.Aggregate = exports.DoubleLiteral = exports.DefaultGraph = exports.DecimalLiteral = exports.BlankNode = exports.BooleanLiteral = exports.NumericLiteral = exports.Variable = exports.NamedNode = exports.Operator = exports.Quad = exports.YearMonthDurationLiteral = exports.Term = void 0;
+var TermTransformer_1 = require("./transformers/TermTransformer");
+Object.defineProperty(exports, "TermTransformer", { enumerable: true, get: function () { return TermTransformer_1.TermTransformer; } });
+var OverloadTree_1 = require("./functions/OverloadTree");
+Object.defineProperty(exports, "OverloadTree", { enumerable: true, get: function () { return OverloadTree_1.OverloadTree; } });
+var Context_1 = require("./util/Context");
+Object.defineProperty(exports, "prepareEvaluatorActionContext", { enumerable: true, get: function () { return Context_1.prepareEvaluatorActionContext; } });
+var Helpers_1 = require("./functions/Helpers");
+Object.defineProperty(exports, "declare", { enumerable: true, get: function () { return Helpers_1.declare; } });
+Object.defineProperty(exports, "bool", { enumerable: true, get: function () { return Helpers_1.bool; } });
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return Helpers_1.string; } });
+Object.defineProperty(exports, "double", { enumerable: true, get: function () { return Helpers_1.double; } });
+Object.defineProperty(exports, "integer", { enumerable: true, get: function () { return Helpers_1.integer; } });
+Object.defineProperty(exports, "dateTime", { enumerable: true, get: function () { return Helpers_1.dateTime; } });
+Object.defineProperty(exports, "langString", { enumerable: true, get: function () { return Helpers_1.langString; } });
+Object.defineProperty(exports, "decimal", { enumerable: true, get: function () { return Helpers_1.decimal; } });
+Object.defineProperty(exports, "float", { enumerable: true, get: function () { return Helpers_1.float; } });
+Object.defineProperty(exports, "expressionToVar", { enumerable: true, get: function () { return Helpers_1.expressionToVar; } });
+Object.defineProperty(exports, "Builder", { enumerable: true, get: function () { return Helpers_1.Builder; } });
+var Errors_1 = require("./util/Errors");
+Object.defineProperty(exports, "ExpressionError", { enumerable: true, get: function () { return Errors_1.ExpressionError; } });
+Object.defineProperty(exports, "isExpressionError", { enumerable: true, get: function () { return Errors_1.isExpressionError; } });
+Object.defineProperty(exports, "EmptyAggregateError", { enumerable: true, get: function () { return Errors_1.EmptyAggregateError; } });
+Object.defineProperty(exports, "RDFEqualTypeError", { enumerable: true, get: function () { return Errors_1.RDFEqualTypeError; } });
+Object.defineProperty(exports, "IncompatibleLanguageOperation", { enumerable: true, get: function () { return Errors_1.IncompatibleLanguageOperation; } });
+Object.defineProperty(exports, "InvalidTimezoneCall", { enumerable: true, get: function () { return Errors_1.InvalidTimezoneCall; } });
+Object.defineProperty(exports, "InvalidArgumentTypes", { enumerable: true, get: function () { return Errors_1.InvalidArgumentTypes; } });
+Object.defineProperty(exports, "CoalesceError", { enumerable: true, get: function () { return Errors_1.CoalesceError; } });
+Object.defineProperty(exports, "InError", { enumerable: true, get: function () { return Errors_1.InError; } });
+Object.defineProperty(exports, "NoAggregator", { enumerable: true, get: function () { return Errors_1.NoAggregator; } });
+Object.defineProperty(exports, "UnboundVariableError", { enumerable: true, get: function () { return Errors_1.UnboundVariableError; } });
+Object.defineProperty(exports, "CastError", { enumerable: true, get: function () { return Errors_1.CastError; } });
+Object.defineProperty(exports, "ExtensionFunctionError", { enumerable: true, get: function () { return Errors_1.ExtensionFunctionError; } });
+Object.defineProperty(exports, "InvalidLexicalForm", { enumerable: true, get: function () { return Errors_1.InvalidLexicalForm; } });
+Object.defineProperty(exports, "InvalidArity", { enumerable: true, get: function () { return Errors_1.InvalidArity; } });
+var Consts_1 = require("./util/Consts");
+Object.defineProperty(exports, "typedLiteral", { enumerable: true, get: function () { return Consts_1.typedLiteral; } });
+Object.defineProperty(exports, "TypeURL", { enumerable: true, get: function () { return Consts_1.TypeURL; } });
+Object.defineProperty(exports, "TypeAlias", { enumerable: true, get: function () { return Consts_1.TypeAlias; } });
+Object.defineProperty(exports, "SparqlOperator", { enumerable: true, get: function () { return Consts_1.SparqlOperator; } });
+var TypeHandling_1 = require("./util/TypeHandling");
+Object.defineProperty(exports, "isSubTypeOf", { enumerable: true, get: function () { return TypeHandling_1.isSubTypeOf; } });
+var DateTimeHelpers_1 = require("./util/DateTimeHelpers");
+Object.defineProperty(exports, "dayTimeDurationsToSeconds", { enumerable: true, get: function () { return DateTimeHelpers_1.dayTimeDurationsToSeconds; } });
+Object.defineProperty(exports, "defaultedDateTimeRepresentation", { enumerable: true, get: function () { return DateTimeHelpers_1.defaultedDateTimeRepresentation; } });
+Object.defineProperty(exports, "defaultedDayTimeDurationRepresentation", { enumerable: true, get: function () { return DateTimeHelpers_1.defaultedDayTimeDurationRepresentation; } });
+Object.defineProperty(exports, "defaultedDurationRepresentation", { enumerable: true, get: function () { return DateTimeHelpers_1.defaultedDurationRepresentation; } });
+Object.defineProperty(exports, "defaultedYearMonthDurationRepresentation", { enumerable: true, get: function () { return DateTimeHelpers_1.defaultedYearMonthDurationRepresentation; } });
+Object.defineProperty(exports, "extractRawTimeZone", { enumerable: true, get: function () { return DateTimeHelpers_1.extractRawTimeZone; } });
+Object.defineProperty(exports, "negateDuration", { enumerable: true, get: function () { return DateTimeHelpers_1.negateDuration; } });
+Object.defineProperty(exports, "toDateTimeRepresentation", { enumerable: true, get: function () { return DateTimeHelpers_1.toDateTimeRepresentation; } });
+Object.defineProperty(exports, "toUTCDate", { enumerable: true, get: function () { return DateTimeHelpers_1.toUTCDate; } });
+Object.defineProperty(exports, "yearMonthDurationsToMonths", { enumerable: true, get: function () { return DateTimeHelpers_1.yearMonthDurationsToMonths; } });
+var expressions_1 = require("./expressions");
+Object.defineProperty(exports, "DateTimeLiteral", { enumerable: true, get: function () { return expressions_1.DateTimeLiteral; } });
+Object.defineProperty(exports, "DayTimeDurationLiteral", { enumerable: true, get: function () { return expressions_1.DayTimeDurationLiteral; } });
+Object.defineProperty(exports, "DateLiteral", { enumerable: true, get: function () { return expressions_1.DateLiteral; } });
+Object.defineProperty(exports, "DurationLiteral", { enumerable: true, get: function () { return expressions_1.DurationLiteral; } });
+Object.defineProperty(exports, "TimeLiteral", { enumerable: true, get: function () { return expressions_1.TimeLiteral; } });
+Object.defineProperty(exports, "LangStringLiteral", { enumerable: true, get: function () { return expressions_1.LangStringLiteral; } });
+Object.defineProperty(exports, "Term", { enumerable: true, get: function () { return expressions_1.Term; } });
+Object.defineProperty(exports, "YearMonthDurationLiteral", { enumerable: true, get: function () { return expressions_1.YearMonthDurationLiteral; } });
+Object.defineProperty(exports, "Quad", { enumerable: true, get: function () { return expressions_1.Quad; } });
+Object.defineProperty(exports, "Operator", { enumerable: true, get: function () { return expressions_1.Operator; } });
+Object.defineProperty(exports, "NamedNode", { enumerable: true, get: function () { return expressions_1.NamedNode; } });
+Object.defineProperty(exports, "Variable", { enumerable: true, get: function () { return expressions_1.Variable; } });
+Object.defineProperty(exports, "NumericLiteral", { enumerable: true, get: function () { return expressions_1.NumericLiteral; } });
+Object.defineProperty(exports, "BooleanLiteral", { enumerable: true, get: function () { return expressions_1.BooleanLiteral; } });
+Object.defineProperty(exports, "BlankNode", { enumerable: true, get: function () { return expressions_1.BlankNode; } });
+Object.defineProperty(exports, "DecimalLiteral", { enumerable: true, get: function () { return expressions_1.DecimalLiteral; } });
+Object.defineProperty(exports, "DefaultGraph", { enumerable: true, get: function () { return expressions_1.DefaultGraph; } });
+Object.defineProperty(exports, "DoubleLiteral", { enumerable: true, get: function () { return expressions_1.DoubleLiteral; } });
+Object.defineProperty(exports, "Aggregate", { enumerable: true, get: function () { return expressions_1.Aggregate; } });
+Object.defineProperty(exports, "Existence", { enumerable: true, get: function () { return expressions_1.Existence; } });
+Object.defineProperty(exports, "Literal", { enumerable: true, get: function () { return expressions_1.Literal; } });
+Object.defineProperty(exports, "IntegerLiteral", { enumerable: true, get: function () { return expressions_1.IntegerLiteral; } });
+Object.defineProperty(exports, "FloatLiteral", { enumerable: true, get: function () { return expressions_1.FloatLiteral; } });
+Object.defineProperty(exports, "NonLexicalLiteral", { enumerable: true, get: function () { return expressions_1.NonLexicalLiteral; } });
+Object.defineProperty(exports, "StringLiteral", { enumerable: true, get: function () { return expressions_1.StringLiteral; } });
+Object.defineProperty(exports, "isNonLexicalLiteral", { enumerable: true, get: function () { return expressions_1.isNonLexicalLiteral; } });
+var SpecAlgos_1 = require("./util/SpecAlgos");
+Object.defineProperty(exports, "addDurationToDateTime", { enumerable: true, get: function () { return SpecAlgos_1.addDurationToDateTime; } });
+Object.defineProperty(exports, "elapsedDuration", { enumerable: true, get: function () { return SpecAlgos_1.elapsedDuration; } });
+var Parsing_1 = require("./util/Parsing");
+Object.defineProperty(exports, "parseDateTime", { enumerable: true, get: function () { return Parsing_1.parseDateTime; } });
+Object.defineProperty(exports, "parseDayTimeDuration", { enumerable: true, get: function () { return Parsing_1.parseDayTimeDuration; } });
+Object.defineProperty(exports, "parseDuration", { enumerable: true, get: function () { return Parsing_1.parseDuration; } });
+Object.defineProperty(exports, "parseTime", { enumerable: true, get: function () { return Parsing_1.parseTime; } });
+Object.defineProperty(exports, "parseYearMonthDuration", { enumerable: true, get: function () { return Parsing_1.parseYearMonthDuration; } });
+Object.defineProperty(exports, "parseXSDDecimal", { enumerable: true, get: function () { return Parsing_1.parseXSDDecimal; } });
+Object.defineProperty(exports, "parseXSDFloat", { enumerable: true, get: function () { return Parsing_1.parseXSDFloat; } });
+Object.defineProperty(exports, "parseDate", { enumerable: true, get: function () { return Parsing_1.parseDate; } });
+var DateTimeHelpers_2 = require("./util/DateTimeHelpers");
+Object.defineProperty(exports, "trimToYearMonthDuration", { enumerable: true, get: function () { return DateTimeHelpers_2.trimToYearMonthDuration; } });
+Object.defineProperty(exports, "trimToDayTimeDuration", { enumerable: true, get: function () { return DateTimeHelpers_2.trimToDayTimeDuration; } });
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;;AAAA,kEAAiE;AAAxD,kHAAA,eAAe,OAAA;AACxB,yDAEkC;AADhC,4GAAA,YAAY,OAAA;AAEd,0CAA+D;AAAtD,wHAAA,6BAA6B,OAAA;AACtC,+CAY6B;AAX3B,kGAAA,OAAO,OAAA;AACP,+FAAA,IAAI,OAAA;AACJ,iGAAA,MAAM,OAAA;AACN,iGAAA,MAAM,OAAA;AACN,kGAAA,OAAO,OAAA;AACP,mGAAA,QAAQ,OAAA;AACR,qGAAA,UAAU,OAAA;AACV,kGAAA,OAAO,OAAA;AACP,gGAAA,KAAK,OAAA;AACL,0GAAA,eAAe,OAAA;AACf,kGAAA,OAAO,OAAA;AAET,wCAgBuB;AAfrB,yGAAA,eAAe,OAAA;AACf,2GAAA,iBAAiB,OAAA;AACjB,6GAAA,mBAAmB,OAAA;AACnB,2GAAA,iBAAiB,OAAA;AACjB,uHAAA,6BAA6B,OAAA;AAC7B,6GAAA,mBAAmB,OAAA;AACnB,8GAAA,oBAAoB,OAAA;AACpB,uGAAA,aAAa,OAAA;AACb,iGAAA,OAAO,OAAA;AACP,sGAAA,YAAY,OAAA;AACZ,8GAAA,oBAAoB,OAAA;AACpB,mGAAA,SAAS,OAAA;AACT,gHAAA,sBAAsB,OAAA;AACtB,4GAAA,kBAAkB,OAAA;AAClB,sGAAA,YAAY,OAAA;AAEd,wCASuB;AARrB,sGAAA,YAAY,OAAA;AACZ,iGAAA,OAAO,OAAA;AACP,mGAAA,SAAS,OAAA;AACT,wGAAA,cAAc,OAAA;AAMhB,oDAAkD;AAAzC,2GAAA,WAAW,OAAA;AACpB,0DAWgC;AAV9B,4HAAA,yBAAyB,OAAA;AACzB,kIAAA,+BAA+B,OAAA;AAC/B,yIAAA,sCAAsC,OAAA;AACtC,kIAAA,+BAA+B,OAAA;AAC/B,2IAAA,wCAAwC,OAAA;AACxC,qHAAA,kBAAkB,OAAA;AAClB,iHAAA,cAAc,OAAA;AACd,2HAAA,wBAAwB,OAAA;AACxB,4GAAA,SAAS,OAAA;AACT,6HAAA,0BAA0B,OAAA;AAE5B,6CA2BuB;AA1BrB,8GAAA,eAAe,OAAA;AACf,qHAAA,sBAAsB,OAAA;AACtB,0GAAA,WAAW,OAAA;AACX,8GAAA,eAAe,OAAA;AACf,0GAAA,WAAW,OAAA;AACX,gHAAA,iBAAiB,OAAA;AACjB,mGAAA,IAAI,OAAA;AACJ,uHAAA,wBAAwB,OAAA;AACxB,mGAAA,IAAI,OAAA;AACJ,uGAAA,QAAQ,OAAA;AACR,wGAAA,SAAS,OAAA;AACT,uGAAA,QAAQ,OAAA;AACR,6GAAA,cAAc,OAAA;AACd,6GAAA,cAAc,OAAA;AACd,wGAAA,SAAS,OAAA;AACT,6GAAA,cAAc,OAAA;AACd,2GAAA,YAAY,OAAA;AACZ,4GAAA,aAAa,OAAA;AACb,wGAAA,SAAS,OAAA;AACT,wGAAA,SAAS,OAAA;AACT,sGAAA,OAAO,OAAA;AACP,6GAAA,cAAc,OAAA;AACd,2GAAA,YAAY,OAAA;AACZ,gHAAA,iBAAiB,OAAA;AACjB,4GAAA,aAAa,OAAA;AACb,kHAAA,mBAAmB,OAAA;AAErB,8CAA0E;AAAjE,kHAAA,qBAAqB,OAAA;AAAE,4GAAA,eAAe,OAAA;AAC/C,0CASwB;AARtB,wGAAA,aAAa,OAAA;AACb,+GAAA,oBAAoB,OAAA;AACpB,wGAAA,aAAa,OAAA;AACb,oGAAA,SAAS,OAAA;AACT,iHAAA,sBAAsB,OAAA;AACtB,0GAAA,eAAe,OAAA;AACf,wGAAA,aAAa,OAAA;AACb,oGAAA,SAAS,OAAA;AAEX,0DAGgC;AAF9B,0HAAA,uBAAuB,OAAA;AACvB,wHAAA,qBAAqB,OAAA","sourcesContent":["export { TermTransformer } from './transformers/TermTransformer';\nexport {\n  OverloadTree,\n} from './functions/OverloadTree';\nexport { prepareEvaluatorActionContext } from './util/Context';\nexport {\n  declare,\n  bool,\n  string,\n  double,\n  integer,\n  dateTime,\n  langString,\n  decimal,\n  float,\n  expressionToVar,\n  Builder,\n} from './functions/Helpers';\nexport {\n  ExpressionError,\n  isExpressionError,\n  EmptyAggregateError,\n  RDFEqualTypeError,\n  IncompatibleLanguageOperation,\n  InvalidTimezoneCall,\n  InvalidArgumentTypes,\n  CoalesceError,\n  InError,\n  NoAggregator,\n  UnboundVariableError,\n  CastError,\n  ExtensionFunctionError,\n  InvalidLexicalForm,\n  InvalidArity,\n} from './util/Errors';\nexport {\n  typedLiteral,\n  TypeURL,\n  TypeAlias,\n  SparqlOperator,\n  NamedOperator,\n  GeneralOperator,\n  KnownOperator,\n  KnownLiteralTypes,\n} from './util/Consts';\nexport { isSubTypeOf } from './util/TypeHandling';\nexport {\n  dayTimeDurationsToSeconds,\n  defaultedDateTimeRepresentation,\n  defaultedDayTimeDurationRepresentation,\n  defaultedDurationRepresentation,\n  defaultedYearMonthDurationRepresentation,\n  extractRawTimeZone,\n  negateDuration,\n  toDateTimeRepresentation,\n  toUTCDate,\n  yearMonthDurationsToMonths,\n} from './util/DateTimeHelpers';\nexport {\n  DateTimeLiteral,\n  DayTimeDurationLiteral,\n  DateLiteral,\n  DurationLiteral,\n  TimeLiteral,\n  LangStringLiteral,\n  Term,\n  YearMonthDurationLiteral,\n  Quad,\n  Operator,\n  NamedNode,\n  Variable,\n  NumericLiteral,\n  BooleanLiteral,\n  BlankNode,\n  DecimalLiteral,\n  DefaultGraph,\n  DoubleLiteral,\n  Aggregate,\n  Existence,\n  Literal,\n  IntegerLiteral,\n  FloatLiteral,\n  NonLexicalLiteral,\n  StringLiteral,\n  isNonLexicalLiteral,\n} from './expressions';\nexport { addDurationToDateTime, elapsedDuration } from './util/SpecAlgos';\nexport {\n  parseDateTime,\n  parseDayTimeDuration,\n  parseDuration,\n  parseTime,\n  parseYearMonthDuration,\n  parseXSDDecimal,\n  parseXSDFloat,\n  parseDate,\n} from './util/Parsing';\nexport {\n  trimToYearMonthDuration,\n  trimToDayTimeDuration,\n} from './util/DateTimeHelpers';\n"]}

package/lib/transformers/TermTransformer.d.ts

@@ -0,0 +1,24 @@
+import type { Expression, ISuperTypeProvider } from '@comunica/types';
+import type * as RDF from '@rdfjs/types';
+import type { Algebra as Alg } from 'sparqlalgebrajs';
+import * as E from '../expressions';
+export interface ITermTransformer {
+    transformRDFTermUnsafe: (term: RDF.Term) => E.Term;
+    transformLiteral: (lit: RDF.Literal) => E.Literal<any>;
+}
+export declare class TermTransformer implements ITermTransformer {
+    protected readonly superTypeProvider: ISuperTypeProvider;
+    constructor(superTypeProvider: ISuperTypeProvider);
+    /**
+     * Transforms an RDF term to the internal representation of a term,
+     * assuming it is not a variable, which would be an expression (internally).
+     *
+     * @param term RDF term to transform into internal representation of a term
+     */
+    transformRDFTermUnsafe(term: RDF.Term): E.Term;
+    protected transformTerm(term: Alg.TermExpression): Expression;
+    /**
+     * @param lit the rdf literal we want to transform to an internal Literal expression.
+     */
+    transformLiteral(lit: RDF.Literal): E.Literal<any>;
+}

package/lib/transformers/TermTransformer.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TermTransformer = void 0;
+const RDFString = require("rdf-string");
+const sparqlalgebrajs_1 = require("sparqlalgebrajs");
+const E = require("../expressions");
+const Consts_1 = require("../util/Consts");
+const Err = require("../util/Errors");
+const Errors_1 = require("../util/Errors");
+const Parsing_1 = require("../util/Parsing");
+const P = require("../util/Parsing");
+const TypeHandling_1 = require("../util/TypeHandling");
+class TermTransformer {
+    constructor(superTypeProvider) {
+        this.superTypeProvider = superTypeProvider;
+    }
+    /**
+     * Transforms an RDF term to the internal representation of a term,
+     * assuming it is not a variable, which would be an expression (internally).
+     *
+     * @param term RDF term to transform into internal representation of a term
+     */
+    transformRDFTermUnsafe(term) {
+        return this.transformTerm({
+            term,
+            type: sparqlalgebrajs_1.Algebra.types.EXPRESSION,
+            expressionType: sparqlalgebrajs_1.Algebra.expressionTypes.TERM,
+        });
+    }
+    transformTerm(term) {
+        if (!term.term) {
+            throw new Err.InvalidExpression(term);
+        }
+        switch (term.term.termType) {
+            case 'Variable':
+                return new E.Variable(RDFString.termToString(term.term));
+            case 'Literal':
+                return this.transformLiteral(term.term);
+            case 'NamedNode':
+                return new E.NamedNode(term.term.value);
+            case 'BlankNode':
+                return new E.BlankNode(term.term.value);
+            case 'Quad':
+                return new E.Quad(this.transformRDFTermUnsafe(term.term.subject), this.transformRDFTermUnsafe(term.term.predicate), this.transformRDFTermUnsafe(term.term.object), this.transformRDFTermUnsafe(term.term.graph));
+            case 'DefaultGraph':
+                return new E.DefaultGraph();
+        }
+    }
+    /**
+     * @param lit the rdf literal we want to transform to an internal Literal expression.
+     */
+    transformLiteral(lit) {
+        // Both here and within the switch we transform to LangStringLiteral or StringLiteral.
+        // We do this when we detect a simple literal being used.
+        // Original issue regarding this behaviour: https://github.com/w3c/sparql-12/issues/112
+        if (!lit.datatype || [null, undefined, ''].includes(lit.datatype.value)) {
+            return lit.language ?
+                new E.LangStringLiteral(lit.value, lit.language) :
+                new E.StringLiteral(lit.value);
+        }
+        const dataType = lit.datatype.value;
+        const superTypeDict = (0, TypeHandling_1.getSuperTypeDict)(dataType, this.superTypeProvider);
+        // The order of checking matters! Check most specific types first!
+        try {
+            if (Consts_1.TypeURL.XSD_STRING in superTypeDict) {
+                return new E.StringLiteral(lit.value, dataType);
+            }
+            if (Consts_1.TypeURL.RDF_LANG_STRING in superTypeDict) {
+                return new E.LangStringLiteral(lit.value, lit.language);
+            }
+            if (Consts_1.TypeURL.XSD_YEAR_MONTH_DURATION in superTypeDict) {
+                return new E.YearMonthDurationLiteral((0, Parsing_1.parseYearMonthDuration)(lit.value), lit.value, dataType);
+            }
+            if (Consts_1.TypeURL.XSD_DAY_TIME_DURATION in superTypeDict) {
+                return new E.DayTimeDurationLiteral((0, Parsing_1.parseDayTimeDuration)(lit.value), lit.value, dataType);
+            }
+            if (Consts_1.TypeURL.XSD_DURATION in superTypeDict) {
+                return new E.DurationLiteral((0, Parsing_1.parseDuration)(lit.value), lit.value, dataType);
+            }
+            if (Consts_1.TypeURL.XSD_DATE_TIME in superTypeDict) {
+                const dateVal = new Date(lit.value);
+                if (Number.isNaN(dateVal.getTime())) {
+                    return new E.NonLexicalLiteral(undefined, dataType, this.superTypeProvider, lit.value);
+                }
+                return new E.DateTimeLiteral((0, Parsing_1.parseDateTime)(lit.value), lit.value, dataType);
+            }
+            if (Consts_1.TypeURL.XSD_DATE in superTypeDict) {
+                return new E.DateLiteral((0, Parsing_1.parseDate)(lit.value), lit.value, dataType);
+            }
+            if (Consts_1.TypeURL.XSD_TIME in superTypeDict) {
+                return new E.TimeLiteral((0, Parsing_1.parseTime)(lit.value), lit.value, dataType);
+            }
+            if (Consts_1.TypeURL.XSD_BOOLEAN in superTypeDict) {
+                if (lit.value !== 'true' && lit.value !== 'false' && lit.value !== '1' && lit.value !== '0') {
+                    return new E.NonLexicalLiteral(undefined, dataType, this.superTypeProvider, lit.value);
+                }
+                return new E.BooleanLiteral(lit.value === 'true' || lit.value === '1', lit.value);
+            }
+            if (Consts_1.TypeURL.XSD_DECIMAL in superTypeDict) {
+                const intVal = P.parseXSDDecimal(lit.value);
+                if (intVal === undefined) {
+                    return new E.NonLexicalLiteral(undefined, dataType, this.superTypeProvider, lit.value);
+                }
+                if (Consts_1.TypeURL.XSD_INTEGER in superTypeDict) {
+                    return new E.IntegerLiteral(intVal, dataType, lit.value);
+                }
+                // If type is not an integer it's just a decimal.
+                return new E.DecimalLiteral(intVal, dataType, lit.value);
+            }
+            const isFloat = Consts_1.TypeURL.XSD_FLOAT in superTypeDict;
+            const isDouble = Consts_1.TypeURL.XSD_DOUBLE in superTypeDict;
+            if (isFloat || isDouble) {
+                const doubleVal = P.parseXSDFloat(lit.value);
+                if (doubleVal === undefined) {
+                    return new E.NonLexicalLiteral(undefined, dataType, this.superTypeProvider, lit.value);
+                }
+                if (isFloat) {
+                    return new E.FloatLiteral(doubleVal, dataType, lit.value);
+                }
+                return new E.DoubleLiteral(doubleVal, dataType, lit.value);
+            }
+            return new E.Literal(lit.value, dataType, lit.value);
+        }
+        catch (error) {
+            if ((0, Errors_1.isExpressionError)(error)) {
+                return new E.NonLexicalLiteral(undefined, dataType, this.superTypeProvider, lit.value);
+            }
+            throw error;
+        }
+    }
+}
+exports.TermTransformer = TermTransformer;
+//# sourceMappingURL=TermTransformer.js.map

package/lib/transformers/TermTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TermTransformer.js","sourceRoot":"","sources":["TermTransformer.ts"],"names":[],"mappings":";;;AAEA,wCAAwC;AAExC,qDAA0C;AAC1C,oCAAoC;AACpC,2CAAyC;AACzC,sCAAsC;AACtC,2CAAmD;AACnD,6CAOyB;AACzB,qCAAqC;AACrC,uDAAwD;AAOxD,MAAa,eAAe;IAC1B,YAAsC,iBAAqC;QAArC,sBAAiB,GAAjB,iBAAiB,CAAoB;IAAG,CAAC;IAE/E;;;;;OAKG;IACI,sBAAsB,CAAC,IAAc;QAC1C,OAAgB,IAAI,CAAC,aAAa,CAAC;YACjC,IAAI;YACJ,IAAI,EAAE,yBAAO,CAAC,KAAK,CAAC,UAAU;YAC9B,cAAc,EAAE,yBAAO,CAAC,eAAe,CAAC,IAAI;SAC7C,CAAC,CAAC;IACL,CAAC;IAES,aAAa,CAAC,IAAwB;QAC9C,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACf,MAAM,IAAI,GAAG,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACxC,CAAC;QAED,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC3B,KAAK,UAAU;gBACb,OAAO,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YAC3D,KAAK,SAAS;gBACZ,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC1C,KAAK,WAAW;gBACd,OAAO,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC1C,KAAK,WAAW;gBACd,OAAO,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC1C,KAAK,MAAM;gBACT,OAAO,IAAI,CAAC,CAAC,IAAI,CACf,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAC9C,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,EAChD,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAC7C,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAC7C,CAAC;YACJ,KAAK,cAAc;gBACjB,OAAO,IAAI,CAAC,CAAC,YAAY,EAAE,CAAC;QAChC,CAAC;IACH,CAAC;IAED;;OAEG;IACI,gBAAgB,CAAC,GAAgB;QACtC,sFAAsF;QACtF,yDAAyD;QACzD,uFAAuF;QACvF,IAAI,CAAC,GAAG,CAAC,QAAQ,IAAI,CAAE,IAAI,EAAE,SAAS,EAAE,EAAE,CAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1E,OAAO,GAAG,CAAC,QAAQ,CAAC,CAAC;gBACnB,IAAI,CAAC,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAClD,IAAI,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;QAED,MAAM,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC;QACpC,MAAM,aAAa,GAAyB,IAAA,+BAAgB,EAAC,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAE/F,kEAAkE;QAClE,IAAI,CAAC;YACH,IAAI,gBAAO,CAAC,UAAU,IAAI,aAAa,EAAE,CAAC;gBACxC,OAAO,IAAI,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YAClD,CAAC;YACD,IAAI,gBAAO,CAAC,eAAe,IAAI,aAAa,EAAE,CAAC;gBAC7C,OAAO,IAAI,CAAC,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;YAC1D,CAAC;YACD,IAAI,gBAAO,CAAC,uBAAuB,IAAI,aAAa,EAAE,CAAC;gBACrD,OAAO,IAAI,CAAC,CAAC,wBAAwB,CAAC,IAAA,gCAAsB,EAAC,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YAChG,CAAC;YACD,IAAI,gBAAO,CAAC,qBAAqB,IAAI,aAAa,EAAE,CAAC;gBACnD,OAAO,IAAI,CAAC,CAAC,sBAAsB,CAAC,IAAA,8BAAoB,EAAC,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YAC5F,CAAC;YACD,IAAI,gBAAO,CAAC,YAAY,IAAI,aAAa,EAAE,CAAC;gBAC1C,OAAO,IAAI,CAAC,CAAC,eAAe,CAAC,IAAA,uBAAa,EAAC,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YAC9E,CAAC;YACD,IAAI,gBAAO,CAAC,aAAa,IAAI,aAAa,EAAE,CAAC;gBAC3C,MAAM,OAAO,GAAS,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBAC1C,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC;oBACpC,OAAO,IAAI,CAAC,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;gBACzF,CAAC;gBACD,OAAO,IAAI,CAAC,CAAC,eAAe,CAAC,IAAA,uBAAa,EAAC,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YAC9E,CAAC;YACD,IAAI,gBAAO,CAAC,QAAQ,IAAI,aAAa,EAAE,CAAC;gBACtC,OAAO,IAAI,CAAC,CAAC,WAAW,CAAC,IAAA,mBAAS,EAAC,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YACtE,CAAC;YACD,IAAI,gBAAO,CAAC,QAAQ,IAAI,aAAa,EAAE,CAAC;gBACtC,OAAO,IAAI,CAAC,CAAC,WAAW,CAAC,IAAA,mBAAS,EAAC,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YACtE,CAAC;YACD,IAAI,gBAAO,CAAC,WAAW,IAAI,aAAa,EAAE,CAAC;gBACzC,IAAI,GAAG,CAAC,KAAK,KAAK,MAAM,IAAI,GAAG,CAAC,KAAK,KAAK,OAAO,IAAI,GAAG,CAAC,KAAK,KAAK,GAAG,IAAI,GAAG,CAAC,KAAK,KAAK,GAAG,EAAE,CAAC;oBAC5F,OAAO,IAAI,CAAC,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;gBACzF,CAAC;gBACD,OAAO,IAAI,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,KAAK,MAAM,IAAI,GAAG,CAAC,KAAK,KAAK,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;YACpF,CAAC;YACD,IAAI,gBAAO,CAAC,WAAW,IAAI,aAAa,EAAE,CAAC;gBACzC,MAAM,MAAM,GAAuB,CAAC,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBAChE,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;oBACzB,OAAO,IAAI,CAAC,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;gBACzF,CAAC;gBACD,IAAI,gBAAO,CAAC,WAAW,IAAI,aAAa,EAAE,CAAC;oBACzC,OAAO,IAAI,CAAC,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;gBAC3D,CAAC;gBACD,iDAAiD;gBACjD,OAAO,IAAI,CAAC,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;YAC3D,CAAC;YACD,MAAM,OAAO,GAAG,gBAAO,CAAC,SAAS,IAAI,aAAa,CAAC;YACnD,MAAM,QAAQ,GAAG,gBAAO,CAAC,UAAU,IAAI,aAAa,CAAC;YACrD,IAAI,OAAO,IAAI,QAAQ,EAAE,CAAC;gBACxB,MAAM,SAAS,GAAuB,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBACjE,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;oBAC5B,OAAO,IAAI,CAAC,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;gBACzF,CAAC;gBACD,IAAI,OAAO,EAAE,CAAC;oBACZ,OAAO,IAAI,CAAC,CAAC,YAAY,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;gBAC5D,CAAC;gBACD,OAAO,IAAI,CAAC,CAAC,aAAa,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;YAC7D,CAAC;YAED,OAAO,IAAI,CAAC,CAAC,OAAO,CAAS,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;QAC/D,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,IAAI,IAAA,0BAAiB,EAAS,KAAK,CAAC,EAAE,CAAC;gBACrC,OAAO,IAAI,CAAC,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;YACzF,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;CACF;AA/HD,0CA+HC","sourcesContent":["import type { Expression, GeneralSuperTypeDict, ISuperTypeProvider } from '@comunica/types';\nimport type * as RDF from '@rdfjs/types';\nimport * as RDFString from 'rdf-string';\nimport type { Algebra as Alg } from 'sparqlalgebrajs';\nimport { Algebra } from 'sparqlalgebrajs';\nimport * as E from '../expressions';\nimport { TypeURL } from '../util/Consts';\nimport * as Err from '../util/Errors';\nimport { isExpressionError } from '../util/Errors';\nimport {\n  parseDate,\n  parseDateTime,\n  parseDayTimeDuration,\n  parseDuration,\n  parseTime,\n  parseYearMonthDuration,\n} from '../util/Parsing';\nimport * as P from '../util/Parsing';\nimport { getSuperTypeDict } from '../util/TypeHandling';\n\nexport interface ITermTransformer {\n  transformRDFTermUnsafe: (term: RDF.Term) => E.Term;\n  transformLiteral: (lit: RDF.Literal) => E.Literal<any>;\n}\n\nexport class TermTransformer implements ITermTransformer {\n  public constructor(protected readonly superTypeProvider: ISuperTypeProvider) {}\n\n  /**\n   * Transforms an RDF term to the internal representation of a term,\n   * assuming it is not a variable, which would be an expression (internally).\n   *\n   * @param term RDF term to transform into internal representation of a term\n   */\n  public transformRDFTermUnsafe(term: RDF.Term): E.Term {\n    return <E.Term> this.transformTerm({\n      term,\n      type: Algebra.types.EXPRESSION,\n      expressionType: Algebra.expressionTypes.TERM,\n    });\n  }\n\n  protected transformTerm(term: Alg.TermExpression): Expression {\n    if (!term.term) {\n      throw new Err.InvalidExpression(term);\n    }\n\n    switch (term.term.termType) {\n      case 'Variable':\n        return new E.Variable(RDFString.termToString(term.term));\n      case 'Literal':\n        return this.transformLiteral(term.term);\n      case 'NamedNode':\n        return new E.NamedNode(term.term.value);\n      case 'BlankNode':\n        return new E.BlankNode(term.term.value);\n      case 'Quad':\n        return new E.Quad(\n          this.transformRDFTermUnsafe(term.term.subject),\n          this.transformRDFTermUnsafe(term.term.predicate),\n          this.transformRDFTermUnsafe(term.term.object),\n          this.transformRDFTermUnsafe(term.term.graph),\n        );\n      case 'DefaultGraph':\n        return new E.DefaultGraph();\n    }\n  }\n\n  /**\n   * @param lit the rdf literal we want to transform to an internal Literal expression.\n   */\n  public transformLiteral(lit: RDF.Literal): E.Literal<any> {\n    // Both here and within the switch we transform to LangStringLiteral or StringLiteral.\n    // We do this when we detect a simple literal being used.\n    // Original issue regarding this behaviour: https://github.com/w3c/sparql-12/issues/112\n    if (!lit.datatype || [ null, undefined, '' ].includes(lit.datatype.value)) {\n      return lit.language ?\n        new E.LangStringLiteral(lit.value, lit.language) :\n        new E.StringLiteral(lit.value);\n    }\n\n    const dataType = lit.datatype.value;\n    const superTypeDict: GeneralSuperTypeDict = getSuperTypeDict(dataType, this.superTypeProvider);\n\n    // The order of checking matters! Check most specific types first!\n    try {\n      if (TypeURL.XSD_STRING in superTypeDict) {\n        return new E.StringLiteral(lit.value, dataType);\n      }\n      if (TypeURL.RDF_LANG_STRING in superTypeDict) {\n        return new E.LangStringLiteral(lit.value, lit.language);\n      }\n      if (TypeURL.XSD_YEAR_MONTH_DURATION in superTypeDict) {\n        return new E.YearMonthDurationLiteral(parseYearMonthDuration(lit.value), lit.value, dataType);\n      }\n      if (TypeURL.XSD_DAY_TIME_DURATION in superTypeDict) {\n        return new E.DayTimeDurationLiteral(parseDayTimeDuration(lit.value), lit.value, dataType);\n      }\n      if (TypeURL.XSD_DURATION in superTypeDict) {\n        return new E.DurationLiteral(parseDuration(lit.value), lit.value, dataType);\n      }\n      if (TypeURL.XSD_DATE_TIME in superTypeDict) {\n        const dateVal: Date = new Date(lit.value);\n        if (Number.isNaN(dateVal.getTime())) {\n          return new E.NonLexicalLiteral(undefined, dataType, this.superTypeProvider, lit.value);\n        }\n        return new E.DateTimeLiteral(parseDateTime(lit.value), lit.value, dataType);\n      }\n      if (TypeURL.XSD_DATE in superTypeDict) {\n        return new E.DateLiteral(parseDate(lit.value), lit.value, dataType);\n      }\n      if (TypeURL.XSD_TIME in superTypeDict) {\n        return new E.TimeLiteral(parseTime(lit.value), lit.value, dataType);\n      }\n      if (TypeURL.XSD_BOOLEAN in superTypeDict) {\n        if (lit.value !== 'true' && lit.value !== 'false' && lit.value !== '1' && lit.value !== '0') {\n          return new E.NonLexicalLiteral(undefined, dataType, this.superTypeProvider, lit.value);\n        }\n        return new E.BooleanLiteral(lit.value === 'true' || lit.value === '1', lit.value);\n      }\n      if (TypeURL.XSD_DECIMAL in superTypeDict) {\n        const intVal: number | undefined = P.parseXSDDecimal(lit.value);\n        if (intVal === undefined) {\n          return new E.NonLexicalLiteral(undefined, dataType, this.superTypeProvider, lit.value);\n        }\n        if (TypeURL.XSD_INTEGER in superTypeDict) {\n          return new E.IntegerLiteral(intVal, dataType, lit.value);\n        }\n        // If type is not an integer it's just a decimal.\n        return new E.DecimalLiteral(intVal, dataType, lit.value);\n      }\n      const isFloat = TypeURL.XSD_FLOAT in superTypeDict;\n      const isDouble = TypeURL.XSD_DOUBLE in superTypeDict;\n      if (isFloat || isDouble) {\n        const doubleVal: number | undefined = P.parseXSDFloat(lit.value);\n        if (doubleVal === undefined) {\n          return new E.NonLexicalLiteral(undefined, dataType, this.superTypeProvider, lit.value);\n        }\n        if (isFloat) {\n          return new E.FloatLiteral(doubleVal, dataType, lit.value);\n        }\n        return new E.DoubleLiteral(doubleVal, dataType, lit.value);\n      }\n\n      return new E.Literal<string>(lit.value, dataType, lit.value);\n    } catch (error: unknown) {\n      if (isExpressionError(<Error> error)) {\n        return new E.NonLexicalLiteral(undefined, dataType, this.superTypeProvider, lit.value);\n      }\n      throw error;\n    }\n  }\n}\n"]}

package/lib/util/Consts.d.ts

@@ -0,0 +1,136 @@
+import type * as RDF from '@rdfjs/types';
+export type KnownLiteralTypes = TypeAlias | TypeURL;
+export declare enum TypeAlias {
+    SPARQL_NUMERIC = "SPARQL_NUMERIC",
+    /**
+     * Stringly is everything defined in https://www.w3.org/TR/sparql11-query/#func-strings
+     * In other words it is a simple literal, a plain literal with language tag, or a literal with datatype xsd:string
+     * In other words, since utils-expression-evaluator transforms a simple literal to xsd_string.
+     * It is RDF_LANG_STRING or XSD_STRING.
+     * Reasons for this are mentioned here: w3c/sparql-12#112
+     */
+    SPARQL_STRINGLY = "SPARQL_STRINGLY"
+}
+export declare function typedLiteral(value: string, type: TypeURL): RDF.Literal;
+export declare enum TypeURL {
+    XSD_ANY_URI = "http://www.w3.org/2001/XMLSchema#anyURI",
+    XSD_STRING = "http://www.w3.org/2001/XMLSchema#string",
+    RDF_LANG_STRING = "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString",
+    XSD_BOOLEAN = "http://www.w3.org/2001/XMLSchema#boolean",
+    XSD_DATE_TIME = "http://www.w3.org/2001/XMLSchema#dateTime",
+    XSD_DATE_TIME_STAMP = "http://www.w3.org/2001/XMLSchema#dateTimeStamp",
+    XSD_DATE = "http://www.w3.org/2001/XMLSchema#date",
+    XSD_G_MONTH = "http://www.w3.org/2001/XMLSchema#gMonth",
+    XSD_G_MONTHDAY = "http://www.w3.org/2001/XMLSchema#gMonthDay",
+    XSD_G_YEAR = "http://www.w3.org/2001/XMLSchema#gYear",
+    XSD_G_YEAR_MONTH = "http://www.w3.org/2001/XMLSchema#gYearMonth",
+    XSD_TIME = "http://www.w3.org/2001/XMLSchema#time",
+    XSD_G_DAY = "http://www.w3.org/2001/XMLSchema#gDay",
+    XSD_DECIMAL = "http://www.w3.org/2001/XMLSchema#decimal",
+    XSD_FLOAT = "http://www.w3.org/2001/XMLSchema#float",
+    XSD_DOUBLE = "http://www.w3.org/2001/XMLSchema#double",
+    XSD_INTEGER = "http://www.w3.org/2001/XMLSchema#integer",
+    XSD_NON_POSITIVE_INTEGER = "http://www.w3.org/2001/XMLSchema#nonPositiveInteger",
+    XSD_NEGATIVE_INTEGER = "http://www.w3.org/2001/XMLSchema#negativeInteger",
+    XSD_LONG = "http://www.w3.org/2001/XMLSchema#long",
+    XSD_INT = "http://www.w3.org/2001/XMLSchema#int",
+    XSD_SHORT = "http://www.w3.org/2001/XMLSchema#short",
+    XSD_BYTE = "http://www.w3.org/2001/XMLSchema#byte",
+    XSD_NON_NEGATIVE_INTEGER = "http://www.w3.org/2001/XMLSchema#nonNegativeInteger",
+    XSD_POSITIVE_INTEGER = "http://www.w3.org/2001/XMLSchema#positiveInteger",
+    XSD_UNSIGNED_LONG = "http://www.w3.org/2001/XMLSchema#unsignedLong",
+    XSD_UNSIGNED_INT = "http://www.w3.org/2001/XMLSchema#unsignedInt",
+    XSD_UNSIGNED_SHORT = "http://www.w3.org/2001/XMLSchema#unsignedShort",
+    XSD_UNSIGNED_BYTE = "http://www.w3.org/2001/XMLSchema#unsignedByte",
+    XSD_NORMALIZED_STRING = "http://www.w3.org/2001/XMLSchema#normalizedString",
+    XSD_TOKEN = "http://www.w3.org/2001/XMLSchema#token",
+    XSD_LANGUAGE = "http://www.w3.org/2001/XMLSchema#language",
+    XSD_NM_TOKEN = "http://www.w3.org/2001/XMLSchema#NMTOKEN",
+    XSD_NAME = "http://www.w3.org/2001/XMLSchema#name",
+    XSD_NC_NAME = "http://www.w3.org/2001/XMLSchema#NCName",
+    XSD_ENTITY = "http://www.w3.org/2001/XMLSchema#ENTITY",
+    XSD_ID = "http://www.w3.org/2001/XMLSchema#ID",
+    XSD_ID_REF = "http://www.w3.org/2001/XMLSchema#IDREF",
+    XSD_DURATION = "http://www.w3.org/2001/XMLSchema#duration",
+    XSD_YEAR_MONTH_DURATION = "http://www.w3.org/2001/XMLSchema#yearMonthDuration",
+    XSD_DAY_TIME_DURATION = "http://www.w3.org/2001/XMLSchema#dayTimeDuration"
+}
+export type GeneralOperator = KnownOperator | string;
+export type KnownOperator = SparqlOperator | NamedOperator;
+export declare enum SparqlOperator {
+    NOT = "!",
+    UMINUS = "uminus",
+    UPLUS = "uplus",
+    LOGICAL_OR = "||",
+    LOGICAL_AND = "&&",
+    EQUAL = "=",
+    NOT_EQUAL = "!=",
+    LT = "<",
+    GT = ">",
+    LTE = "<=",
+    GTE = ">=",
+    SAME_TERM = "sameterm",
+    IN = "in",
+    NOT_IN = "notin",
+    MULTIPLICATION = "*",
+    DIVISION = "/",
+    ADDITION = "+",
+    SUBTRACTION = "-",
+    IS_IRI = "isiri",
+    IS_URI = "isuri",
+    IS_BLANK = "isblank",
+    IS_LITERAL = "isliteral",
+    IS_NUMERIC = "isnumeric",
+    STR = "str",
+    LANG = "lang",
+    DATATYPE = "datatype",
+    IRI = "iri",
+    URI = "uri",
+    BNODE = "bnode",
+    STRDT = "strdt",
+    STRLANG = "strlang",
+    UUID = "uuid",
+    STRUUID = "struuid",
+    STRLEN = "strlen",
+    SUBSTR = "substr",
+    UCASE = "ucase",
+    LCASE = "lcase",
+    STRSTARTS = "strstarts",
+    STRENDS = "strends",
+    CONTAINS = "contains",
+    STRBEFORE = "strbefore",
+    STRAFTER = "strafter",
+    ENCODE_FOR_URI = "encode_for_uri",
+    CONCAT = "concat",
+    LANG_MATCHES = "langmatches",
+    REGEX = "regex",
+    REPLACE = "replace",
+    ABS = "abs",
+    ROUND = "round",
+    CEIL = "ceil",
+    FLOOR = "floor",
+    RAND = "rand",
+    NOW = "now",
+    YEAR = "year",
+    MONTH = "month",
+    DAY = "day",
+    HOURS = "hours",
+    MINUTES = "minutes",
+    SECONDS = "seconds",
+    TIMEZONE = "timezone",
+    TZ = "tz",
+    MD5 = "md5",
+    SHA1 = "sha1",
+    SHA256 = "sha256",
+    SHA384 = "sha384",
+    SHA512 = "sha512",
+    TRIPLE = "triple",
+    SUBJECT = "subject",
+    PREDICATE = "predicate",
+    OBJECT = "object",
+    IS_TRIPLE = "istriple",
+    BOUND = "bound",
+    IF = "if",
+    COALESCE = "coalesce"
+}
+export type NamedOperator = TypeURL.XSD_STRING | TypeURL.XSD_FLOAT | TypeURL.XSD_DOUBLE | TypeURL.XSD_DECIMAL | TypeURL.XSD_INTEGER | TypeURL.XSD_DATE_TIME | TypeURL.XSD_DATE | TypeURL.XSD_BOOLEAN | TypeURL.XSD_TIME | TypeURL.XSD_DURATION | TypeURL.XSD_DAY_TIME_DURATION | TypeURL.XSD_YEAR_MONTH_DURATION;

package/lib/util/Consts.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SparqlOperator = exports.TypeURL = exports.typedLiteral = exports.TypeAlias = void 0;
+const rdf_data_factory_1 = require("rdf-data-factory");
+var TypeAlias;
+(function (TypeAlias) {
+    // Numeric is everything defined in https://www.w3.org/TR/sparql11-query/#operandDataTypes
+    TypeAlias["SPARQL_NUMERIC"] = "SPARQL_NUMERIC";
+    /**
+     * Stringly is everything defined in https://www.w3.org/TR/sparql11-query/#func-strings
+     * In other words it is a simple literal, a plain literal with language tag, or a literal with datatype xsd:string
+     * In other words, since utils-expression-evaluator transforms a simple literal to xsd_string.
+     * It is RDF_LANG_STRING or XSD_STRING.
+     * Reasons for this are mentioned here: w3c/sparql-12#112
+     */
+    TypeAlias["SPARQL_STRINGLY"] = "SPARQL_STRINGLY";
+})(TypeAlias || (exports.TypeAlias = TypeAlias = {}));
+const DF = new rdf_data_factory_1.DataFactory();
+function typedLiteral(value, type) {
+    return DF.literal(value, DF.namedNode(type));
+}
+exports.typedLiteral = typedLiteral;
+var TypeURL;
+(function (TypeURL) {
+    TypeURL["XSD_ANY_URI"] = "http://www.w3.org/2001/XMLSchema#anyURI";
+    TypeURL["XSD_STRING"] = "http://www.w3.org/2001/XMLSchema#string";
+    TypeURL["RDF_LANG_STRING"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString";
+    TypeURL["XSD_BOOLEAN"] = "http://www.w3.org/2001/XMLSchema#boolean";
+    TypeURL["XSD_DATE_TIME"] = "http://www.w3.org/2001/XMLSchema#dateTime";
+    TypeURL["XSD_DATE_TIME_STAMP"] = "http://www.w3.org/2001/XMLSchema#dateTimeStamp";
+    TypeURL["XSD_DATE"] = "http://www.w3.org/2001/XMLSchema#date";
+    TypeURL["XSD_G_MONTH"] = "http://www.w3.org/2001/XMLSchema#gMonth";
+    TypeURL["XSD_G_MONTHDAY"] = "http://www.w3.org/2001/XMLSchema#gMonthDay";
+    TypeURL["XSD_G_YEAR"] = "http://www.w3.org/2001/XMLSchema#gYear";
+    TypeURL["XSD_G_YEAR_MONTH"] = "http://www.w3.org/2001/XMLSchema#gYearMonth";
+    TypeURL["XSD_TIME"] = "http://www.w3.org/2001/XMLSchema#time";
+    TypeURL["XSD_G_DAY"] = "http://www.w3.org/2001/XMLSchema#gDay";
+    // Numeric types
+    TypeURL["XSD_DECIMAL"] = "http://www.w3.org/2001/XMLSchema#decimal";
+    TypeURL["XSD_FLOAT"] = "http://www.w3.org/2001/XMLSchema#float";
+    TypeURL["XSD_DOUBLE"] = "http://www.w3.org/2001/XMLSchema#double";
+    // Derived numeric types
+    TypeURL["XSD_INTEGER"] = "http://www.w3.org/2001/XMLSchema#integer";
+    TypeURL["XSD_NON_POSITIVE_INTEGER"] = "http://www.w3.org/2001/XMLSchema#nonPositiveInteger";
+    TypeURL["XSD_NEGATIVE_INTEGER"] = "http://www.w3.org/2001/XMLSchema#negativeInteger";
+    TypeURL["XSD_LONG"] = "http://www.w3.org/2001/XMLSchema#long";
+    TypeURL["XSD_INT"] = "http://www.w3.org/2001/XMLSchema#int";
+    TypeURL["XSD_SHORT"] = "http://www.w3.org/2001/XMLSchema#short";
+    TypeURL["XSD_BYTE"] = "http://www.w3.org/2001/XMLSchema#byte";
+    TypeURL["XSD_NON_NEGATIVE_INTEGER"] = "http://www.w3.org/2001/XMLSchema#nonNegativeInteger";
+    TypeURL["XSD_POSITIVE_INTEGER"] = "http://www.w3.org/2001/XMLSchema#positiveInteger";
+    TypeURL["XSD_UNSIGNED_LONG"] = "http://www.w3.org/2001/XMLSchema#unsignedLong";
+    TypeURL["XSD_UNSIGNED_INT"] = "http://www.w3.org/2001/XMLSchema#unsignedInt";
+    TypeURL["XSD_UNSIGNED_SHORT"] = "http://www.w3.org/2001/XMLSchema#unsignedShort";
+    TypeURL["XSD_UNSIGNED_BYTE"] = "http://www.w3.org/2001/XMLSchema#unsignedByte";
+    // Derived String Type
+    TypeURL["XSD_NORMALIZED_STRING"] = "http://www.w3.org/2001/XMLSchema#normalizedString";
+    TypeURL["XSD_TOKEN"] = "http://www.w3.org/2001/XMLSchema#token";
+    TypeURL["XSD_LANGUAGE"] = "http://www.w3.org/2001/XMLSchema#language";
+    TypeURL["XSD_NM_TOKEN"] = "http://www.w3.org/2001/XMLSchema#NMTOKEN";
+    TypeURL["XSD_NAME"] = "http://www.w3.org/2001/XMLSchema#name";
+    TypeURL["XSD_NC_NAME"] = "http://www.w3.org/2001/XMLSchema#NCName";
+    TypeURL["XSD_ENTITY"] = "http://www.w3.org/2001/XMLSchema#ENTITY";
+    TypeURL["XSD_ID"] = "http://www.w3.org/2001/XMLSchema#ID";
+    TypeURL["XSD_ID_REF"] = "http://www.w3.org/2001/XMLSchema#IDREF";
+    // Other types
+    TypeURL["XSD_DURATION"] = "http://www.w3.org/2001/XMLSchema#duration";
+    TypeURL["XSD_YEAR_MONTH_DURATION"] = "http://www.w3.org/2001/XMLSchema#yearMonthDuration";
+    TypeURL["XSD_DAY_TIME_DURATION"] = "http://www.w3.org/2001/XMLSchema#dayTimeDuration";
+})(TypeURL || (exports.TypeURL = TypeURL = {}));
+// TODO: Remove unneeded double typing
+var SparqlOperator;
+(function (SparqlOperator) {
+    // Operator mapping
+    // https://www.w3.org/TR/sparql11-query/#OperatorMapping
+    SparqlOperator["NOT"] = "!";
+    SparqlOperator["UMINUS"] = "uminus";
+    SparqlOperator["UPLUS"] = "uplus";
+    SparqlOperator["LOGICAL_OR"] = "||";
+    SparqlOperator["LOGICAL_AND"] = "&&";
+    SparqlOperator["EQUAL"] = "=";
+    SparqlOperator["NOT_EQUAL"] = "!=";
+    SparqlOperator["LT"] = "<";
+    SparqlOperator["GT"] = ">";
+    SparqlOperator["LTE"] = "<=";
+    SparqlOperator["GTE"] = ">=";
+    SparqlOperator["SAME_TERM"] = "sameterm";
+    SparqlOperator["IN"] = "in";
+    SparqlOperator["NOT_IN"] = "notin";
+    SparqlOperator["MULTIPLICATION"] = "*";
+    SparqlOperator["DIVISION"] = "/";
+    SparqlOperator["ADDITION"] = "+";
+    SparqlOperator["SUBTRACTION"] = "-";
+    // Functional Forms
+    // https://www.w3.org/TR/sparql11-query/#func-forms
+    // See SpecialOperators
+    // Functions on RDF Terms
+    // https://www.w3.org/TR/sparql11-query/#func-rdfTerms
+    SparqlOperator["IS_IRI"] = "isiri";
+    SparqlOperator["IS_URI"] = "isuri";
+    SparqlOperator["IS_BLANK"] = "isblank";
+    SparqlOperator["IS_LITERAL"] = "isliteral";
+    SparqlOperator["IS_NUMERIC"] = "isnumeric";
+    SparqlOperator["STR"] = "str";
+    SparqlOperator["LANG"] = "lang";
+    SparqlOperator["DATATYPE"] = "datatype";
+    SparqlOperator["IRI"] = "iri";
+    SparqlOperator["URI"] = "uri";
+    SparqlOperator["BNODE"] = "bnode";
+    SparqlOperator["STRDT"] = "strdt";
+    SparqlOperator["STRLANG"] = "strlang";
+    SparqlOperator["UUID"] = "uuid";
+    SparqlOperator["STRUUID"] = "struuid";
+    // Functions on strings
+    // https://www.w3.org/TR/sparql11-query/#func-strings
+    SparqlOperator["STRLEN"] = "strlen";
+    SparqlOperator["SUBSTR"] = "substr";
+    SparqlOperator["UCASE"] = "ucase";
+    SparqlOperator["LCASE"] = "lcase";
+    SparqlOperator["STRSTARTS"] = "strstarts";
+    SparqlOperator["STRENDS"] = "strends";
+    SparqlOperator["CONTAINS"] = "contains";
+    SparqlOperator["STRBEFORE"] = "strbefore";
+    SparqlOperator["STRAFTER"] = "strafter";
+    SparqlOperator["ENCODE_FOR_URI"] = "encode_for_uri";
+    SparqlOperator["CONCAT"] = "concat";
+    SparqlOperator["LANG_MATCHES"] = "langmatches";
+    SparqlOperator["REGEX"] = "regex";
+    SparqlOperator["REPLACE"] = "replace";
+    // Functions on numerics
+    // https://www.w3.org/TR/sparql11-query/#func-numerics
+    SparqlOperator["ABS"] = "abs";
+    SparqlOperator["ROUND"] = "round";
+    SparqlOperator["CEIL"] = "ceil";
+    SparqlOperator["FLOOR"] = "floor";
+    SparqlOperator["RAND"] = "rand";
+    // Functions on Dates and Times
+    // https://www.w3.org/TR/sparql11-query/#func-date-time
+    SparqlOperator["NOW"] = "now";
+    SparqlOperator["YEAR"] = "year";
+    SparqlOperator["MONTH"] = "month";
+    SparqlOperator["DAY"] = "day";
+    SparqlOperator["HOURS"] = "hours";
+    SparqlOperator["MINUTES"] = "minutes";
+    SparqlOperator["SECONDS"] = "seconds";
+    SparqlOperator["TIMEZONE"] = "timezone";
+    SparqlOperator["TZ"] = "tz";
+    // Hash functions
+    // https://www.w3.org/TR/sparql11-query/#func-hash
+    SparqlOperator["MD5"] = "md5";
+    SparqlOperator["SHA1"] = "sha1";
+    SparqlOperator["SHA256"] = "sha256";
+    SparqlOperator["SHA384"] = "sha384";
+    SparqlOperator["SHA512"] = "sha512";
+    // XPath Constructor functions
+    // https://www.w3.org/TR/sparql11-query/#FunctionMapping
+    // See Named Operators
+    // Functions for quoted triples
+    // https://w3c.github.io/rdf-star/cg-spec/editors_draft.html#triple-function
+    SparqlOperator["TRIPLE"] = "triple";
+    SparqlOperator["SUBJECT"] = "subject";
+    SparqlOperator["PREDICATE"] = "predicate";
+    SparqlOperator["OBJECT"] = "object";
+    SparqlOperator["IS_TRIPLE"] = "istriple";
+    // Functional Forms
+    // https://www.w3.org/TR/sparql11-query/#func-forms
+    SparqlOperator["BOUND"] = "bound";
+    SparqlOperator["IF"] = "if";
+    SparqlOperator["COALESCE"] = "coalesce";
+})(SparqlOperator || (exports.SparqlOperator = SparqlOperator = {}));
+//# sourceMappingURL=Consts.js.map