@traqula/rules-sparql-1-1 0.0.1-alpha.148 → 0.0.1-alpha.9

package/lib/Sparql11types.d.ts

@@ -1,245 +1,36 @@
-import type * as RdfJs from '@rdfjs/types';
-import type * as RDF from '@rdfjs/types';
-import type { BlankNode, DataFactory } from 'rdf-data-factory';
-import type { CommonIRIs, RuleDef } 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 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[];
-}
+import type { GeneratorRule, ParserRule } from '@traqula/core';
+import type { Factory } from './factory';
+export type SparqlRule<
 /**
- * Basic Graph Pattern
+ * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.
  */
-export interface BgpPattern {
-    type: 'bgp';
-    triples: Triple[];
-}
-export interface GraphQuads {
-    type: 'graph';
-    name: IriTerm | VariableTerm;
-    triples: Triple[];
-}
-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;
-}
+NameType extends string = string, 
 /**
- * Examples: '?var', '*',
- *   SELECT (?a as ?b) ... ==> { expression: '?a', variable: '?b' }
+ * Type that will be returned after a correct parse of this rule.
+ * This type will be the return type of calling SUBRULE with this grammar rule.
  */
-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;
-}
-export type SparqlRuleDef<
+ReturnType = unknown, GenInputType = ReturnType, 
+/**
+ * Function arguments that can be given to convey the state of the current parse operation.
+ */
+ParamType = undefined> = SparqlGrammarRule<NameType, ReturnType, ParamType> & SparqlGeneratorRule<NameType, GenInputType, ParamType>;
+export type SparqlGeneratorRule<
+/**
+ * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.
+ */
+NameType extends string = string, 
+/**
+ * Type that will be returned after a correct parse of this rule.
+ * This type will be the return type of calling SUBRULE with this grammar rule.
+ */
+ReturnType = unknown, 
+/**
+ * Function arguments that can be given to convey the state of the current parse operation.
+ */
+ParamType = undefined> = GeneratorRule<{
+    factory: Factory;
+}, NameType, ReturnType, ParamType>;
+export type SparqlGrammarRule<
 /**
  * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.
  */
@@ -252,12 +43,12 @@ ReturnType = unknown,
 /**
  * Function arguments that can be given to convey the state of the current parse operation.
  */
-ParamType = undefined> = RuleDef<SparqlContext, NameType, ReturnType, ParamType>;
+ParamType = undefined> = ParserRule<SparqlContext, NameType, ReturnType, ParamType>;
 export interface SparqlContext {
     /**
-     * Data-factory to be used when constructing rdf primitives.
+     * Data-factoryMixins to be used when constructing rdf primitives.
      */
-    dataFactory: DataFactory<RDF.BaseQuad>;
+    factory: Factory;
     /**
      * Current scoped prefixes. Used for resolving prefixed names.
      */

package/lib/Sparql11types.js.map

@@ -1 +1 @@
-{"version":3,"file":"Sparql11types.js","sourceRoot":"","sources":["Sparql11types.ts"],"names":[],"mappings":"","sourcesContent":["import type * as RdfJs from '@rdfjs/types';\nimport type * as RDF from '@rdfjs/types';\nimport type {BlankNode, DataFactory} from 'rdf-data-factory';\nimport type {CommonIRIs, RuleDef} 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 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\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\nexport type SparqlRuleDef<\n  /**\n   * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.\n   */\n  NameType extends string = string,\n  /**\n   * Type that will be returned after a correct parse of this rule.\n   * This type will be the return type of calling SUBRULE with this grammar rule.\n   */\n  ReturnType = unknown,\n  /**\n   * Function arguments that can be given to convey the state of the current parse operation.\n   */\n  ParamType = undefined,\n> = RuleDef<SparqlContext, NameType, ReturnType, ParamType>;\n\nexport interface SparqlContext {\n  /**\n   * Data-factory to be used when constructing rdf primitives.\n   */\n  dataFactory: DataFactory<RDF.BaseQuad>;\n  /**\n   * Current scoped prefixes. Used for resolving prefixed names.\n   */\n  prefixes: Record<string, string>;\n  /**\n   * The base IRI for the query. Used for resolving relative IRIs.\n   */\n  baseIRI: string | undefined;\n  /**\n   * Can be used to disable the validation that used variables in a select clause are in scope.\n   */\n  skipValidation: boolean;\n  /**\n   * Set of queryModes. Primarily used for note 8, 14.\n   */\n  parseMode: Set<'canParseVars' | 'canCreateBlankNodes' | 'inAggregate' | 'canParseAggregate' | string>;\n}"]}
+{"version":3,"file":"Sparql11types.js","sourceRoot":"","sources":["Sparql11types.ts"],"names":[],"mappings":"","sourcesContent":["import type { GeneratorRule, ParserRule } from '@traqula/core';\nimport type { Factory } from './factory';\n\nexport type SparqlRule<\n  /**\n   * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.\n   */\n  NameType extends string = string,\n  /**\n   * Type that will be returned after a correct parse of this rule.\n   * This type will be the return type of calling SUBRULE with this grammar rule.\n   */\n  ReturnType = unknown,\n  GenInputType = ReturnType,\n  /**\n   * Function arguments that can be given to convey the state of the current parse operation.\n   */\n  ParamType = undefined,\n> = SparqlGrammarRule<NameType, ReturnType, ParamType>\n  & SparqlGeneratorRule<NameType, GenInputType, ParamType>;\n\nexport type SparqlGeneratorRule<\n  /**\n   * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.\n   */\n  NameType extends string = string,\n  /**\n   * Type that will be returned after a correct parse of this rule.\n   * This type will be the return type of calling SUBRULE with this grammar rule.\n   */\n  ReturnType = unknown,\n  /**\n   * Function arguments that can be given to convey the state of the current parse operation.\n   */\n  ParamType = undefined,\n> = GeneratorRule<{ factory: Factory }, NameType, ReturnType, ParamType>;\n\nexport type SparqlGrammarRule<\n  /**\n   * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.\n   */\n  NameType extends string = string,\n  /**\n   * Type that will be returned after a correct parse of this rule.\n   * This type will be the return type of calling SUBRULE with this grammar rule.\n   */\n  ReturnType = unknown,\n  /**\n   * Function arguments that can be given to convey the state of the current parse operation.\n   */\n  ParamType = undefined,\n> = ParserRule<SparqlContext, NameType, ReturnType, ParamType>;\n\nexport interface SparqlContext {\n  /**\n   * Data-factoryMixins to be used when constructing rdf primitives.\n   */\n  factory: Factory;\n  /**\n   * Current scoped prefixes. Used for resolving prefixed names.\n   */\n  prefixes: Record<string, string>;\n  /**\n   * The base IRI for the query. Used for resolving relative IRIs.\n   */\n  baseIRI: string | undefined;\n  /**\n   * Can be used to disable the validation that used variables in a select clause are in scope.\n   */\n  skipValidation: boolean;\n  /**\n   * Set of queryModes. Primarily used for note 8, 14.\n   */\n  parseMode: Set<'canParseVars' | 'canCreateBlankNodes' | 'inAggregate' | 'canParseAggregate' | string>;\n}\n"]}

package/lib/SparqlParser.d.ts

@@ -1,14 +1,23 @@
-import { IriTerm, PropertyPath, SparqlContext } from "./Sparql11types";
+import type { Path, TermIri } from './RoundTripTypes';
+import type { SparqlContext } from './Sparql11types';
 interface Parser<ParseRet> {
     queryOrUpdate: (input: string, context: SparqlContext, arg: undefined) => ParseRet;
-    path: (input: string, context: SparqlContext, arg: undefined) => IriTerm | PropertyPath;
+    path: (input: string, context: SparqlContext, arg: undefined) => TermIri | Path;
 }
+export declare function completeParseContext(context: Partial<SparqlContext & {
+    origSource: string;
+    offset?: number;
+}>): SparqlContext & {
+    origSource: string;
+    offset?: number;
+};
 export declare class SparqlParser<ParseRet> {
-    private parser;
+    private readonly parser;
     constructor(parser: Parser<ParseRet>);
+    private readonly F;
     parse(query: string, context?: Partial<SparqlContext>): ParseRet;
-    parsePath(query: string, context?: Partial<SparqlContext>): (PropertyPath & {
+    parsePath(query: string, context?: Partial<SparqlContext>): (Path & {
         prefixes: object;
-    }) | IriTerm;
+    }) | TermIri;
 }
 export {};

package/lib/SparqlParser.js

@@ -1,9 +1,11 @@
-import { DataFactory } from "rdf-data-factory";
-function completeParseContext(context) {
+import { Factory } from './factory';
+export function completeParseContext(context) {
     return {
-        dataFactory: context.dataFactory ?? new DataFactory({ blankNodePrefix: 'g_' }),
+        factory: context.factory ?? new Factory(),
         baseIRI: context.baseIRI,
         prefixes: { ...context.prefixes },
+        origSource: context.origSource ?? '',
+        offset: context.offset,
         parseMode: context.parseMode ? new Set(context.parseMode) : new Set(['canParseVars', 'canCreateBlankNodes']),
         skipValidation: context.skipValidation ?? false,
     };
@@ -11,13 +13,14 @@ function completeParseContext(context) {
 export class SparqlParser {
     constructor(parser) {
         this.parser = parser;
+        this.F = new Factory();
     }
     parse(query, context = {}) {
         return this.parser.queryOrUpdate(query, completeParseContext(context), undefined);
     }
     parsePath(query, context = {}) {
         const result = this.parser.path(query, completeParseContext(context), undefined);
-        if ('type' in result) {
+        if (this.F.isPathPure(result)) {
             return {
                 ...result,
                 prefixes: {},

package/lib/SparqlParser.js.map

@@ -1 +1 @@
-{"version":3,"file":"SparqlParser.js","sourceRoot":"","sources":["SparqlParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAQ7C,SAAS,oBAAoB,CAAC,OAA+B;IAC3D,OAAO;QACL,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,IAAI,WAAW,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC;QAC9E,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE;QACjC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAE,cAAc,EAAE,qBAAqB,CAAE,CAAC;QAC9G,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,KAAK;KAChD,CAAC;AACJ,CAAC;AAED,MAAM,OAAO,YAAY;IACvB,YAA2B,MAAwB;QAAxB,WAAM,GAAN,MAAM,CAAkB;IAAI,CAAC;IAEjD,KAAK,CAAC,KAAa,EAAE,UAAkC,EAAE;QAC9D,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC;IACpF,CAAC;IAEM,SAAS,CAAC,KAAa,EAAE,UAAkC,EAAE;QAClE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC;QACjF,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;YACrB,OAAO;gBACL,GAAG,MAAM;gBACT,QAAQ,EAAE,EAAE;aACb,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF","sourcesContent":["import {DataFactory} from \"rdf-data-factory\";\nimport {IriTerm, PropertyPath, SparqlContext} from \"./Sparql11types\";\n\ninterface Parser<ParseRet> {\n  queryOrUpdate: (input: string, context: SparqlContext, arg: undefined) => ParseRet;\n  path: (input: string, context: SparqlContext, arg: undefined) => IriTerm | PropertyPath;\n}\n\nfunction completeParseContext(context: Partial<SparqlContext>): SparqlContext {\n  return {\n    dataFactory: context.dataFactory ?? new DataFactory({ blankNodePrefix: 'g_' }),\n    baseIRI: context.baseIRI,\n    prefixes: { ...context.prefixes },\n    parseMode: context.parseMode ? new Set(context.parseMode) : new Set([ 'canParseVars', 'canCreateBlankNodes' ]),\n    skipValidation: context.skipValidation ?? false,\n  };\n}\n\nexport class SparqlParser<ParseRet> {\n  public constructor(private parser: Parser<ParseRet>) { }\n\n  public parse(query: string, context: Partial<SparqlContext> = {}): ParseRet {\n    return this.parser.queryOrUpdate(query, completeParseContext(context), undefined);\n  }\n\n  public parsePath(query: string, context: Partial<SparqlContext> = {}): (PropertyPath & { prefixes: object }) | IriTerm {\n    const result = this.parser.path(query, completeParseContext(context), undefined);\n    if ('type' in result) {\n      return {\n        ...result,\n        prefixes: {},\n      };\n    }\n    return result;\n  }\n}\n"]}
+{"version":3,"file":"SparqlParser.js","sourceRoot":"","sources":["SparqlParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,MAAM,UAAU,oBAAoB,CAClC,OAAyE;IAEzE,OAAO;QACL,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,IAAI,OAAO,EAAE;QACzC,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE;QACjC,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,EAAE;QACpC,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAE,cAAc,EAAE,qBAAqB,CAAE,CAAC;QAC9G,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,KAAK;KAChD,CAAC;AACJ,CAAC;AAED,MAAM,OAAO,YAAY;IACvB,YAAoC,MAAwB;QAAxB,WAAM,GAAN,MAAM,CAAkB;QAC3C,MAAC,GAAG,IAAI,OAAO,EAAE,CAAC;IAD4B,CAAC;IAGzD,KAAK,CAAC,KAAa,EAAE,UAAkC,EAAE;QAC9D,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC;IACpF,CAAC;IAEM,SAAS,CAAC,KAAa,EAAE,UAAkC,EAAE;QAElE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC;QACjF,IAAI,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC9B,OAAO;gBACL,GAAG,MAAM;gBACT,QAAQ,EAAE,EAAE;aACb,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF","sourcesContent":["import { Factory } from './factory';\nimport type { Path, TermIri } from './RoundTripTypes';\nimport type { SparqlContext } from './Sparql11types';\n\ninterface Parser<ParseRet> {\n  queryOrUpdate: (input: string, context: SparqlContext, arg: undefined) => ParseRet;\n  path: (input: string, context: SparqlContext, arg: undefined) => TermIri | Path;\n}\n\nexport function completeParseContext(\n  context: Partial<SparqlContext & { origSource: string; offset?: number }>,\n): SparqlContext & { origSource: string; offset?: number } {\n  return {\n    factory: context.factory ?? new Factory(),\n    baseIRI: context.baseIRI,\n    prefixes: { ...context.prefixes },\n    origSource: context.origSource ?? '',\n    offset: context.offset,\n    parseMode: context.parseMode ? new Set(context.parseMode) : new Set([ 'canParseVars', 'canCreateBlankNodes' ]),\n    skipValidation: context.skipValidation ?? false,\n  };\n}\n\nexport class SparqlParser<ParseRet> {\n  public constructor(private readonly parser: Parser<ParseRet>) {}\n  private readonly F = new Factory();\n\n  public parse(query: string, context: Partial<SparqlContext> = {}): ParseRet {\n    return this.parser.queryOrUpdate(query, completeParseContext(context), undefined);\n  }\n\n  public parsePath(query: string, context: Partial<SparqlContext> = {}):\n    (Path & { prefixes: object }) | TermIri {\n    const result = this.parser.path(query, completeParseContext(context), undefined);\n    if (this.F.isPathPure(result)) {\n      return {\n        ...result,\n        prefixes: {},\n      };\n    }\n    return result;\n  }\n}\n"]}

package/lib/expressionHelpers.d.ts

@@ -1,12 +1,10 @@
 import type { TokenType } from 'chevrotain';
-import { Wildcard } from '@traqula/core';
-import type { Expression, Pattern, SparqlRuleDef, VariableTerm } from './Sparql11types';
-export interface IExpressionFunctionX<U extends (Expression | Pattern)[]> {
-    type: 'operation';
-    operator: string;
+import type { Expression, ExpressionAggregateDefault, ExpressionOperation, ExpressionPatternOperation, TermVariable } from './RoundTripTypes';
+import type { SparqlGrammarRule } from './Sparql11types';
+export type ExpressionFunctionX<U extends Expression[]> = ExpressionOperation & {
     args: U;
-}
-export type RuleDefExpressionFunctionX<T extends string, U extends (Expression | Pattern)[]> = SparqlRuleDef<T, IExpressionFunctionX<U>>;
+};
+export type RuleDefExpressionFunctionX<T extends string, U extends Expression[]> = SparqlGrammarRule<T, ExpressionFunctionX<U>>;
 export declare function funcExpr1<T extends string>(func: TokenType & {
     name: T;
 }): RuleDefExpressionFunctionX<Uncapitalize<T>, [Expression]>;
@@ -18,7 +16,7 @@ export declare function funcExpr3<T extends string>(func: TokenType & {
 }): RuleDefExpressionFunctionX<Uncapitalize<T>, [Expression, Expression, Expression]>;
 export declare function funcVar1<T extends string>(func: TokenType & {
     name: T;
-}): RuleDefExpressionFunctionX<Uncapitalize<T>, [VariableTerm]>;
+}): RuleDefExpressionFunctionX<Uncapitalize<T>, [TermVariable]>;
 export declare function funcExprOrNil1<T extends string>(func: TokenType & {
     name: T;
 }): RuleDefExpressionFunctionX<Uncapitalize<T>, [] | [Expression]>;
@@ -40,15 +38,8 @@ export declare function funcExpr3or4<T extends string>(func: TokenType & {
 ] | [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> = SparqlRuleDef<T, IExpressionAggregator>;
+}): SparqlGrammarRule<Uncapitalize<T>, ExpressionPatternOperation>;
+export type RuleDefExpressionAggregatorX<T extends string> = SparqlGrammarRule<T, ExpressionAggregateDefault>;
 export declare function baseAggregateFunc<T extends string>(func: TokenType & {
     name: T;
 }): RuleDefExpressionAggregatorX<Uncapitalize<T>>;