@traqula/rules-sparql-1-1 0.0.2 → 0.0.4

package/README.md

@@ -1,7 +1,5 @@
 # Traqula Rules SPARQL 1.1
 
-**WARNING:** V2 will come shortly and will have lots of breaking changes.
-
 Traqula rules SPARQL 1.1 contains rules required for creating a parser for SPARQL 1.1.
 
 ## Installation

package/lib/Sparql11types.d.ts

@@ -1,68 +1,379 @@
-import type { GeneratorRule, ParserRule } from '@traqula/core';
-import type { Factory } from './factory';
-export type SparqlRule<
+import type { Localized, Node } from '@traqula/core';
+export type Sparql11Nodes = GraphRef | UpdateOperation | Update | Query | DatasetClauses | TripleCollection | TripleNesting | Pattern | SolutionModifier | Expression | Path | ContextDefinition | Wildcard | Term;
+export type GraphRefBase = Node & {
+    type: 'graphRef';
+    subType: string;
+};
+export type GraphRefDefault = GraphRefBase & {
+    subType: 'default';
+};
+export type GraphRefNamed = GraphRefBase & {
+    subType: 'named';
+};
+export type GraphRefAll = GraphRefBase & {
+    subType: 'all';
+};
+export type GraphRefSpecific = GraphRefBase & {
+    subType: 'specific';
+    graph: TermIri;
+};
+export type GraphRef = GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific;
+export type Quads = PatternBgp | GraphQuads;
+export type GraphQuads = Node & {
+    type: 'graph';
+    graph: TermIri | TermVariable;
+    triples: PatternBgp;
+};
+export type UpdateOperationBase = Node & {
+    type: 'updateOperation';
+    subType: string;
+};
+export type UpdateOperationLoad = UpdateOperationBase & {
+    subType: 'load';
+    silent: boolean;
+    source: TermIri;
+    destination?: GraphRefSpecific;
+};
+type UpdateOperationClearDropCreateBase = UpdateOperationBase & {
+    subType: 'clear' | 'drop' | 'create';
+    silent: boolean;
+    destination: GraphRef;
+};
+export type UpdateOperationClear = UpdateOperationClearDropCreateBase & {
+    subType: 'clear';
+};
+export type UpdateOperationDrop = UpdateOperationClearDropCreateBase & {
+    subType: 'drop';
+};
+export type UpdateOperationCreate = UpdateOperationClearDropCreateBase & {
+    subType: 'create';
+    destination: GraphRefSpecific;
+};
+type UpdateOperationAddMoveCopy = UpdateOperationBase & {
+    subType: 'add' | 'move' | 'copy';
+    silent: boolean;
+    source: GraphRefDefault | GraphRefSpecific;
+    destination: GraphRefDefault | GraphRefSpecific;
+};
+export type UpdateOperationAdd = UpdateOperationAddMoveCopy & {
+    subType: 'add';
+};
+export type UpdateOperationMove = UpdateOperationAddMoveCopy & {
+    subType: 'move';
+};
+export type UpdateOperationCopy = UpdateOperationAddMoveCopy & {
+    subType: 'copy';
+};
+type UpdateOperationInsertDeleteDelWhere = UpdateOperationBase & {
+    subType: 'insertdata' | 'deletedata' | 'deletewhere';
+    data: Quads[];
+};
+export type UpdateOperationInsertData = UpdateOperationInsertDeleteDelWhere & {
+    subType: 'insertdata';
+};
+export type UpdateOperationDeleteData = UpdateOperationInsertDeleteDelWhere & {
+    subType: 'deletedata';
+};
+export type UpdateOperationDeleteWhere = UpdateOperationInsertDeleteDelWhere & {
+    subType: 'deletewhere';
+};
+export type UpdateOperationModify = UpdateOperationBase & {
+    subType: 'modify';
+    graph: TermIri | undefined;
+    insert: Quads[];
+    delete: Quads[];
+    from: DatasetClauses;
+    where: PatternGroup;
+};
+export type UpdateOperation = UpdateOperationLoad | UpdateOperationClear | UpdateOperationDrop | UpdateOperationCreate | UpdateOperationAdd | UpdateOperationMove | UpdateOperationCopy | UpdateOperationInsertData | UpdateOperationDeleteData | UpdateOperationDeleteWhere | UpdateOperationModify;
+export type Update = Node & {
+    type: 'update';
+    updates: {
+        operation?: UpdateOperation;
+        context: ContextDefinition[];
+    }[];
+};
+export type QueryBase = Node & {
+    type: 'query';
+    subType: string;
+    context: ContextDefinition[];
+    values?: PatternValues;
+    solutionModifiers: SolutionModifiers;
+    datasets: DatasetClauses;
+    where?: PatternGroup;
+};
+export type QuerySelect = QueryBase & {
+    subType: 'select';
+    variables: (TermVariable | PatternBind)[] | [Wildcard];
+    distinct?: true;
+    reduced?: true;
+    where: PatternGroup;
+};
+export type QueryConstruct = QueryBase & {
+    subType: 'construct';
+    template: PatternBgp;
+    where: PatternGroup;
+};
+export type QueryDescribe = QueryBase & {
+    subType: 'describe';
+    variables: (TermVariable | TermIri)[] | [Wildcard];
+};
+export type QueryAsk = QueryBase & {
+    subType: 'ask';
+    where: PatternGroup;
+};
+export type Query = QuerySelect | QueryConstruct | QueryDescribe | QueryAsk;
+export type SparqlQuery = Query | Update;
+export type DatasetClauses = Node & {
+    type: 'datasetClauses';
+    clauses: {
+        clauseType: 'default' | 'named';
+        value: TermIri;
+    }[];
+};
+export type TripleCollectionBase = Node & {
+    type: 'tripleCollection';
+    subType: string;
+    triples: TripleNesting[];
+    identifier: Term;
+};
 /**
- * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.
+ * The subject of the triples does not have a string manifestation.
  */
-NameType extends string = string, 
+export type TripleCollectionList = TripleCollectionBase & {
+    subType: 'list';
+    identifier: TermBlank;
+};
 /**
- * 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.
+ * Bot subject and predicate of the triples do not have a string manifestation.
  */
-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'.
- */
-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> = ParserRule<SparqlContext, NameType, ReturnType, ParamType>;
-export interface SparqlContext {
-    /**
-     * Data-factoryMixins to be used when constructing rdf primitives.
-     */
-    factory: Factory;
-    /**
-     * Current scoped prefixes. Used for resolving prefixed names.
-     */
-    prefixes: Record<string, string>;
+export type TripleCollectionBlankNodeProperties = TripleCollectionBase & {
+    subType: 'blankNodeProperties';
+    identifier: TermBlank;
+};
+export type TripleCollection = TripleCollectionList | TripleCollectionBlankNodeProperties;
+export type GraphNode = Term | TripleCollection;
+export type TripleNesting = Node & {
+    type: 'triple';
+    subject: GraphNode;
+    predicate: TermIri | TermVariable | Path;
+    object: GraphNode;
+};
+export type PatternBase = Node & {
+    type: 'pattern';
+    subType: string;
+};
+export type PatternFilter = PatternBase & {
+    subType: 'filter';
+    expression: Expression;
+};
+export type PatternMinus = PatternBase & {
+    subType: 'minus';
+    patterns: Pattern[];
+};
+export type PatternGroup = PatternBase & {
+    subType: 'group';
+    patterns: Pattern[];
+};
+export type PatternOptional = PatternBase & {
+    subType: 'optional';
+    patterns: Pattern[];
+};
+export type PatternGraph = PatternBase & {
+    subType: 'graph';
+    name: TermIri | TermVariable;
+    patterns: Pattern[];
+};
+export type PatternUnion = PatternBase & {
+    subType: 'union';
+    patterns: PatternGroup[];
+};
+export type BasicGraphPattern = (TripleNesting | TripleCollection)[];
+export type PatternBgp = PatternBase & {
+    subType: 'bgp';
     /**
-     * The base IRI for the query. Used for resolving relative IRIs.
+     * Only the first appearance of a subject and predicate have a string manifestation
      */
-    baseIRI: string | undefined;
-    /**
-     * Can be used to disable the validation that used variables in a select clause are in scope.
-     */
-    skipValidation: boolean;
-    /**
-     * Set of queryModes. Primarily used for note 8, 14.
-     */
-    parseMode: Set<'canParseVars' | 'canCreateBlankNodes' | 'inAggregate' | 'canParseAggregate' | string>;
-}
+    triples: BasicGraphPattern;
+};
+export type PatternBind = PatternBase & {
+    subType: 'bind';
+    expression: Expression;
+    variable: TermVariable;
+};
+export type PatternService = PatternBase & {
+    subType: 'service';
+    name: TermIri | TermVariable;
+    silent: boolean;
+    patterns: Pattern[];
+};
+/**
+ * A single list of assignments maps the variable identifier to the value
+ */
+export type ValuePatternRow = Record<string, TermIri | TermLiteral | undefined>;
+export type PatternValues = PatternBase & {
+    subType: 'values';
+    values: ValuePatternRow[];
+};
+export type SubSelect = QuerySelect;
+export type Pattern = PatternBgp | PatternGroup | PatternUnion | PatternOptional | PatternMinus | PatternGraph | PatternService | PatternFilter | PatternBind | PatternValues | SubSelect;
+export type SolutionModifiers = {
+    group?: SolutionModifierGroup;
+    having?: SolutionModifierHaving;
+    order?: SolutionModifierOrder;
+    limitOffset?: SolutionModifierLimitOffset;
+};
+export type SolutionModifierBase = Node & {
+    type: 'solutionModifier';
+    subType: string;
+};
+export type SolutionModifierGroupBind = Localized & {
+    variable: TermVariable;
+    value: Expression;
+};
+export type SolutionModifierGroup = SolutionModifierBase & {
+    subType: 'group';
+    groupings: (Expression | SolutionModifierGroupBind)[];
+};
+export type SolutionModifierHaving = SolutionModifierBase & {
+    subType: 'having';
+    having: Expression[];
+};
+export type Ordering = Localized & {
+    descending: boolean;
+    expression: Expression;
+};
+export type SolutionModifierOrder = SolutionModifierBase & {
+    subType: 'order';
+    orderDefs: Ordering[];
+};
+export type SolutionModifierLimitOffset = SolutionModifierBase & {
+    subType: 'limitOffset';
+    limit: number | undefined;
+    offset: number | undefined;
+};
+export type SolutionModifier = SolutionModifierGroup | SolutionModifierHaving | SolutionModifierOrder | SolutionModifierLimitOffset;
+export type ExpressionBase = Node & {
+    type: 'expression';
+    subType: string;
+};
+type ExpressionAggregateBase = ExpressionBase & {
+    subType: 'aggregate';
+    distinct: boolean;
+    expression: [Expression | Wildcard];
+};
+export type ExpressionAggregateDefault = ExpressionAggregateBase & {
+    expression: [Expression];
+    aggregation: string;
+};
+export type ExpressionAggregateOnWildcard = ExpressionAggregateBase & {
+    expression: [Wildcard];
+    aggregation: string;
+};
+export type ExpressionAggregateSeparator = ExpressionAggregateBase & {
+    expression: [Expression];
+    aggregation: string;
+    separator: string;
+};
+export type ExpressionAggregate = ExpressionAggregateDefault | ExpressionAggregateOnWildcard | ExpressionAggregateSeparator;
+export type ExpressionOperation = ExpressionBase & {
+    subType: 'operation';
+    operator: string;
+    args: Expression[];
+};
+export type ExpressionPatternOperation = ExpressionBase & {
+    subType: 'patternOperation';
+    operator: string;
+    args: PatternGroup;
+};
+export type ExpressionFunctionCall = ExpressionBase & {
+    subType: 'functionCall';
+    function: TermIri;
+    distinct: boolean;
+    args: Expression[];
+};
+export type Expression = ExpressionOperation | ExpressionPatternOperation | ExpressionFunctionCall | ExpressionAggregate | TermIri | TermVariable | TermLiteral;
+export type PropertyPathBase = Node & {
+    type: 'path';
+    subType: string;
+};
+export type PropertyPathChain = PropertyPathBase & {
+    subType: '|' | '/';
+    items: Path[];
+};
+export type PathModified = PropertyPathBase & {
+    subType: '?' | '*' | '+' | '^';
+    items: [Path];
+};
+export type PathNegatedElt = PropertyPathBase & {
+    subType: '^';
+    items: [TermIri];
+};
+export type PathAlternativeLimited = PropertyPathBase & {
+    subType: '|';
+    items: (TermIri | PathNegatedElt)[];
+};
+export type PathNegated = PropertyPathBase & {
+    subType: '!';
+    items: [TermIri | PathNegatedElt | PathAlternativeLimited];
+};
+export type Path = TermIri | PropertyPathChain | PathModified | PathNegated;
+export type PathPure = PropertyPathChain | PathModified | PathNegated;
+export type ContextDefinitionBase_ = Node & {
+    type: 'contextDef';
+    subType: string;
+};
+export type ContextDefinitionPrefix = ContextDefinitionBase_ & {
+    subType: 'prefix';
+    key: string;
+    value: TermIriFull;
+};
+export type ContextDefinitionBase = ContextDefinitionBase_ & {
+    subType: 'base';
+    value: TermIriFull;
+};
+export type ContextDefinition = ContextDefinitionPrefix | ContextDefinitionBase;
+export type Wildcard = Node & {
+    type: 'wildcard';
+};
+export type TermBase = Node & {
+    type: 'term';
+    subType: string;
+};
+export type TermLiteralBase = TermBase & {
+    subType: 'literal';
+    value: string;
+};
+export type TermLiteralStr = TermLiteralBase & {
+    langOrIri: undefined;
+};
+export type TermLiteralLangStr = TermLiteralBase & {
+    langOrIri: string;
+};
+export type TermLiteralTyped = TermLiteralBase & {
+    langOrIri: TermIri;
+};
+export type TermLiteral = TermLiteralStr | TermLiteralLangStr | TermLiteralTyped;
+export type TermVariable = TermBase & {
+    subType: 'variable';
+    value: string;
+};
+export type TermIriBase = TermBase & {
+    subType: 'namedNode';
+};
+export type TermIriFull = TermIriBase & {
+    value: string;
+};
+export type TermIriPrefixed = TermIriBase & {
+    value: string;
+    prefix: string;
+};
+export type TermIri = TermIriFull | TermIriPrefixed;
+export type TermBlank = TermBase & {
+    subType: 'blankNode';
+} & {
+    label: string;
+};
+export type GraphTerm = TermIri | TermBlank | TermLiteral;
+export type Term = GraphTerm | TermVariable;
+export {};

package/lib/Sparql11types.js.map

@@ -1 +1 @@
-{"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"]}
+{"version":3,"file":"Sparql11types.js","sourceRoot":"","sources":["Sparql11types.ts"],"names":[],"mappings":"","sourcesContent":["import type { Localized, Node } from '@traqula/core';\n\nexport type Sparql11Nodes =\n  | GraphRef\n  | UpdateOperation\n  | Update\n  | Query\n  | DatasetClauses\n  | TripleCollection\n  | TripleNesting\n  | Pattern\n  | SolutionModifier\n  | Expression\n  | Path\n  | ContextDefinition\n  | Wildcard\n  | Term;\n\nexport type GraphRefBase = Node & {\n  type: 'graphRef';\n  subType: string;\n};\nexport type GraphRefDefault = GraphRefBase & {\n  subType: 'default';\n};\nexport type GraphRefNamed = GraphRefBase & {\n  subType: 'named';\n};\nexport type GraphRefAll = GraphRefBase & {\n  subType: 'all';\n};\nexport type GraphRefSpecific = GraphRefBase & {\n  subType: 'specific';\n  graph: TermIri;\n};\nexport type GraphRef =\n  | GraphRefDefault\n  | GraphRefNamed\n  | GraphRefAll\n  | GraphRefSpecific;\n\nexport type Quads = PatternBgp | GraphQuads;\n\nexport type GraphQuads = Node & {\n  type: 'graph';\n  graph: TermIri | TermVariable;\n  triples: PatternBgp;\n};\n\n// https://www.w3.org/TR/sparql11-query/#rUpdate1\nexport type UpdateOperationBase = Node & { type: 'updateOperation'; subType: string };\nexport type UpdateOperationLoad = UpdateOperationBase & {\n  subType: 'load';\n  silent: boolean;\n  source: TermIri;\n  destination?: GraphRefSpecific;\n};\ntype UpdateOperationClearDropCreateBase = UpdateOperationBase & {\n  subType: 'clear' | 'drop' | 'create';\n  silent: boolean;\n  destination: GraphRef;\n};\nexport type UpdateOperationClear = UpdateOperationClearDropCreateBase & { subType: 'clear' };\nexport type UpdateOperationDrop = UpdateOperationClearDropCreateBase & { subType: 'drop' };\nexport type UpdateOperationCreate = UpdateOperationClearDropCreateBase & {\n  subType: 'create';\n  destination: GraphRefSpecific;\n};\ntype UpdateOperationAddMoveCopy = UpdateOperationBase & {\n  subType: 'add' | 'move' | 'copy';\n  silent: boolean;\n  source: GraphRefDefault | GraphRefSpecific;\n  destination: GraphRefDefault | GraphRefSpecific;\n};\nexport type UpdateOperationAdd = UpdateOperationAddMoveCopy & { subType: 'add' };\nexport type UpdateOperationMove = UpdateOperationAddMoveCopy & { subType: 'move' };\nexport type UpdateOperationCopy = UpdateOperationAddMoveCopy & { subType: 'copy' };\ntype UpdateOperationInsertDeleteDelWhere = UpdateOperationBase & {\n  subType: 'insertdata' | 'deletedata' | 'deletewhere';\n  data: Quads[];\n};\nexport type UpdateOperationInsertData = UpdateOperationInsertDeleteDelWhere & { subType: 'insertdata' };\nexport type UpdateOperationDeleteData = UpdateOperationInsertDeleteDelWhere & { subType: 'deletedata' };\nexport type UpdateOperationDeleteWhere = UpdateOperationInsertDeleteDelWhere & { subType: 'deletewhere' };\nexport type UpdateOperationModify = UpdateOperationBase & {\n  subType: 'modify';\n  graph: TermIri | undefined;\n  insert: Quads[];\n  delete: Quads[];\n  from: DatasetClauses;\n  where: PatternGroup;\n};\nexport type UpdateOperation =\n  | UpdateOperationLoad\n  | UpdateOperationClear\n  | UpdateOperationDrop\n  | UpdateOperationCreate\n  | UpdateOperationAdd\n  | UpdateOperationMove\n  | UpdateOperationCopy\n  | UpdateOperationInsertData\n  | UpdateOperationDeleteData\n  | UpdateOperationDeleteWhere\n  | UpdateOperationModify;\n\n// https://www.w3.org/TR/sparql11-query/#rUpdate\nexport type Update = Node & {\n  type: 'update';\n  updates: {\n    operation?: UpdateOperation;\n    context: ContextDefinition[];\n  }[];\n};\n\n// https://www.w3.org/TR/sparql11-query/#rQueryUnit\nexport type QueryBase = Node & {\n  type: 'query';\n  subType: string;\n\n  context: ContextDefinition[];\n  values?: PatternValues;\n  solutionModifiers: SolutionModifiers;\n  datasets: DatasetClauses;\n  where?: PatternGroup;\n};\nexport type QuerySelect = QueryBase & {\n  subType: 'select';\n  variables: (TermVariable | PatternBind)[] | [Wildcard];\n  distinct?: true;\n  reduced?: true;\n  where: PatternGroup;\n};\nexport type QueryConstruct = QueryBase & {\n  subType: 'construct';\n  template: PatternBgp;\n  where: PatternGroup;\n};\nexport type QueryDescribe = QueryBase & {\n  subType: 'describe';\n  variables: (TermVariable | TermIri)[] | [Wildcard];\n};\nexport type QueryAsk = QueryBase & {\n  subType: 'ask';\n  where: PatternGroup;\n};\nexport type Query =\n  | QuerySelect\n  | QueryConstruct\n  | QueryDescribe\n  | QueryAsk;\n\nexport type SparqlQuery = Query | Update;\n\n// https://www.w3.org/TR/sparql11-query/#rDatasetClause\nexport type DatasetClauses = Node & {\n  type: 'datasetClauses';\n  clauses: { clauseType: 'default' | 'named'; value: TermIri }[];\n};\n\n// https://www.w3.org/TR/sparql11-query/#rGraphNode\nexport type TripleCollectionBase = Node & {\n  type: 'tripleCollection';\n  subType: string;\n  triples: TripleNesting[];\n  identifier: Term;\n};\n/**\n * The subject of the triples does not have a string manifestation.\n */\nexport type TripleCollectionList = TripleCollectionBase & {\n  subType: 'list';\n  identifier: TermBlank;\n};\n/**\n * Bot subject and predicate of the triples do not have a string manifestation.\n */\nexport type TripleCollectionBlankNodeProperties = TripleCollectionBase & {\n  subType: 'blankNodeProperties';\n  identifier: TermBlank;\n};\nexport type TripleCollection =\n  | TripleCollectionList\n  | TripleCollectionBlankNodeProperties;\n\n// https://www.w3.org/TR/sparql11-query/#rGraphNode\nexport type GraphNode = Term | TripleCollection;\n\n// https://www.w3.org/TR/sparql11-query/#rTriplesBlock\nexport type TripleNesting = Node & {\n  type: 'triple';\n  subject: GraphNode;\n  predicate: TermIri | TermVariable | Path;\n  object: GraphNode;\n};\n\nexport type PatternBase = Node & { type: 'pattern'; subType: string };\nexport type PatternFilter = PatternBase & {\n  subType: 'filter';\n  expression: Expression;\n};\nexport type PatternMinus = PatternBase & {\n  subType: 'minus';\n  patterns: Pattern[];\n};\n\nexport type PatternGroup = PatternBase & {\n  subType: 'group';\n  patterns: Pattern[];\n};\nexport type PatternOptional = PatternBase & {\n  subType: 'optional';\n  patterns: Pattern[];\n};\nexport type PatternGraph = PatternBase & {\n  subType: 'graph';\n  name: TermIri | TermVariable;\n  patterns: Pattern[];\n};\nexport type PatternUnion = PatternBase & {\n  subType: 'union';\n  patterns: PatternGroup[];\n};\nexport type BasicGraphPattern = (TripleNesting | TripleCollection)[];\nexport type PatternBgp = PatternBase & {\n  subType: 'bgp';\n  /**\n   * Only the first appearance of a subject and predicate have a string manifestation\n   */\n  triples: BasicGraphPattern;\n};\nexport type PatternBind = PatternBase & {\n  subType: 'bind';\n  expression: Expression;\n  variable: TermVariable;\n};\nexport type PatternService = PatternBase & {\n  subType: 'service';\n  name: TermIri | TermVariable;\n  silent: boolean;\n  patterns: Pattern[];\n};\n/**\n * A single list of assignments maps the variable identifier to the value\n */\nexport type ValuePatternRow = Record<string, TermIri | TermLiteral | undefined>;\nexport type PatternValues = PatternBase & {\n  subType: 'values';\n  values: ValuePatternRow[];\n};\nexport type SubSelect = QuerySelect;\n\nexport type Pattern =\n  | PatternBgp\n  | PatternGroup\n  | PatternUnion\n  | PatternOptional\n  | PatternMinus\n  | PatternGraph\n  | PatternService\n  | PatternFilter\n  | PatternBind\n  | PatternValues\n  | SubSelect;\n\nexport type SolutionModifiers = {\n  group?: SolutionModifierGroup;\n  having?: SolutionModifierHaving;\n  order?: SolutionModifierOrder;\n  limitOffset?: SolutionModifierLimitOffset;\n};\nexport type SolutionModifierBase = Node & { type: 'solutionModifier'; subType: string };\nexport type SolutionModifierGroupBind = Localized & {\n  variable: TermVariable;\n  value: Expression;\n};\nexport type SolutionModifierGroup = SolutionModifierBase & {\n  subType: 'group';\n  groupings: (Expression | SolutionModifierGroupBind)[];\n};\nexport type SolutionModifierHaving = SolutionModifierBase & {\n  subType: 'having';\n  having: Expression[];\n};\nexport type Ordering = Localized & {\n  descending: boolean;\n  expression: Expression;\n};\nexport type SolutionModifierOrder = SolutionModifierBase & {\n  subType: 'order';\n  orderDefs: Ordering[];\n};\nexport type SolutionModifierLimitOffset = SolutionModifierBase\n  & { subType: 'limitOffset'; limit: number | undefined; offset: number | undefined };\n\nexport type SolutionModifier =\n  | SolutionModifierGroup\n  | SolutionModifierHaving\n  | SolutionModifierOrder\n  | SolutionModifierLimitOffset;\n\nexport type ExpressionBase = Node & { type: 'expression'; subType: string };\n\ntype ExpressionAggregateBase = ExpressionBase & {\n  subType: 'aggregate';\n  distinct: boolean;\n  expression: [Expression | Wildcard];\n};\nexport type ExpressionAggregateDefault = ExpressionAggregateBase & {\n  expression: [Expression];\n  aggregation: string;\n};\nexport type ExpressionAggregateOnWildcard = ExpressionAggregateBase & {\n  expression: [Wildcard];\n  aggregation: string;\n};\nexport type ExpressionAggregateSeparator = ExpressionAggregateBase & {\n  expression: [Expression];\n  aggregation: string;\n  separator: string;\n};\nexport type ExpressionAggregate =\n  | ExpressionAggregateDefault\n  | ExpressionAggregateOnWildcard\n  | ExpressionAggregateSeparator;\n\nexport type ExpressionOperation = ExpressionBase & {\n  subType: 'operation';\n  operator: string;\n  args: Expression[];\n};\n\nexport type ExpressionPatternOperation = ExpressionBase & {\n  subType: 'patternOperation';\n  operator: string;\n  // Can be a pattern in case of exists and not exists\n  args: PatternGroup;\n};\n\nexport type ExpressionFunctionCall = ExpressionBase & {\n  subType: 'functionCall';\n  function: TermIri;\n  distinct: boolean;\n  args: Expression[];\n};\n\nexport type Expression =\n  | ExpressionOperation\n  | ExpressionPatternOperation\n  | ExpressionFunctionCall\n  | ExpressionAggregate\n  | TermIri\n  | TermVariable\n  | TermLiteral;\n\nexport type PropertyPathBase = Node & { type: 'path'; subType: string };\nexport type PropertyPathChain = PropertyPathBase & {\n  subType: '|' | '/';\n  items: Path[];\n};\n\nexport type PathModified = PropertyPathBase & {\n  subType: '?' | '*' | '+' | '^';\n  items: [Path];\n};\n\nexport type PathNegatedElt = PropertyPathBase & {\n  subType: '^';\n  items: [TermIri];\n};\n\nexport type PathAlternativeLimited = PropertyPathBase & {\n  subType: '|';\n  items: (TermIri | PathNegatedElt)[];\n};\n\nexport type PathNegated = PropertyPathBase & {\n  subType: '!';\n  items: [TermIri | PathNegatedElt | PathAlternativeLimited];\n};\n\n// [[88]](https://www.w3.org/TR/sparql11-query/#rPath)\nexport type Path =\n  | TermIri\n  | PropertyPathChain\n  | PathModified\n  | PathNegated;\nexport type PathPure = PropertyPathChain | PathModified | PathNegated;\n\nexport type ContextDefinitionBase_ = Node & { type: 'contextDef'; subType: string };\nexport type ContextDefinitionPrefix = ContextDefinitionBase_ & {\n  subType: 'prefix';\n  key: string;\n  value: TermIriFull;\n};\nexport type ContextDefinitionBase = ContextDefinitionBase_ & {\n  subType: 'base';\n  value: TermIriFull;\n};\nexport type ContextDefinition = ContextDefinitionPrefix | ContextDefinitionBase;\n\nexport type Wildcard = Node & {\n  type: 'wildcard';\n};\n\nexport type TermBase = Node & { type: 'term'; subType: string };\nexport type TermLiteralBase = TermBase & {\n  subType: 'literal';\n  value: string;\n};\nexport type TermLiteralStr = TermLiteralBase & { langOrIri: undefined };\nexport type TermLiteralLangStr = TermLiteralBase & { langOrIri: string };\nexport type TermLiteralTyped = TermLiteralBase & { langOrIri: TermIri };\nexport type TermLiteral = TermLiteralStr | TermLiteralLangStr | TermLiteralTyped;\n\nexport type TermVariable = TermBase & {\n  subType: 'variable';\n  value: string;\n};\n\nexport type TermIriBase = TermBase & { subType: 'namedNode' };\nexport type TermIriFull = TermIriBase & { value: string };\nexport type TermIriPrefixed = TermIriBase & {\n  value: string;\n  prefix: string;\n};\nexport type TermIri = TermIriFull | TermIriPrefixed;\n\nexport type TermBlank = TermBase & { subType: 'blankNode' } & { label: string };\n\nexport type GraphTerm = TermIri | TermBlank | TermLiteral;\nexport type Term = GraphTerm | TermVariable;\n"]}

package/lib/SparqlParser.d.ts

@@ -1,8 +1,8 @@
-import type { Path, TermIri } from './RoundTripTypes';
-import type { SparqlContext } from './Sparql11types';
+import type { SparqlContext } from './sparql11HelperTypes';
+import type { Path, TermIri } from './Sparql11types';
 interface Parser<ParseRet> {
-    queryOrUpdate: (input: string, context: SparqlContext, arg: undefined) => ParseRet;
-    path: (input: string, context: SparqlContext, arg: undefined) => TermIri | Path;
+    queryOrUpdate: (input: string, context: SparqlContext) => ParseRet;
+    path: (input: string, context: SparqlContext) => TermIri | Path;
 }
 export declare function completeParseContext(context: Partial<SparqlContext & {
     origSource: string;

package/lib/SparqlParser.js

@@ -16,10 +16,10 @@ export class SparqlParser {
         this.F = new Factory();
     }
     parse(query, context = {}) {
-        return this.parser.queryOrUpdate(query, completeParseContext(context), undefined);
+        return this.parser.queryOrUpdate(query, completeParseContext(context));
     }
     parsePath(query, context = {}) {
-        const result = this.parser.path(query, completeParseContext(context), undefined);
+        const result = this.parser.path(query, completeParseContext(context));
         if (this.F.isPathPure(result)) {
             return {
                 ...result,

package/lib/SparqlParser.js.map

@@ -1 +1 @@
-{"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"]}
+{"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,CAAC,CAAC;IACzE,CAAC;IAEM,SAAS,CAAC,KAAa,EAAE,UAAkC,EAAE;QAElE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC;QACtE,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 { SparqlContext } from './sparql11HelperTypes';\nimport type { Path, TermIri } from './Sparql11types';\n\ninterface Parser<ParseRet> {\n  queryOrUpdate: (input: string, context: SparqlContext) => ParseRet;\n  path: (input: string, context: SparqlContext) => 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));\n  }\n\n  public parsePath(query: string, context: Partial<SparqlContext> = {}):\n    (Path & { prefixes: object }) | TermIri {\n    const result = this.parser.path(query, completeParseContext(context));\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,6 +1,6 @@
 import type { TokenType } from 'chevrotain';
-import type { Expression, ExpressionAggregateDefault, ExpressionOperation, ExpressionPatternOperation, TermVariable } from './RoundTripTypes';
-import type { SparqlGrammarRule } from './Sparql11types';
+import type { SparqlGrammarRule } from './sparql11HelperTypes';
+import type { Expression, ExpressionAggregateDefault, ExpressionOperation, ExpressionPatternOperation, TermVariable } from './Sparql11types';
 export type ExpressionFunctionX<U extends Expression[]> = ExpressionOperation & {
     args: U;
 };