@traqula/rules-sparql-1-1 0.0.1-alpha.137

package/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © 2024–now Jitse De Smet
+Comunica Association and Ghent University – imec, Belgium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# TRAQULA Rules SPARQL 1.1
+
+TRAQULA rules SPARQL 1.1 contains rules required for creating a parser for SPARQL 1.1.
+
+## Installation
+
+```bash
+npm install @traqula/rules-sparql-1-1
+```
+
+or
+
+```bash
+yarn add @traqula/rules-sparql-1-1
+```

package/lib/Sparql11types.d.ts

@@ -0,0 +1,246 @@
+import type * as RdfJs from '@rdfjs/types';
+import type { BlankNode } from 'rdf-data-factory';
+import type { CommonIRIs } from '@traqula/core';
+export type GraphTerm = IriTerm | BlankTerm | LiteralTerm;
+export type Term = GraphTerm | VariableTerm;
+export type VerbA = IriTerm<CommonIRIs.TYPE>;
+export interface Wildcard {
+    readonly termType: 'Wildcard';
+    readonly value: '*';
+    equals: (other: RdfJs.Term | null | undefined) => boolean;
+}
+export type Triple = {
+    subject: Term;
+    predicate: IriTerm | VariableTerm | PropertyPath;
+    object: Term;
+};
+export type TripleCreatorS = (part: Pick<Triple, 'subject'>) => Triple;
+export type TripleCreatorSP = (part: Pick<Triple, 'subject' | 'predicate'>) => Triple;
+export interface IGraphNode {
+    node: ITriplesNode['node'] | Term;
+    triples: Triple[];
+}
+export interface ITriplesNode {
+    node: IriTerm | BlankNode;
+    triples: Triple[];
+}
+export type Pattern = BgpPattern | BlockPattern | FilterPattern | BindPattern | ValuesPattern | Omit<SelectQuery, 'prefixes'>;
+export type Expression = OperationExpression | FunctionCallExpression | AggregateExpression | Expression[] | IriTerm | VariableTerm | LiteralTerm;
+export interface FunctionCallExpression extends BaseExpression {
+    type: 'functionCall';
+    function: IriTerm;
+    args: Expression[];
+}
+/**
+ * Basic Graph Pattern
+ */
+export interface BgpPattern {
+    type: 'bgp';
+    triples: Triple[];
+}
+export interface GraphQuads {
+    type: 'graph';
+    name: IriTerm | VariableTerm;
+    triples: Triple[];
+}
+export interface SparqlParser {
+    parse: (query: string) => SparqlQuery;
+    _resetBlanks: () => void;
+}
+export type VariableTerm = RdfJs.Variable;
+export type IriTerm<IRI extends string = string> = RdfJs.NamedNode<IRI>;
+export type LiteralTerm = RdfJs.Literal;
+export type BlankTerm = RdfJs.BlankNode;
+export type PropertyPath = NegatedPropertySet | {
+    type: 'path';
+    pathType: '|' | '/' | '^' | '+' | '*' | '?';
+    items: (IriTerm | PropertyPath)[];
+};
+export type SparqlQuery = Query | Update | Pick<Update, 'base' | 'prefixes'>;
+export type Query = SelectQuery | ConstructQuery | AskQuery | DescribeQuery;
+export interface SelectQuery extends BaseQuery {
+    queryType: 'SELECT';
+    variables: Variable[] | [Wildcard];
+    distinct?: true | undefined;
+    reduced?: true | undefined;
+    group?: Grouping[] | undefined;
+    having?: Expression[] | undefined;
+    order?: Ordering[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}
+export interface Grouping {
+    expression: Expression;
+    variable?: VariableTerm;
+}
+export interface Ordering {
+    expression: Expression;
+    descending?: true | undefined;
+}
+export interface ConstructQuery extends BaseQuery {
+    queryType: 'CONSTRUCT';
+    template?: Triple[] | undefined;
+}
+export interface AskQuery extends BaseQuery {
+    queryType: 'ASK';
+}
+export interface DescribeQuery extends BaseQuery {
+    queryType: 'DESCRIBE';
+    variables: (VariableTerm | IriTerm)[] | [Wildcard];
+}
+export interface Update {
+    type: 'update';
+    base?: string | undefined;
+    prefixes: Record<string, string>;
+    updates: UpdateOperation[];
+}
+export type UpdateOperation = InsertDeleteOperation | ManagementOperation;
+export type InsertDeleteOperation = {
+    updateType: 'insert';
+    graph?: GraphOrDefault;
+    insert: Quads[];
+} | {
+    updateType: 'delete';
+    graph?: GraphOrDefault;
+    delete: Quads[];
+} | {
+    updateType: 'insertdelete';
+    graph?: IriTerm;
+    insert: Quads[];
+    delete: Quads[];
+    using?: {
+        default: IriTerm[];
+        named: IriTerm[];
+    };
+    where: Pattern[];
+} | {
+    updateType: 'deletewhere';
+    graph?: GraphOrDefault;
+    delete: Quads[];
+};
+export type Quads = BgpPattern | GraphQuads;
+export type ManagementOperation = CopyMoveAddOperation | LoadOperation | CreateOperation | ClearDropOperation;
+export interface CopyMoveAddOperation {
+    type: 'copy' | 'move' | 'add';
+    silent: boolean;
+    source: GraphOrDefault;
+    destination: GraphOrDefault;
+}
+export interface LoadOperation {
+    type: 'load';
+    silent: boolean;
+    source: IriTerm;
+    destination?: IriTerm;
+}
+export interface CreateOperation {
+    type: 'create';
+    silent: boolean;
+    graph: GraphOrDefault;
+}
+export interface ClearDropOperation {
+    type: 'clear' | 'drop';
+    silent: boolean;
+    graph: GraphReference;
+}
+export interface GraphOrDefault {
+    type?: 'graph';
+    name?: IriTerm | undefined;
+    default?: true | undefined;
+}
+export interface GraphReference extends GraphOrDefault {
+    named?: true | undefined;
+    all?: true | undefined;
+}
+/**
+ * Examples: '?var', '*',
+ *   SELECT (?a as ?b) ... ==> { expression: '?a', variable: '?b' }
+ */
+export type Variable = VariableExpression | VariableTerm;
+export interface VariableExpression {
+    expression: Expression;
+    variable: VariableTerm;
+}
+export interface BaseQuery {
+    type: 'query';
+    base?: string | undefined;
+    prefixes: Record<string, string>;
+    from?: {
+        default: IriTerm[];
+        named: IriTerm[];
+    } | undefined;
+    where?: Pattern[] | undefined;
+    values?: ValuePatternRow[] | undefined;
+}
+export type IriTermOrElt = IriTerm | {
+    type: 'path';
+    pathType: '^';
+    items: [IriTerm];
+};
+export interface NegatedPropertySet {
+    type: 'path';
+    pathType: '!';
+    items: IriTermOrElt[] | [
+        {
+            type: 'path';
+            pathType: '|';
+            items: (IriTermOrElt)[];
+        }
+    ];
+}
+export interface GroupPattern {
+    type: 'group';
+    patterns: Pattern[];
+}
+export interface GraphPattern {
+    type: 'graph';
+    name: IriTerm | VariableTerm;
+    patterns: Pattern[];
+}
+export interface MinusPattern {
+    type: 'minus';
+    patterns: Pattern[];
+}
+export interface ServicePattern {
+    type: 'service';
+    name: IriTerm | VariableTerm;
+    silent: boolean;
+    patterns: Pattern[];
+}
+export type BlockPattern = OptionalPattern | UnionPattern | GroupPattern | GraphPattern | MinusPattern | ServicePattern;
+export interface OptionalPattern {
+    type: 'optional';
+    patterns: Pattern[];
+}
+export interface UnionPattern {
+    type: 'union';
+    patterns: Pattern[];
+}
+export type ValuePatternRow = Record<string, IriTerm | BlankTerm | LiteralTerm | undefined>;
+export interface FilterPattern {
+    type: 'filter';
+    expression: Expression;
+}
+export interface BindPattern {
+    type: 'bind';
+    expression: Expression;
+    variable: VariableTerm;
+}
+export interface ValuesPattern {
+    type: 'values';
+    values: ValuePatternRow[];
+}
+export interface BaseExpression {
+    type: string;
+    distinct?: boolean | undefined;
+}
+export interface OperationExpression extends BaseExpression {
+    type: 'operation';
+    operator: string;
+    args: (Expression | Pattern)[];
+}
+export interface AggregateExpression extends BaseExpression {
+    type: 'aggregate';
+    expression: Expression | Wildcard;
+    aggregation: string;
+    separator?: string | undefined;
+}

package/lib/Sparql11types.js

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

package/lib/Sparql11types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sparql11types.js","sourceRoot":"","sources":["Sparql11types.ts"],"names":[],"mappings":"","sourcesContent":["import type * as RdfJs from '@rdfjs/types';\nimport type { BlankNode } from 'rdf-data-factory';\nimport type { CommonIRIs } from '@traqula/core';\n\nexport type GraphTerm = IriTerm | BlankTerm | LiteralTerm;\nexport type Term = GraphTerm | VariableTerm;\nexport type VerbA = IriTerm<CommonIRIs.TYPE>;\n\nexport interface Wildcard {\n  readonly termType: 'Wildcard';\n  readonly value: '*';\n  equals: (other: RdfJs.Term | null | undefined) => boolean;\n}\n\nexport type Triple = {\n  subject: Term;\n  predicate: IriTerm | VariableTerm | PropertyPath;\n  object: Term;\n};\n\nexport type TripleCreatorS = (part: Pick<Triple, 'subject'>) => Triple;\nexport type TripleCreatorSP = (part: Pick<Triple, 'subject' | 'predicate'>) => Triple;\n\nexport interface IGraphNode {\n  node: ITriplesNode['node'] | Term;\n  triples: Triple[];\n}\n\nexport interface ITriplesNode {\n  node: IriTerm | BlankNode;\n  triples: Triple[];\n}\n\nexport type Pattern =\n  | BgpPattern\n  | BlockPattern\n  | FilterPattern\n  | BindPattern\n  | ValuesPattern\n  | Omit<SelectQuery, 'prefixes'>;\n\nexport type Expression =\n  | OperationExpression\n  | FunctionCallExpression\n  | AggregateExpression\n  // Used in `IN` operator\n  | Expression[]\n  | IriTerm\n  | VariableTerm\n  | LiteralTerm;\n\nexport interface FunctionCallExpression extends BaseExpression {\n  type: 'functionCall';\n  function: IriTerm;\n  args: Expression[];\n}\n\n/**\n * Basic Graph Pattern\n */\nexport interface BgpPattern {\n  type: 'bgp';\n  triples: Triple[];\n}\n\nexport interface GraphQuads {\n  type: 'graph';\n  name: IriTerm | VariableTerm;\n  triples: Triple[];\n}\n\n// Copied types\nexport interface SparqlParser {\n  parse: (query: string) => SparqlQuery;\n  _resetBlanks: () => void;\n}\n\nexport type VariableTerm = RdfJs.Variable;\nexport type IriTerm<IRI extends string = string> = RdfJs.NamedNode<IRI>;\nexport type LiteralTerm = RdfJs.Literal;\nexport type BlankTerm = RdfJs.BlankNode;\n\nexport type PropertyPath = NegatedPropertySet | {\n  type: 'path';\n  pathType: '|' | '/' | '^' | '+' | '*' | '?';\n  items: (IriTerm | PropertyPath)[];\n};\n\nexport type SparqlQuery = Query | Update | Pick<Update, 'base' | 'prefixes'>;\n\nexport type Query = SelectQuery | ConstructQuery | AskQuery | DescribeQuery;\n\nexport interface SelectQuery extends BaseQuery {\n  queryType: 'SELECT';\n  variables: Variable[] | [Wildcard];\n  distinct?: true | undefined;\n  reduced?: true | undefined;\n  group?: Grouping[] | undefined;\n  having?: Expression[] | undefined;\n  order?: Ordering[] | undefined;\n  limit?: number | undefined;\n  offset?: number | undefined;\n}\n\nexport interface Grouping {\n  expression: Expression;\n  variable?: VariableTerm;\n}\n\nexport interface Ordering {\n  expression: Expression;\n  descending?: true | undefined;\n}\n\nexport interface ConstructQuery extends BaseQuery {\n  queryType: 'CONSTRUCT';\n  template?: Triple[] | undefined;\n}\n\nexport interface AskQuery extends BaseQuery {\n  queryType: 'ASK';\n}\n\nexport interface DescribeQuery extends BaseQuery {\n  queryType: 'DESCRIBE';\n  variables: (VariableTerm | IriTerm)[] | [Wildcard];\n}\n\nexport interface Update {\n  type: 'update';\n  base?: string | undefined;\n  prefixes: Record<string, string>;\n  updates: UpdateOperation[];\n}\n\nexport type UpdateOperation = InsertDeleteOperation | ManagementOperation;\n\nexport type InsertDeleteOperation =\n  | {\n    updateType: 'insert';\n    graph?: GraphOrDefault;\n    insert: Quads[];\n  }\n  | {\n    updateType: 'delete';\n    graph?: GraphOrDefault;\n    delete: Quads[];\n  }\n  | {\n    updateType: 'insertdelete';\n    graph?: IriTerm;\n    insert: Quads[];\n    delete: Quads[];\n    using?: {\n      default: IriTerm[];\n      named: IriTerm[];\n    };\n    where: Pattern[];\n  }\n  | {\n    updateType: 'deletewhere';\n    graph?: GraphOrDefault;\n    delete: Quads[];\n  };\n\nexport type Quads = BgpPattern | GraphQuads;\n\nexport type ManagementOperation =\n  | CopyMoveAddOperation\n  | LoadOperation\n  | CreateOperation\n  | ClearDropOperation;\n\nexport interface CopyMoveAddOperation {\n  type: 'copy' | 'move' | 'add';\n  silent: boolean;\n  source: GraphOrDefault;\n  destination: GraphOrDefault;\n}\n\nexport interface LoadOperation {\n  type: 'load';\n  silent: boolean;\n  source: IriTerm;\n  destination?: IriTerm;\n}\n\nexport interface CreateOperation {\n  type: 'create';\n  silent: boolean;\n  graph: GraphOrDefault;\n}\n\nexport interface ClearDropOperation {\n  type: 'clear' | 'drop';\n  silent: boolean;\n  graph: GraphReference;\n}\n\nexport interface GraphOrDefault {\n  type?: 'graph';\n  name?: IriTerm | undefined;\n  default?: true | undefined;\n}\n\nexport interface GraphReference extends GraphOrDefault {\n  named?: true | undefined;\n  all?: true | undefined;\n}\n\n/**\n * Examples: '?var', '*',\n *   SELECT (?a as ?b) ... ==> { expression: '?a', variable: '?b' }\n */\nexport type Variable = VariableExpression | VariableTerm;\n\nexport interface VariableExpression {\n  expression: Expression;\n  variable: VariableTerm;\n}\n\nexport interface BaseQuery {\n  type: 'query';\n  base?: string | undefined;\n  prefixes: Record<string, string>;\n  from?:\n    | {\n      default: IriTerm[];\n      named: IriTerm[];\n    }\n    | undefined;\n  where?: Pattern[] | undefined;\n  values?: ValuePatternRow[] | undefined;\n}\n\nexport type IriTermOrElt = IriTerm | {\n  type: 'path';\n  pathType: '^';\n  items: [IriTerm];\n};\n\nexport interface NegatedPropertySet {\n  type: 'path';\n  pathType: '!';\n  items: IriTermOrElt[] | [{\n    type: 'path';\n    pathType: '|';\n    items: (IriTermOrElt)[];\n  }];\n}\n\nexport interface GroupPattern {\n  type: 'group';\n  patterns: Pattern[];\n}\n\nexport interface GraphPattern {\n  type: 'graph';\n  name: IriTerm | VariableTerm;\n  patterns: Pattern[];\n}\n\nexport interface MinusPattern {\n  type: 'minus';\n  patterns: Pattern[];\n}\n\nexport interface ServicePattern {\n  type: 'service';\n  name: IriTerm | VariableTerm;\n  silent: boolean;\n  patterns: Pattern[];\n}\n\nexport type BlockPattern =\n  | OptionalPattern\n  | UnionPattern\n  | GroupPattern\n  | GraphPattern\n  | MinusPattern\n  | ServicePattern;\n\nexport interface OptionalPattern {\n  type: 'optional';\n  patterns: Pattern[];\n}\n\nexport interface UnionPattern {\n  type: 'union';\n  patterns: Pattern[];\n}\n\nexport type ValuePatternRow = Record<string, IriTerm | BlankTerm | LiteralTerm | undefined>;\n\nexport interface FilterPattern {\n  type: 'filter';\n  expression: Expression;\n}\n\nexport interface BindPattern {\n  type: 'bind';\n  expression: Expression;\n  variable: VariableTerm;\n}\n\nexport interface ValuesPattern {\n  type: 'values';\n  values: ValuePatternRow[];\n}\n\nexport interface BaseExpression {\n  type: string;\n  distinct?: boolean | undefined;\n}\n\nexport interface OperationExpression extends BaseExpression {\n  type: 'operation';\n  operator: string;\n  args: (Expression | Pattern)[];\n}\n\nexport interface AggregateExpression extends BaseExpression {\n  type: 'aggregate';\n  expression: Expression | Wildcard;\n  aggregation: string;\n  separator?: string | undefined;\n}\n"]}

package/lib/expressionHelpers.d.ts

@@ -0,0 +1,55 @@
+import type { TokenType } from 'chevrotain';
+import { Wildcard } from '@traqula/core';
+import type { RuleDef } from '@traqula/core';
+import type { Expression, Pattern, VariableTerm } from './Sparql11types';
+export interface IExpressionFunctionX<U extends (Expression | Pattern)[]> {
+    type: 'operation';
+    operator: string;
+    args: U;
+}
+export type RuleDefExpressionFunctionX<T extends string, U extends (Expression | Pattern)[]> = RuleDef<T, IExpressionFunctionX<U>>;
+export declare function funcExpr1<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, [Expression]>;
+export declare function funcExpr2<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, [Expression, Expression]>;
+export declare function funcExpr3<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, [Expression, Expression, Expression]>;
+export declare function funcVar1<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, [VariableTerm]>;
+export declare function funcExprOrNil1<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, [] | [Expression]>;
+export declare function funcNil1<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, []>;
+export declare function funcExprList1<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, Expression[]>;
+export declare function funcExpr2or3<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, [Expression, Expression] | [Expression, Expression, Expression]>;
+export declare function funcExpr3or4<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, [
+    Expression,
+    Expression,
+    Expression
+] | [Expression, Expression, Expression, Expression]>;
+export declare function funcGroupGraphPattern<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, Pattern[]>;
+export interface IExpressionAggregator {
+    type: 'aggregate';
+    distinct: boolean;
+    expression: Expression | Wildcard;
+    aggregation: string;
+    separator?: string;
+}
+export type RuleDefExpressionAggregatorX<T extends string> = RuleDef<T, IExpressionAggregator>;
+export declare function baseAggregateFunc<T extends string>(func: TokenType & {
+    name: T;
+}): RuleDefExpressionAggregatorX<Uncapitalize<T>>;

package/lib/expressionHelpers.js

@@ -0,0 +1,224 @@
+import * as l from './lexer';
+import { Wildcard } from '@traqula/core';
+import { expression, expressionList } from './grammar/expression';
+import { var_ } from './grammar/general';
+import { groupGraphPattern } from './grammar/whereClause';
+import { unCapitalize } from '@traqula/core';
+import { deGroupSingle } from './utils';
+function formatOperator(operator) {
+    return operator.toLowerCase().replaceAll(' ', '');
+}
+export function funcExpr1(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ SUBRULE, CONSUME }) => () => {
+            const operator = CONSUME(func);
+            CONSUME(l.symbols.LParen);
+            const arg = SUBRULE(expression);
+            CONSUME(l.symbols.RParen);
+            return {
+                type: 'operation',
+                operator: formatOperator(operator.image),
+                args: [arg],
+            };
+        },
+    };
+}
+export function funcExpr2(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ SUBRULE1, SUBRULE2, CONSUME }) => () => {
+            const operator = CONSUME(func);
+            CONSUME(l.symbols.LParen);
+            const arg1 = SUBRULE1(expression);
+            CONSUME(l.symbols.comma);
+            const arg2 = SUBRULE2(expression);
+            CONSUME(l.symbols.RParen);
+            return {
+                type: 'operation',
+                operator: formatOperator(operator.image),
+                args: [arg1, arg2],
+            };
+        },
+    };
+}
+export function funcExpr3(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ SUBRULE1, SUBRULE2, SUBRULE3, CONSUME, CONSUME1, CONSUME2 }) => () => {
+            const operator = CONSUME(func);
+            CONSUME(l.symbols.LParen);
+            const arg1 = SUBRULE1(expression);
+            CONSUME1(l.symbols.comma);
+            const arg2 = SUBRULE2(expression);
+            CONSUME2(l.symbols.comma);
+            const arg3 = SUBRULE3(expression);
+            CONSUME(l.symbols.RParen);
+            return {
+                type: 'operation',
+                operator: formatOperator(operator.image),
+                args: [arg1, arg2, arg3],
+            };
+        },
+    };
+}
+export function funcVar1(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ SUBRULE, CONSUME }) => () => {
+            const operator = CONSUME(func);
+            CONSUME(l.symbols.LParen);
+            const arg = SUBRULE(var_);
+            CONSUME(l.symbols.RParen);
+            return {
+                type: 'operation',
+                operator: formatOperator(operator.image),
+                args: [arg],
+            };
+        },
+    };
+}
+export function funcExprOrNil1(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ CONSUME, OR, SUBRULE }) => () => {
+            const operator = CONSUME(func);
+            const args = OR([
+                {
+                    ALT: () => {
+                        CONSUME(l.symbols.LParen);
+                        const arg = SUBRULE(expression);
+                        CONSUME(l.symbols.RParen);
+                        return [arg];
+                    },
+                },
+                {
+                    ALT: () => {
+                        CONSUME(l.terminals.nil);
+                        return [];
+                    },
+                },
+            ]);
+            return {
+                type: 'operation',
+                operator: formatOperator(operator.image),
+                args,
+            };
+        },
+    };
+}
+export function funcNil1(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ CONSUME }) => () => {
+            const operator = CONSUME(func);
+            CONSUME(l.terminals.nil);
+            return {
+                type: 'operation',
+                operator: formatOperator(operator.image),
+                args: [],
+            };
+        },
+    };
+}
+export function funcExprList1(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ CONSUME, SUBRULE }) => () => {
+            const operator = CONSUME(func);
+            const args = SUBRULE(expressionList);
+            return {
+                type: 'operation',
+                operator: formatOperator(operator.image),
+                args,
+            };
+        },
+    };
+}
+export function funcExpr2or3(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, CONSUME1, OPTION, CONSUME2 }) => () => {
+            const operator = CONSUME(func);
+            CONSUME(l.symbols.LParen);
+            const arg1 = SUBRULE1(expression);
+            CONSUME1(l.symbols.comma);
+            const arg2 = SUBRULE2(expression);
+            const arg3 = OPTION(() => {
+                CONSUME2(l.symbols.comma);
+                return SUBRULE3(expression);
+            });
+            CONSUME(l.symbols.RParen);
+            return {
+                type: 'operation',
+                operator: formatOperator(operator.image),
+                args: arg3 ? [arg1, arg2, arg3] : [arg1, arg2],
+            };
+        },
+    };
+}
+export function funcExpr3or4(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, CONSUME1, OPTION, CONSUME2, SUBRULE4, CONSUME3 }) => () => {
+            const operator = CONSUME(func);
+            CONSUME(l.symbols.LParen);
+            const arg1 = SUBRULE1(expression);
+            CONSUME1(l.symbols.comma);
+            const arg2 = SUBRULE2(expression);
+            CONSUME2(l.symbols.comma);
+            const arg3 = SUBRULE3(expression);
+            const arg4 = OPTION(() => {
+                CONSUME3(l.symbols.comma);
+                return SUBRULE4(expression);
+            });
+            CONSUME(l.symbols.RParen);
+            return {
+                type: 'operation',
+                operator: formatOperator(operator.image),
+                args: arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3],
+            };
+        },
+    };
+}
+export function funcGroupGraphPattern(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ ACTION, SUBRULE, CONSUME }) => () => {
+            const operator = CONSUME(func);
+            const group = SUBRULE(groupGraphPattern);
+            return ACTION(() => ({
+                type: 'operation',
+                operator: formatOperator(operator.image),
+                args: [deGroupSingle(group)],
+            }));
+        },
+    };
+}
+export function baseAggregateFunc(func) {
+    return {
+        name: unCapitalize(func.name),
+        impl: ({ CONSUME, SUBRULE, OPTION, OR }) => () => {
+            const operator = CONSUME(func);
+            CONSUME(l.symbols.LParen);
+            const distinct = OPTION(() => CONSUME(l.distinct));
+            const expressionVal = OR([
+                {
+                    ALT: () => {
+                        CONSUME(l.symbols.star);
+                        return new Wildcard();
+                    },
+                },
+                { ALT: () => SUBRULE(expression) },
+            ]);
+            CONSUME(l.symbols.RParen);
+            return {
+                type: 'aggregate',
+                aggregation: operator.image.toLowerCase(),
+                expression: expressionVal,
+                distinct: Boolean(distinct),
+            };
+        },
+    };
+}
+//# sourceMappingURL=expressionHelpers.js.map

package/lib/expressionHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressionHelpers.js","sourceRoot":"","sources":["expressionHelpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { TokenType } from 'chevrotain';\nimport * as l from './lexer';\nimport { Wildcard } from '@traqula/core';\nimport type { RuleDef } from '@traqula/core';\nimport { expression, expressionList } from './grammar/expression';\nimport { var_ } from './grammar/general';\nimport type { Expression, Pattern, VariableTerm } from './Sparql11types';\nimport { groupGraphPattern } from './grammar/whereClause';\nimport { unCapitalize } from '@traqula/core';\nimport { deGroupSingle } from './utils';\n\nexport interface IExpressionFunctionX<U extends (Expression | Pattern)[]> {\n  type: 'operation';\n  operator: string;\n  args: U;\n}\n\nexport type RuleDefExpressionFunctionX<T extends string, U extends (Expression | Pattern)[]>\n  = RuleDef<T, IExpressionFunctionX<U>>;\n\nfunction formatOperator(operator: string): string {\n  return operator.toLowerCase().replaceAll(' ', '');\n}\n\nexport function funcExpr1<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionFunctionX<Uncapitalize<T>, [Expression]> {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ SUBRULE, CONSUME }) => () => {\n      const operator = CONSUME(func);\n      CONSUME(l.symbols.LParen);\n      const arg = SUBRULE(expression);\n      CONSUME(l.symbols.RParen);\n      return {\n        type: 'operation',\n        operator: formatOperator(operator.image),\n        args: [ arg ],\n      };\n    },\n  };\n}\n\nexport function funcExpr2<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionFunctionX<Uncapitalize<T>, [Expression, Expression]> {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ SUBRULE1, SUBRULE2, CONSUME }) => () => {\n      const operator = CONSUME(func);\n      CONSUME(l.symbols.LParen);\n      const arg1 = SUBRULE1(expression);\n      CONSUME(l.symbols.comma);\n      const arg2 = SUBRULE2(expression);\n      CONSUME(l.symbols.RParen);\n      return {\n        type: 'operation',\n        operator: formatOperator(operator.image),\n        args: [ arg1, arg2 ],\n      };\n    },\n  };\n}\n\nexport function funcExpr3<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionFunctionX<Uncapitalize<T>, [Expression, Expression, Expression]> {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ SUBRULE1, SUBRULE2, SUBRULE3, CONSUME, CONSUME1, CONSUME2 }) => () => {\n      const operator = CONSUME(func);\n      CONSUME(l.symbols.LParen);\n      const arg1 = SUBRULE1(expression);\n      CONSUME1(l.symbols.comma);\n      const arg2 = SUBRULE2(expression);\n      CONSUME2(l.symbols.comma);\n      const arg3 = SUBRULE3(expression);\n      CONSUME(l.symbols.RParen);\n      return {\n        type: 'operation',\n        operator: formatOperator(operator.image),\n        args: [ arg1, arg2, arg3 ],\n      };\n    },\n  };\n}\n\nexport function funcVar1<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionFunctionX<Uncapitalize<T>, [VariableTerm]> {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ SUBRULE, CONSUME }) => () => {\n      const operator = CONSUME(func);\n      CONSUME(l.symbols.LParen);\n      const arg = SUBRULE(var_);\n      CONSUME(l.symbols.RParen);\n      return {\n        type: 'operation',\n        operator: formatOperator(operator.image),\n        args: [ arg ],\n      };\n    },\n  };\n}\n\nexport function funcExprOrNil1<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionFunctionX<Uncapitalize<T>, [] | [Expression]> {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ CONSUME, OR, SUBRULE }) => () => {\n      const operator = CONSUME(func);\n      const args = OR<[] | [Expression]>([\n        {\n          ALT: () => {\n            CONSUME(l.symbols.LParen);\n            const arg = SUBRULE(expression);\n            CONSUME(l.symbols.RParen);\n            return [ arg ];\n          },\n        },\n        {\n          ALT: () => {\n            CONSUME(l.terminals.nil);\n            return [];\n          },\n        },\n      ]);\n      return {\n        type: 'operation',\n        operator: formatOperator(operator.image),\n        args,\n      };\n    },\n  };\n}\n\nexport function funcNil1<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionFunctionX<Uncapitalize<T>, []> {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ CONSUME }) => () => {\n      const operator = CONSUME(func);\n      CONSUME(l.terminals.nil);\n      return {\n        type: 'operation',\n        operator: formatOperator(operator.image),\n        args: [],\n      };\n    },\n  };\n}\n\nexport function funcExprList1<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionFunctionX<Uncapitalize<T>, Expression[]> {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ CONSUME, SUBRULE }) => () => {\n      const operator = CONSUME(func);\n      const args = SUBRULE(expressionList);\n      return {\n        type: 'operation',\n        operator: formatOperator(operator.image),\n        args,\n      };\n    },\n  };\n}\n\nexport function funcExpr2or3<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionFunctionX<Uncapitalize<T>, [Expression, Expression] | [Expression, Expression, Expression]> {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, CONSUME1, OPTION, CONSUME2 }) => () => {\n      const operator = CONSUME(func);\n      CONSUME(l.symbols.LParen);\n      const arg1 = SUBRULE1(expression);\n      CONSUME1(l.symbols.comma);\n      const arg2 = SUBRULE2(expression);\n      const arg3 = OPTION(() => {\n        CONSUME2(l.symbols.comma);\n        return SUBRULE3(expression);\n      });\n      CONSUME(l.symbols.RParen);\n      return {\n        type: 'operation',\n        operator: formatOperator(operator.image),\n        args: arg3 ? [ arg1, arg2, arg3 ] : [ arg1, arg2 ],\n      };\n    },\n  };\n}\n\nexport function funcExpr3or4<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionFunctionX<\n    Uncapitalize<T>,\n    [Expression, Expression, Expression] | [Expression, Expression, Expression, Expression]\n  > {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, CONSUME1, OPTION, CONSUME2, SUBRULE4, CONSUME3 }) => () => {\n      const operator = CONSUME(func);\n      CONSUME(l.symbols.LParen);\n      const arg1 = SUBRULE1(expression);\n      CONSUME1(l.symbols.comma);\n      const arg2 = SUBRULE2(expression);\n      CONSUME2(l.symbols.comma);\n      const arg3 = SUBRULE3(expression);\n      const arg4 = OPTION(() => {\n        CONSUME3(l.symbols.comma);\n        return SUBRULE4(expression);\n      });\n      CONSUME(l.symbols.RParen);\n      return {\n        type: 'operation',\n        operator: formatOperator(operator.image),\n        args: arg4 ? [ arg1, arg2, arg3, arg4 ] : [ arg1, arg2, arg3 ],\n      };\n    },\n  };\n}\n\nexport function funcGroupGraphPattern<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionFunctionX<\n    Uncapitalize<T>,\n    Pattern[]\n  > {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ ACTION, SUBRULE, CONSUME }) => () => {\n      const operator = CONSUME(func);\n      const group = SUBRULE(groupGraphPattern);\n      return ACTION(() => ({\n        type: 'operation',\n        operator: formatOperator(operator.image),\n        args: [ deGroupSingle(group) ],\n      }));\n    },\n  };\n}\n\nexport interface IExpressionAggregator {\n  type: 'aggregate';\n  distinct: boolean;\n  expression: Expression | Wildcard;\n  aggregation: string;\n  separator?: string;\n}\n\nexport type RuleDefExpressionAggregatorX<T extends string> = RuleDef<T, IExpressionAggregator>;\n\nexport function baseAggregateFunc<T extends string>(func: TokenType & { name: T }):\nRuleDefExpressionAggregatorX<Uncapitalize<T>> {\n  return {\n    name: unCapitalize(func.name),\n    impl: ({ CONSUME, SUBRULE, OPTION, OR }) => () => {\n      const operator = CONSUME(func);\n      CONSUME(l.symbols.LParen);\n      const distinct = OPTION(() => CONSUME(l.distinct));\n      const expressionVal = OR<Expression | Wildcard>([\n        {\n          ALT: () => {\n            CONSUME(l.symbols.star);\n            return new Wildcard();\n          },\n        },\n        { ALT: () => SUBRULE(expression) },\n      ]);\n      CONSUME(l.symbols.RParen);\n      return {\n        type: 'aggregate',\n        aggregation: operator.image.toLowerCase(),\n        expression: expressionVal,\n        distinct: Boolean(distinct),\n      };\n    },\n  };\n}\n"]}