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

package/lib/expressions/Term.js

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNonLexicalLiteral = exports.NonLexicalLiteral = exports.YearMonthDurationLiteral = exports.DayTimeDurationLiteral = exports.DurationLiteral = exports.DateLiteral = exports.TimeLiteral = exports.DateTimeLiteral = exports.StringLiteral = exports.LangStringLiteral = exports.BooleanLiteral = exports.DoubleLiteral = exports.FloatLiteral = exports.DecimalLiteral = exports.IntegerLiteral = exports.NumericLiteral = exports.Literal = exports.isLiteralTermExpression = exports.DefaultGraph = exports.Quad = exports.BlankNode = exports.NamedNode = exports.Term = void 0;
+const types_1 = require("@comunica/types");
+const C = require("../util/Consts");
+const Consts_1 = require("../util/Consts");
+const Err = require("../util/Errors");
+const Serialization_1 = require("../util/Serialization");
+const TypeHandling_1 = require("../util/TypeHandling");
+class Term {
+    constructor() {
+        this.expressionType = types_1.ExpressionType.Term;
+    }
+    str() {
+        throw new Err.InvalidArgumentTypes([this], C.SparqlOperator.STR);
+    }
+    coerceEBV() {
+        throw new Err.EBVCoercionError(this);
+    }
+}
+exports.Term = Term;
+// NamedNodes -----------------------------------------------------------------
+class NamedNode extends Term {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.termType = 'namedNode';
+    }
+    toRDF(dataFactory) {
+        return dataFactory.namedNode(this.value);
+    }
+    str() {
+        return this.value;
+    }
+}
+exports.NamedNode = NamedNode;
+// BlankNodes -----------------------------------------------------------------
+class BlankNode extends Term {
+    constructor(value) {
+        super();
+        this.termType = 'blankNode';
+        this.value = value;
+    }
+    toRDF(dataFactory) {
+        return typeof this.value === 'string' ? dataFactory.blankNode(this.value) : this.value;
+    }
+}
+exports.BlankNode = BlankNode;
+// Quads -----------------------------------------------------------------
+class Quad extends Term {
+    constructor(subject, predicate, object, graph) {
+        super();
+        this.subject = subject;
+        this.predicate = predicate;
+        this.object = object;
+        this.graph = graph;
+        this.termType = 'quad';
+    }
+    toRDF(dataFactory) {
+        return dataFactory.quad(this.subject.toRDF(dataFactory), this.predicate.toRDF(dataFactory), this.object.toRDF(dataFactory), this.graph.toRDF(dataFactory));
+    }
+    str() {
+        return `Quad: [${this.subject.str()}, ${this.predicate.str()}, ${this.object.str()}, ${this.graph.str()}]`;
+    }
+}
+exports.Quad = Quad;
+class DefaultGraph extends Term {
+    constructor() {
+        super();
+        this.termType = 'defaultGraph';
+    }
+    toRDF(dataFactory) {
+        return dataFactory.defaultGraph();
+    }
+    str() {
+        return 'DefaultGraph';
+    }
+}
+exports.DefaultGraph = DefaultGraph;
+// Literals-- -----------------------------------------------------------------
+function isLiteralTermExpression(expr) {
+    if (expr.termType === 'literal') {
+        return expr;
+    }
+    return undefined;
+}
+exports.isLiteralTermExpression = isLiteralTermExpression;
+class Literal extends Term {
+    /**
+     * @param typedValue internal representation of this literal's value
+     * @param dataType a string representing the datatype. Can be of type @see LiteralTypes or any URI
+     * @param strValue the string value of this literal. In other words, the string representing the RDF.literal value.
+     * @param language the language, mainly for language enabled strings like RDF_LANG_STRING
+     */
+    constructor(typedValue, dataType, strValue, language) {
+        super();
+        this.typedValue = typedValue;
+        this.dataType = dataType;
+        this.strValue = strValue;
+        this.language = language;
+        this.termType = 'literal';
+    }
+    toRDF(dataFactory) {
+        return dataFactory.literal(this.strValue ?? this.str(), this.language ?? dataFactory.namedNode(this.dataType));
+    }
+    str() {
+        return this.strValue ?? this.typedValue.toString();
+    }
+}
+exports.Literal = Literal;
+class NumericLiteral extends Literal {
+    constructor(typedValue, dataType, strValue, language) {
+        super(typedValue, dataType, strValue, language);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+        this.language = language;
+    }
+    coerceEBV() {
+        return Boolean(this.typedValue);
+    }
+    toRDF(dataFactory) {
+        const term = super.toRDF(dataFactory);
+        if (!Number.isFinite(this.typedValue)) {
+            term.value = term.value.replace('Infinity', 'INF');
+        }
+        return term;
+    }
+    str() {
+        return this.strValue ??
+            this.specificFormatter(this.typedValue);
+    }
+}
+exports.NumericLiteral = NumericLiteral;
+class IntegerLiteral extends NumericLiteral {
+    constructor(typedValue, dataType, strValue, language) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_INTEGER, strValue, language);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+        this.language = language;
+    }
+    specificFormatter(val) {
+        return val.toFixed(0);
+    }
+}
+exports.IntegerLiteral = IntegerLiteral;
+class DecimalLiteral extends NumericLiteral {
+    constructor(typedValue, dataType, strValue, language) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_DECIMAL, strValue, language);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+        this.language = language;
+    }
+    specificFormatter(val) {
+        return val.toString();
+    }
+}
+exports.DecimalLiteral = DecimalLiteral;
+class FloatLiteral extends NumericLiteral {
+    constructor(typedValue, dataType, strValue, language) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_FLOAT, strValue, language);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+        this.language = language;
+    }
+    specificFormatter(val) {
+        return val.toString();
+    }
+}
+exports.FloatLiteral = FloatLiteral;
+class DoubleLiteral extends NumericLiteral {
+    constructor(typedValue, dataType, strValue, language) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_DOUBLE, strValue, language);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+        this.language = language;
+    }
+    specificFormatter(val) {
+        if (!Number.isFinite(val)) {
+            if (val > 0) {
+                return 'INF';
+            }
+            if (val < 0) {
+                return '-INF';
+            }
+            return 'NaN';
+        }
+        const jsExponential = val.toExponential();
+        const [jsMantisse, jsExponent] = jsExponential.split('e');
+        // Leading + must be removed for integer
+        // https://www.w3.org/TR/xmlschema-2/#integer
+        const exponent = jsExponent.replace(/\+/u, '');
+        // SPARQL test suite prefers trailing zero's
+        const mantisse = jsMantisse.includes('.') ?
+            jsMantisse :
+            `${jsMantisse}.0`;
+        return `${mantisse}E${exponent}`;
+    }
+}
+exports.DoubleLiteral = DoubleLiteral;
+class BooleanLiteral extends Literal {
+    constructor(typedValue, strValue, dataType) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_BOOLEAN, strValue);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+    }
+    coerceEBV() {
+        return this.typedValue;
+    }
+}
+exports.BooleanLiteral = BooleanLiteral;
+class LangStringLiteral extends Literal {
+    constructor(typedValue, language, dataType) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.RDF_LANG_STRING, typedValue, language);
+        this.typedValue = typedValue;
+        this.language = language;
+    }
+    coerceEBV() {
+        return this.str().length > 0;
+    }
+}
+exports.LangStringLiteral = LangStringLiteral;
+// https://www.w3.org/TR/2004/REC-rdf-concepts-20040210/#dfn-plain-literal
+// https://www.w3.org/TR/sparql11-query/#defn_SimpleLiteral
+// https://www.w3.org/TR/sparql11-query/#func-strings
+// This does not include language tagged literals
+class StringLiteral extends Literal {
+    /**
+     * @param typedValue
+     * @param dataType Should be type that implements XSD_STRING
+     */
+    constructor(typedValue, dataType) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_STRING, typedValue);
+        this.typedValue = typedValue;
+    }
+    coerceEBV() {
+        return this.str().length > 0;
+    }
+}
+exports.StringLiteral = StringLiteral;
+class DateTimeLiteral extends Literal {
+    constructor(typedValue, strValue, dataType) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_DATE_TIME, strValue);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+    }
+    str() {
+        return (0, Serialization_1.serializeDateTime)(this.typedValue);
+    }
+}
+exports.DateTimeLiteral = DateTimeLiteral;
+class TimeLiteral extends Literal {
+    constructor(typedValue, strValue, dataType) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_TIME, strValue);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+    }
+    str() {
+        return (0, Serialization_1.serializeTime)(this.typedValue);
+    }
+}
+exports.TimeLiteral = TimeLiteral;
+class DateLiteral extends Literal {
+    constructor(typedValue, strValue, dataType) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_DATE, strValue);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+    }
+    str() {
+        return (0, Serialization_1.serializeDate)(this.typedValue);
+    }
+}
+exports.DateLiteral = DateLiteral;
+class DurationLiteral extends Literal {
+    constructor(typedValue, strValue, dataType) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_DURATION, strValue);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+    }
+    str() {
+        return (0, Serialization_1.serializeDuration)(this.typedValue);
+    }
+}
+exports.DurationLiteral = DurationLiteral;
+class DayTimeDurationLiteral extends DurationLiteral {
+    constructor(typedValue, strValue, dataType) {
+        super(typedValue, strValue, dataType ?? Consts_1.TypeURL.XSD_DAY_TIME_DURATION);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+    }
+}
+exports.DayTimeDurationLiteral = DayTimeDurationLiteral;
+class YearMonthDurationLiteral extends Literal {
+    constructor(typedValue, strValue, dataType) {
+        super(typedValue, dataType ?? Consts_1.TypeURL.XSD_YEAR_MONTH_DURATION, strValue);
+        this.typedValue = typedValue;
+        this.strValue = strValue;
+    }
+    str() {
+        return (0, Serialization_1.serializeDuration)(this.typedValue, 'P0M');
+    }
+}
+exports.YearMonthDurationLiteral = YearMonthDurationLiteral;
+/**
+ * This class is used when a literal is parsed, and it's value is
+ * an invalid lexical form for it's datatype. The spec defines value with
+ * invalid lexical form are still valid terms, and as such we can not error
+ * immediately. This class makes sure that the typedValue will remain undefined,
+ * and the category 'nonlexical'. This way, only when operators apply to the
+ * 'nonlexical' category, they will keep working, otherwise they will throw a
+ * type error.
+ * This seems to match the spec, except maybe for functions that accept
+ * non-lexical values for their datatype.
+ *
+ * See:
+ *  - https://www.w3.org/TR/xquery/#dt-type-error
+ *  - https://www.w3.org/TR/rdf-concepts/#section-Literal-Value
+ *  - https://www.w3.org/TR/xquery/#dt-ebv
+ *  - ... some other more precise thing i can't find...
+ */
+class NonLexicalLiteral extends Literal {
+    constructor(typedValue, dataType, openWorldType, strValue, language) {
+        super({ toString: () => 'undefined' }, dataType, strValue, language);
+        this.openWorldType = openWorldType;
+    }
+    coerceEBV() {
+        const isNumericOrBool = (0, TypeHandling_1.isSubTypeOf)(this.dataType, Consts_1.TypeURL.XSD_BOOLEAN, this.openWorldType) ||
+            (0, TypeHandling_1.isSubTypeOf)(this.dataType, Consts_1.TypeAlias.SPARQL_NUMERIC, this.openWorldType);
+        if (isNumericOrBool) {
+            return false;
+        }
+        throw new Err.EBVCoercionError(this);
+    }
+    toRDF(dataFactory) {
+        return dataFactory.literal(this.str(), this.language ?? dataFactory.namedNode(this.dataType));
+    }
+    str() {
+        return this.strValue ?? '';
+    }
+}
+exports.NonLexicalLiteral = NonLexicalLiteral;
+function isNonLexicalLiteral(lit) {
+    if (lit instanceof NonLexicalLiteral) {
+        return lit;
+    }
+    return undefined;
+}
+exports.isNonLexicalLiteral = isNonLexicalLiteral;
+//# sourceMappingURL=Term.js.map

package/lib/expressions/Term.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Term.js","sourceRoot":"","sources":["Term.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  ComunicaDataFactory,\n  IDateRepresentation,\n  IDateTimeRepresentation,\n  IDurationRepresentation,\n  ISuperTypeProvider,\n  ITimeRepresentation,\n  IYearMonthDurationRepresentation,\n  TermExpression,\n  TermType,\n} from '@comunica/types';\nimport { ExpressionType,\n} from '@comunica/types';\nimport type * as RDF from '@rdfjs/types';\nimport * as C from '../util/Consts';\nimport { TypeAlias, TypeURL } from '../util/Consts';\n\nimport * as Err from '../util/Errors';\nimport { serializeDate, serializeDateTime, serializeDuration, serializeTime } from '../util/Serialization';\nimport { isSubTypeOf } from '../util/TypeHandling';\n\nexport abstract class Term implements TermExpression {\n  public expressionType: ExpressionType.Term = ExpressionType.Term;\n  public abstract termType: TermType;\n\n  public abstract toRDF(dataFactory: ComunicaDataFactory): RDF.Term;\n\n  public str(): string {\n    throw new Err.InvalidArgumentTypes([ this ], C.SparqlOperator.STR);\n  }\n\n  public coerceEBV(): boolean {\n    throw new Err.EBVCoercionError(this);\n  }\n}\n\n// NamedNodes -----------------------------------------------------------------\nexport class NamedNode extends Term {\n  public termType: TermType = 'namedNode';\n  public constructor(public value: string) {\n    super();\n  }\n\n  public toRDF(dataFactory: ComunicaDataFactory): RDF.Term {\n    return dataFactory.namedNode(this.value);\n  }\n\n  public override str(): string {\n    return this.value;\n  }\n}\n\n// BlankNodes -----------------------------------------------------------------\n\nexport class BlankNode extends Term {\n  public value: RDF.BlankNode | string;\n  public termType: TermType = 'blankNode';\n\n  public constructor(value: RDF.BlankNode | string) {\n    super();\n    this.value = value;\n  }\n\n  public toRDF(dataFactory: ComunicaDataFactory): RDF.Term {\n    return typeof this.value === 'string' ? dataFactory.blankNode(this.value) : this.value;\n  }\n}\n\n// Quads -----------------------------------------------------------------\nexport class Quad extends Term {\n  public termType: TermType = 'quad';\n\n  public constructor(\n    public readonly subject: Term,\n    public readonly predicate: Term,\n    public readonly object: Term,\n    public readonly graph: Term,\n  ) {\n    super();\n  }\n\n  public toRDF(dataFactory: ComunicaDataFactory): RDF.BaseQuad {\n    return dataFactory.quad(\n      <RDF.Quad_Subject> this.subject.toRDF(dataFactory),\n      <RDF.Quad_Predicate> this.predicate.toRDF(dataFactory),\n      <RDF.Quad_Object> this.object.toRDF(dataFactory),\n      <RDF.Quad_Graph> this.graph.toRDF(dataFactory),\n    );\n  }\n\n  public override str(): string {\n    return `Quad: [${this.subject.str()}, ${this.predicate.str()}, ${this.object.str()}, ${this.graph.str()}]`;\n  }\n}\n\nexport class DefaultGraph extends Term {\n  public termType: TermType = 'defaultGraph';\n\n  public constructor() {\n    super();\n  }\n\n  public toRDF(dataFactory: ComunicaDataFactory): RDF.DefaultGraph {\n    return dataFactory.defaultGraph();\n  }\n\n  public override str(): string {\n    return 'DefaultGraph';\n  }\n}\n\n// Literals-- -----------------------------------------------------------------\nexport function isLiteralTermExpression(expr: TermExpression): Literal<any> | undefined {\n  if (expr.termType === 'literal') {\n    return <Literal<any>> expr;\n  }\n  return undefined;\n}\n\nexport interface ISerializable {\n  toString: () => string;\n}\n\nexport class Literal<T extends ISerializable> extends Term {\n  public termType = <const> 'literal';\n  /**\n   * @param typedValue internal representation of this literal's value\n   * @param dataType a string representing the datatype. Can be of type @see LiteralTypes or any URI\n   * @param strValue the string value of this literal. In other words, the string representing the RDF.literal value.\n   * @param language the language, mainly for language enabled strings like RDF_LANG_STRING\n   */\n  public constructor(\n    public typedValue: T,\n    public dataType: string,\n    public strValue?: string,\n    public language?: string,\n  ) {\n    super();\n  }\n\n  public toRDF(dataFactory: ComunicaDataFactory): RDF.Literal {\n    return dataFactory.literal(\n      this.strValue ?? this.str(),\n      this.language ?? dataFactory.namedNode(this.dataType),\n    );\n  }\n\n  public override str(): string {\n    return this.strValue ?? this.typedValue.toString();\n  }\n}\n\nexport abstract class NumericLiteral extends Literal<number> {\n  protected constructor(\n    public override typedValue: number,\n    dataType: string,\n    public override strValue?: string,\n    public override language?: string,\n  ) {\n    super(typedValue, dataType, strValue, language);\n  }\n\n  protected abstract specificFormatter(val: number): string;\n\n  public override coerceEBV(): boolean {\n    return Boolean(this.typedValue);\n  }\n\n  public override toRDF(dataFactory: ComunicaDataFactory): RDF.Literal {\n    const term = super.toRDF(dataFactory);\n    if (!Number.isFinite(this.typedValue)) {\n      term.value = term.value.replace('Infinity', 'INF');\n    }\n    return term;\n  }\n\n  public override str(): string {\n    return this.strValue ??\n      this.specificFormatter(this.typedValue);\n  }\n}\n\nexport class IntegerLiteral extends NumericLiteral {\n  public constructor(\n    public override typedValue: number,\n    dataType?: string,\n    public override strValue?: string,\n    public override language?: string,\n  ) {\n    super(typedValue, dataType ?? TypeURL.XSD_INTEGER, strValue, language);\n  }\n\n  protected specificFormatter(val: number): string {\n    return val.toFixed(0);\n  }\n}\n\nexport class DecimalLiteral extends NumericLiteral {\n  public constructor(\n    public override typedValue: number,\n    dataType?: string,\n    public override strValue?: string,\n    public override language?: string,\n  ) {\n    super(typedValue, dataType ?? TypeURL.XSD_DECIMAL, strValue, language);\n  }\n\n  protected specificFormatter(val: number): string {\n    return val.toString();\n  }\n}\n\nexport class FloatLiteral extends NumericLiteral {\n  public constructor(\n    public override typedValue: number,\n    dataType?: string,\n    public override strValue?: string,\n    public override language?: string,\n  ) {\n    super(typedValue, dataType ?? TypeURL.XSD_FLOAT, strValue, language);\n  }\n\n  protected specificFormatter(val: number): string {\n    return val.toString();\n  }\n}\n\nexport class DoubleLiteral extends NumericLiteral {\n  public constructor(\n    public override typedValue: number,\n    dataType?: string,\n    public override strValue?: string,\n    public override language?: string,\n  ) {\n    super(typedValue, dataType ?? TypeURL.XSD_DOUBLE, strValue, language);\n  }\n\n  protected specificFormatter(val: number): string {\n    if (!Number.isFinite(val)) {\n      if (val > 0) {\n        return 'INF';\n      }\n      if (val < 0) {\n        return '-INF';\n      }\n      return 'NaN';\n    }\n\n    const jsExponential = val.toExponential();\n    const [ jsMantisse, jsExponent ] = jsExponential.split('e');\n\n    // Leading + must be removed for integer\n    // https://www.w3.org/TR/xmlschema-2/#integer\n    const exponent = jsExponent.replace(/\\+/u, '');\n\n    // SPARQL test suite prefers trailing zero's\n    const mantisse = jsMantisse.includes('.') ?\n      jsMantisse :\n      `${jsMantisse}.0`;\n\n    return `${mantisse}E${exponent}`;\n  }\n}\n\nexport class BooleanLiteral extends Literal<boolean> {\n  public constructor(public override typedValue: boolean, public override strValue?: string, dataType?: string) {\n    super(typedValue, dataType ?? TypeURL.XSD_BOOLEAN, strValue);\n  }\n\n  public override coerceEBV(): boolean {\n    return this.typedValue;\n  }\n}\n\nexport class LangStringLiteral extends Literal<string> {\n  public constructor(public override typedValue: string, public override language: string, dataType?: string) {\n    super(typedValue, dataType ?? TypeURL.RDF_LANG_STRING, typedValue, language);\n  }\n\n  public override coerceEBV(): boolean {\n    return this.str().length > 0;\n  }\n}\n\n// https://www.w3.org/TR/2004/REC-rdf-concepts-20040210/#dfn-plain-literal\n// https://www.w3.org/TR/sparql11-query/#defn_SimpleLiteral\n// https://www.w3.org/TR/sparql11-query/#func-strings\n// This does not include language tagged literals\nexport class StringLiteral extends Literal<string> {\n  /**\n   * @param typedValue\n   * @param dataType Should be type that implements XSD_STRING\n   */\n  public constructor(public override typedValue: string, dataType?: string) {\n    super(typedValue, dataType ?? TypeURL.XSD_STRING, typedValue);\n  }\n\n  public override coerceEBV(): boolean {\n    return this.str().length > 0;\n  }\n}\n\nexport class DateTimeLiteral extends Literal<IDateTimeRepresentation> {\n  public constructor(\n    public override typedValue: IDateTimeRepresentation,\n    public override strValue?: string,\n    dataType?: string,\n  ) {\n    super(typedValue, dataType ?? TypeURL.XSD_DATE_TIME, strValue);\n  }\n\n  public override str(): string {\n    return serializeDateTime(this.typedValue);\n  }\n}\n\nexport class TimeLiteral extends Literal<ITimeRepresentation> {\n  public constructor(\n    public override typedValue: ITimeRepresentation,\n    public override strValue?: string,\n    dataType?: string,\n  ) {\n    super(typedValue, dataType ?? TypeURL.XSD_TIME, strValue);\n  }\n\n  public override str(): string {\n    return serializeTime(this.typedValue);\n  }\n}\n\nexport class DateLiteral extends Literal<IDateRepresentation> {\n  public constructor(\n    public override typedValue: IDateRepresentation,\n    public override strValue?: string,\n    dataType?: string,\n  ) {\n    super(typedValue, dataType ?? TypeURL.XSD_DATE, strValue);\n  }\n\n  public override str(): string {\n    return serializeDate(this.typedValue);\n  }\n}\n\nexport class DurationLiteral extends Literal<Partial<IDurationRepresentation>> {\n  public constructor(\n    public override typedValue: Partial<IDurationRepresentation>,\n    public override strValue?: string,\n    dataType?: string,\n  ) {\n    super(typedValue, dataType ?? TypeURL.XSD_DURATION, strValue);\n  }\n\n  public override str(): string {\n    return serializeDuration(this.typedValue);\n  }\n}\n\nexport class DayTimeDurationLiteral extends DurationLiteral {\n  public constructor(\n    public override typedValue: Partial<IDurationRepresentation>,\n    public override strValue?: string,\n    dataType?: string,\n  ) {\n    super(typedValue, strValue, dataType ?? TypeURL.XSD_DAY_TIME_DURATION);\n  }\n}\n\nexport class YearMonthDurationLiteral extends Literal<Partial<IYearMonthDurationRepresentation>> {\n  public constructor(\n    public override typedValue: Partial<IYearMonthDurationRepresentation>,\n    public override strValue?: string,\n    dataType?: string,\n  ) {\n    super(typedValue, dataType ?? TypeURL.XSD_YEAR_MONTH_DURATION, strValue);\n  }\n\n  public override str(): string {\n    return serializeDuration(this.typedValue, 'P0M');\n  }\n}\n\n/**\n * This class is used when a literal is parsed, and it's value is\n * an invalid lexical form for it's datatype. The spec defines value with\n * invalid lexical form are still valid terms, and as such we can not error\n * immediately. This class makes sure that the typedValue will remain undefined,\n * and the category 'nonlexical'. This way, only when operators apply to the\n * 'nonlexical' category, they will keep working, otherwise they will throw a\n * type error.\n * This seems to match the spec, except maybe for functions that accept\n * non-lexical values for their datatype.\n *\n * See:\n *  - https://www.w3.org/TR/xquery/#dt-type-error\n *  - https://www.w3.org/TR/rdf-concepts/#section-Literal-Value\n *  - https://www.w3.org/TR/xquery/#dt-ebv\n *  - ... some other more precise thing i can't find...\n */\nexport class NonLexicalLiteral extends Literal<{ toString: () => 'undefined' }> {\n  public constructor(\n    typedValue: undefined,\n    dataType: string,\n    private readonly openWorldType: ISuperTypeProvider,\n    strValue?: string,\n    language?: string,\n  ) {\n    super({ toString: () => 'undefined' }, dataType, strValue, language);\n  }\n\n  public override coerceEBV(): boolean {\n    const isNumericOrBool =\n      isSubTypeOf(this.dataType, TypeURL.XSD_BOOLEAN, this.openWorldType) ||\n      isSubTypeOf(this.dataType, TypeAlias.SPARQL_NUMERIC, this.openWorldType);\n    if (isNumericOrBool) {\n      return false;\n    }\n    throw new Err.EBVCoercionError(this);\n  }\n\n  public override toRDF(dataFactory: ComunicaDataFactory): RDF.Literal {\n    return dataFactory.literal(\n      this.str(),\n      this.language ?? dataFactory.namedNode(this.dataType),\n    );\n  }\n\n  public override str(): string {\n    return this.strValue ?? '';\n  }\n}\n\nexport function isNonLexicalLiteral(lit: Literal<any>): NonLexicalLiteral | undefined {\n  if (lit instanceof NonLexicalLiteral) {\n    return lit;\n  }\n  return undefined;\n}\n"]}

package/lib/expressions/Variable.d.ts

@@ -0,0 +1,7 @@
+import type { VariableExpression } from '@comunica/types';
+import { ExpressionType } from '@comunica/types';
+export declare class Variable implements VariableExpression {
+    expressionType: ExpressionType.Variable;
+    name: string;
+    constructor(name: string);
+}

package/lib/expressions/Variable.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Variable = void 0;
+const types_1 = require("@comunica/types");
+class Variable {
+    constructor(name) {
+        this.expressionType = types_1.ExpressionType.Variable;
+        this.name = name;
+    }
+}
+exports.Variable = Variable;
+//# sourceMappingURL=Variable.js.map

package/lib/expressions/Variable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Variable.js","sourceRoot":"","sources":["Variable.ts"],"names":[],"mappings":";;;AACA,2CAAiD;AAEjD,MAAa,QAAQ;IAGnB,YAAmB,IAAY;QAFxB,mBAAc,GAA4B,sBAAc,CAAC,QAAQ,CAAC;QAGvE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAND,4BAMC","sourcesContent":["import type { VariableExpression } from '@comunica/types';\nimport { ExpressionType } from '@comunica/types';\n\nexport class Variable implements VariableExpression {\n  public expressionType: ExpressionType.Variable = ExpressionType.Variable;\n  public name: string;\n  public constructor(name: string) {\n    this.name = name;\n  }\n}\n"]}

package/lib/expressions/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Expressions';
+export * from './Variable';
+export * from './Term';
+export * from './Operator';
+export * from './Aggregate';
+export * from './Existence';

package/lib/expressions/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Expressions"), exports);
+__exportStar(require("./Variable"), exports);
+__exportStar(require("./Term"), exports);
+__exportStar(require("./Operator"), exports);
+__exportStar(require("./Aggregate"), exports);
+__exportStar(require("./Existence"), exports);
+//# sourceMappingURL=index.js.map

package/lib/expressions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gDAA8B;AAC9B,6CAA2B;AAC3B,yCAAuB;AACvB,6CAA2B;AAC3B,8CAA4B;AAC5B,8CAA4B","sourcesContent":["export * from './Expressions';\nexport * from './Variable';\nexport * from './Term';\nexport * from './Operator';\nexport * from './Aggregate';\nexport * from './Existence';\n"]}

package/lib/functions/Helpers.d.ts

@@ -0,0 +1,81 @@
+import type { ComunicaDataFactory, IDateTimeRepresentation, IInternalEvaluator, ImplementationFunction, ImplementationFunctionTuple, TermExpression, VariableExpression } from '@comunica/types';
+import type * as RDF from '@rdfjs/types';
+import type { ISerializable, Quad } from '../expressions';
+import * as E from '../expressions';
+import type { ArgumentType } from './OverloadTree';
+import { OverloadTree } from './OverloadTree';
+type Term = TermExpression;
+export declare function declare(identifier: string): Builder;
+export declare class Builder {
+    private readonly overloadTree;
+    private collected;
+    constructor(identifier: string);
+    collect(): OverloadTree;
+    private static wrapInvalidLexicalProtected;
+    set(argTypes: [], func: ImplementationFunctionTuple<[]>, addInvalidHandling?: boolean): Builder;
+    set<T1 extends TermExpression>(argTypes: [ArgumentType], func: ImplementationFunctionTuple<[T1]>, addInvalidHandling?: boolean): Builder;
+    set<T1 extends TermExpression, T2 extends TermExpression>(argTypes: [ArgumentType, ArgumentType], func: ImplementationFunctionTuple<[T1, T2]>, addInvalidHandling?: boolean): Builder;
+    set<T1 extends TermExpression, T2 extends TermExpression, T3 extends TermExpression>(argTypes: [ArgumentType, ArgumentType, ArgumentType], func: ImplementationFunctionTuple<[T1, T2, T3]>, addInvalidHandling?: boolean): Builder;
+    set<T1 extends TermExpression, T2 extends TermExpression, T3 extends TermExpression, T4 extends TermExpression>(argTypes: [ArgumentType, ArgumentType, ArgumentType, ArgumentType], func: ImplementationFunctionTuple<[T1, T2, T3, T4]>, addInvalidHandling?: boolean): Builder;
+    set(argTypes: ArgumentType[], func: ImplementationFunction, addInvalidHandling?: boolean): Builder;
+    copy({ from, to }: {
+        from: ArgumentType[];
+        to: ArgumentType[];
+    }): Builder;
+    onUnary<T extends Term>(type: ArgumentType, op: (expressionEvaluator: IInternalEvaluator) => (val: T) => Term, addInvalidHandling?: boolean): Builder;
+    onUnaryTyped<T extends ISerializable>(type: ArgumentType, op: (expressionEvaluator: IInternalEvaluator) => (val: T) => Term, addInvalidHandling?: boolean): Builder;
+    onBinary<L extends Term, R extends Term>(types: [ArgumentType, ArgumentType], op: (expressionEvaluator: IInternalEvaluator) => (left: L, right: R) => Term, addInvalidHandling?: boolean): Builder;
+    onBinaryTyped<L extends ISerializable, R extends ISerializable>(types: [ArgumentType, ArgumentType], op: (expressionEvaluator: IInternalEvaluator) => (left: L, right: R) => Term, addInvalidHandling?: boolean): Builder;
+    onTernaryTyped<A1 extends ISerializable, A2 extends ISerializable, A3 extends ISerializable>(types: [ArgumentType, ArgumentType, ArgumentType], op: (expressionEvaluator: IInternalEvaluator) => (a1: A1, a2: A2, a3: A3) => Term, addInvalidHandling?: boolean): Builder;
+    onTernary<A1 extends Term, A2 extends Term, A3 extends Term>(types: [ArgumentType, ArgumentType, ArgumentType], op: (expressionEvaluator: IInternalEvaluator) => (a1: A1, a2: A2, a3: A3) => Term, addInvalidHandling?: boolean): Builder;
+    onQuaternaryTyped<A1 extends ISerializable, A2 extends ISerializable, A3 extends ISerializable, A4 extends ISerializable>(types: [ArgumentType, ArgumentType, ArgumentType, ArgumentType], op: (expressionEvaluator: IInternalEvaluator) => (a1: A1, a2: A2, a3: A3, a4: A4) => Term, addInvalidHandling?: boolean): Builder;
+    onTerm1<T extends Term>(op: (expressionEvaluator: IInternalEvaluator) => (term: T) => Term, addInvalidHandling?: boolean): Builder;
+    onTerm3(op: (expressionEvaluator: IInternalEvaluator) => (t1: Term, t2: Term, t3: Term) => Term): Builder;
+    onQuad1(op: (expressionEvaluator: IInternalEvaluator) => (term: Term & Quad) => Term): Builder;
+    onLiteral1<T extends ISerializable>(op: (expressionEvaluator: IInternalEvaluator) => (lit: E.Literal<T>) => Term, addInvalidHandling?: boolean): Builder;
+    onBoolean1(op: (expressionEvaluator: IInternalEvaluator) => (lit: E.BooleanLiteral) => Term, addInvalidHandling?: boolean): Builder;
+    onBoolean1Typed(op: (expressionEvaluator: IInternalEvaluator) => (lit: boolean) => Term, addInvalidHandling?: boolean): Builder;
+    onString1(op: (expressionEvaluator: IInternalEvaluator) => (lit: E.Literal<string>) => Term, addInvalidHandling?: boolean): Builder;
+    onString1Typed(op: (expressionEvaluator: IInternalEvaluator) => (lit: string) => Term, addInvalidHandling?: boolean): Builder;
+    onLangString1(op: (expressionEvaluator: IInternalEvaluator) => (lit: E.LangStringLiteral) => Term, addInvalidHandling?: boolean): Builder;
+    onStringly1(op: (expressionEvaluator: IInternalEvaluator) => (lit: E.Literal<string>) => Term, addInvalidHandling?: boolean): Builder;
+    onStringly1Typed(op: (expressionEvaluator: IInternalEvaluator) => (lit: string) => Term, addInvalidHandling?: boolean): Builder;
+    onNumeric1(op: (expressionEvaluator: IInternalEvaluator) => (val: E.NumericLiteral) => Term, addInvalidHandling?: boolean): Builder;
+    onDateTime1(op: (expressionEvaluator: IInternalEvaluator) => (date: E.DateTimeLiteral) => Term, addInvalidHandling?: boolean): Builder;
+    /**
+     * We return the base types and not the provided types because we don't want to create invalid terms.
+     * Providing negative number to a function unary - for example should not
+     * return a term of type negative number having a positive value.
+     * @param op the numeric operator performed
+     * @param addInvalidHandling whether to add invalid handling,
+     *   whether to add @param op in @see wrapInvalidLexicalProtected
+     */
+    numericConverter(op: (expressionEvaluator: IInternalEvaluator) => (val: number) => number, addInvalidHandling?: boolean): Builder;
+    /**
+     * !!! Be aware when using this function, it will create different overloads with different return types !!!
+     * Arithmetic operators take 2 numeric arguments, and return a single numerical
+     * value. The type of the return value is heavily dependent on the types of the
+     * input arguments. In JS everything is a double, but in SPARQL it is not.
+     *
+     * The different arguments are handled by type promotion and subtype substitution.
+     * The way numeric function arguments work is described here:
+     * https://www.w3.org/TR/xpath20/#mapping
+     * Above url is referenced in the sparql spec: https://www.w3.org/TR/sparql11-query/#OperatorMapping
+     */
+    arithmetic(op: (expressionEvaluator: IInternalEvaluator) => (left: number, right: number) => number, addInvalidHandling?: boolean): Builder;
+    numberTest(test: (expressionEvaluator: IInternalEvaluator) => (left: number, right: number) => boolean): Builder;
+    stringTest(test: (expressionEvaluator: IInternalEvaluator) => (left: string, right: string) => boolean, addInvalidHandling?: boolean): Builder;
+    booleanTest(test: (expressionEvaluator: IInternalEvaluator) => (left: boolean, right: boolean) => boolean, addInvalidHandling?: boolean): Builder;
+    dateTimeTest(test: (expressionEvaluator: IInternalEvaluator) => (left: IDateTimeRepresentation, right: IDateTimeRepresentation) => boolean, addInvalidHandling?: boolean): Builder;
+    numeric<T extends TermExpression>(op: ImplementationFunctionTuple<[T, T]>): Builder;
+}
+export declare function bool(val: boolean): E.BooleanLiteral;
+export declare function integer(num: number): E.IntegerLiteral;
+export declare function decimal(num: number): E.DecimalLiteral;
+export declare function float(num: number): E.FloatLiteral;
+export declare function double(num: number): E.DoubleLiteral;
+export declare function string(str: string): E.StringLiteral;
+export declare function langString(str: string, lang: string): E.LangStringLiteral;
+export declare function dateTime(date: IDateTimeRepresentation, str: string): E.DateTimeLiteral;
+export declare function expressionToVar(dataFactory: ComunicaDataFactory, variableExpression: VariableExpression): RDF.Variable;
+export {};