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

package/lib/sparql12Types.d.ts

@@ -1,158 +1,317 @@
-import type * as RDF from '@rdfjs/types';
-import type { Patch } from '@traqula/core';
+import type { Localized, Node, Patch } from '@traqula/core';
 import type * as T11 from '@traqula/rules-sparql-1-1';
-export type BaseQuadTerm = RDF.BaseQuad & {
-    subject: Term;
-    predicate: Term;
-    object: Term;
+export type Sparql12Nodes = GraphRef | UpdateOperation | Update | Query | DatasetClauses | TripleCollection | TripleNesting | Pattern | SolutionModifier | Expression | Path | ContextDefinition | Wildcard | Term;
+export type GraphRefBase = T11.GraphRefBase;
+export type GraphRefDefault = T11.GraphRefDefault;
+export type GraphRefNamed = T11.GraphRefNamed;
+export type GraphRefAll = T11.GraphRefAll;
+export type GraphRefSpecific = T11.GraphRefSpecific;
+export type GraphRef = T11.GraphRef;
+export type Quads = PatternBgp | GraphQuads;
+export type GraphQuads = Node & {
+    type: 'graph';
+    graph: TermIri | TermVariable;
+    triples: PatternBgp;
 };
-export type GraphTerm = IriTerm | BlankTerm | LiteralTerm | BaseQuadTerm;
-export type Term = GraphTerm | VariableTerm;
-export type Expression = T11.Expression | BaseQuadTerm;
-export type Triple = Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>;
-export type IGraphNode = Patch<T11.IGraphNode, {
-    triples: Triple[];
-    node: ITriplesNode['node'] | Term;
-}>;
-export type ITriplesNode = Patch<T11.ITriplesNode, {
-    triples: Triple[];
-}>;
-/**
- * Overrides {@link T11.Pattern}
- */
-export type Pattern = BgpPattern | BlockPattern | FilterPattern | BindPattern | ValuesPattern | Omit<SelectQuery, 'prefixes'>;
-export type FunctionCallExpression = Patch<T11.FunctionCallExpression, {
-    args: Expression[];
-}>;
-export type BgpPattern = Patch<T11.BgpPattern, {
-    triples: Triple[];
-}>;
-export type GraphQuads = Patch<T11.GraphQuads, {
-    triples: Triple[];
-}>;
-export type VariableTerm = T11.VariableTerm;
-export type IriTerm<IRI extends string = string> = T11.IriTerm<IRI>;
-export type LiteralTerm = T11.LiteralTerm;
-export type BlankTerm = T11.BlankTerm;
-export type PropertyPath = NegatedPropertySet | {
-    type: 'path';
-    pathType: '|' | '/' | '^' | '+' | '*' | '?';
-    items: (IriTerm | PropertyPath)[];
+export type UpdateOperationBase = Node & {
+    type: 'updateOperation';
+    subType: string;
 };
-/**
- * Overrides {@link T11.SparqlQuery}
- */
-export type SparqlQuery = Query | Update | Pick<Update, 'base' | 'prefixes'>;
-/**
- * Overrides {@link T11.Query}
- */
-export type Query = SelectQuery | ConstructQuery | AskQuery | DescribeQuery;
-export type SelectQuery = Patch<T11.SelectQuery, BaseQuery>;
-export type Grouping = Patch<T11.Grouping, {
-    expression: Expression;
-}>;
-export type Ordering = Patch<T11.Ordering, {
-    expression: Expression;
-}>;
-export type ConstructQuery = Patch<T11.ConstructQuery, BaseQuery & {
-    template?: Triple[] | undefined;
-}>;
-export type AskQuery = Patch<T11.AskQuery, BaseQuery>;
-export type DescribeQuery = Patch<T11.DescribeQuery, BaseQuery>;
-export type Update = Patch<T11.Update, {
-    updates: UpdateOperation;
-}>;
-/**
- * Overrides {@link T11.UpdateOperation}
- */
-export type UpdateOperation = InsertDeleteOperation | ManagementOperation;
-/**
- * Overrides {@link T11.InsertDeleteOperation}
- */
-export type InsertDeleteOperation = InsertOperation | DeleteOperation | ModifyOperation | DeleteWhereOperation;
-export type InsertOperation = Patch<T11.InsertOperation, {
-    insert: Quads[];
-}>;
-export type DeleteOperation = Patch<T11.DeleteOperation, {
-    delete: Quads[];
-}>;
-export type ModifyOperation = Patch<T11.ModifyOperation, {
+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[];
-    where: Pattern[];
-}>;
-export type DeleteWhereOperation = Patch<T11.DeleteWhereOperation, {
-    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;
+};
 /**
- * Overrides {@link T11.Quads}
+ * Both subject and predicate of the triples do not have a string manifestation.
  */
-export type Quads = BgpPattern | GraphQuads;
+export type TripleCollectionList = TripleCollectionBase & {
+    subType: 'list';
+    identifier: TermBlank;
+};
 /**
- * Overrides {@link T11.ManagementOperation}
+ * The subject of the triples does not have a string manifestation.
  */
-export type ManagementOperation = CopyMoveAddOperation | LoadOperation | CreateOperation | ClearDropOperation;
-export type CopyMoveAddOperation = T11.CopyMoveAddOperation;
-export type LoadOperation = T11.LoadOperation;
-export type CreateOperation = T11.CreateOperation;
-export type ClearDropOperation = T11.ClearDropOperation;
-export type GraphOrDefault = T11.GraphOrDefault;
-export type GraphReference = T11.GraphReference;
-export type Variable = T11.Variable;
-export type VariableExpression = Patch<T11.VariableExpression, {
-    expression: Expression;
+export type TripleCollectionBlankNodeProperties = Patch<T11.TripleCollectionBlankNodeProperties, {
+    triples: TripleNesting[];
+    identifier: TermBlank | TermVariable | TermIri;
 }>;
-export type BaseQuery = Patch<T11.BaseQuery, {
-    where?: Pattern[] | undefined;
-    values?: ValuePatternRow[] | undefined;
-    having?: Expression[] | undefined;
-    group?: Grouping[] | undefined;
-    order: Ordering[] | undefined;
-}>;
-export type IriTermOrElt = T11.IriTermOrElt;
-export type NegatedPropertySet = T11.NegatedPropertySet;
-export type GroupPattern = Patch<T11.GroupPattern, {
-    patterns: Pattern[];
-}>;
-export type GraphPattern = Patch<T11.GraphPattern, {
+export type TripleCollectionReifiedTriple = TripleCollectionBase & {
+    subType: 'reifiedTriple';
+    identifier: TermVariable | TermIri | TermBlank;
+};
+export type TripleCollection = TripleCollectionList | TripleCollectionBlankNodeProperties | TripleCollectionReifiedTriple;
+export type GraphNode = Term | TripleCollection;
+export type Annotation = TripleCollectionBlankNodeProperties | TermVariable | TermIri | TermBlank;
+export type TripleNesting = Node & {
+    type: 'triple';
+    subject: GraphNode;
+    predicate: TermIri | TermVariable | Path;
+    object: GraphNode;
+    annotations?: Annotation[];
+};
+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 MinusPattern = Patch<T11.MinusPattern, {
+};
+export type PatternGroup = PatternBase & {
+    subType: 'group';
     patterns: Pattern[];
-}>;
-export type ServicePattern = Patch<T11.ServicePattern, {
+};
+export type PatternOptional = PatternBase & {
+    subType: 'optional';
     patterns: Pattern[];
-}>;
-/**
- * Overrides {@link T11.BlockPattern}
- */
-export type BlockPattern = OptionalPattern | UnionPattern | GroupPattern | GraphPattern | MinusPattern | ServicePattern;
-export type OptionalPattern = Patch<T11.OptionalPattern, {
+};
+export type PatternGraph = PatternBase & {
+    subType: 'graph';
+    name: TermIri | TermVariable;
     patterns: Pattern[];
-}>;
-export type UnionPattern = Patch<T11.UnionPattern, {
+};
+export type PatternUnion = PatternBase & {
+    subType: 'union';
+    patterns: PatternGroup[];
+};
+export type BasicGraphPattern = (TripleNesting | TripleCollection)[];
+export type PatternBgp = PatternBase & {
+    subType: 'bgp';
+    /**
+     * Only the first appearance of a subject and predicate have a string manifestation
+     */
+    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[];
-}>;
+};
 /**
- * Overrides {@link T11.ValuePatternRow}
+ * A single list of assignments maps the variable identifier to the value
  */
-export type ValuePatternRow = Record<string, IriTerm | BlankTerm | LiteralTerm | BaseQuery | undefined>;
-export type FilterPattern = Patch<T11.FilterPattern, {
-    expression: Expression;
-}>;
-export type BindPattern = Patch<T11.BindPattern, {
-    expression: Expression;
-}>;
-export type ValuesPattern = Patch<T11.ValuesPattern, {
+export type ValuePatternRow = Record<string, TermIri | TermLiteral | undefined>;
+export type PatternValues = PatternBase & {
+    subType: 'values';
     values: ValuePatternRow[];
-}>;
-export type BaseExpression = T11.BaseExpression;
-export type OperationExpression = Patch<T11.OperationExpression, BaseExpression & {
-    args: Expression[] | [Pattern];
-}>;
-export type AggregateExpression = Patch<T11.AggregateExpression, BaseExpression & {
-    expression: Expression | T11.Wildcard;
-}>;
+};
+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 = Expression | (Localized & {
+    descending: boolean;
+    expression: Expression;
+});
+export type SolutionModifierOrder = SolutionModifierBase & {
+    subType: 'order';
+    orderDefs: Ordering[];
+};
+export type SolutionModifierLimitOffset = T11.SolutionModifierLimitOffset;
+export type SolutionModifier = SolutionModifierGroup | SolutionModifierHaving | SolutionModifierOrder | SolutionModifierLimitOffset;
+export type ExpressionBase = Node & {
+    type: 'expression';
+    subType: string;
+};
+type ExpressionAggregateBase = ExpressionBase & {
+    subType: 'aggregate';
+    distinct: boolean;
+};
+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 | TermTriple;
+export type PropertyPathChain = T11.PropertyPathChain;
+export type PathModified = T11.PathModified;
+export type PathNegatedElt = T11.PathNegatedElt;
+export type PathAlternativeLimited = T11.PathAlternativeLimited;
+export type PathNegated = T11.PathNegated;
+export type Path = T11.Path;
+export type ContextDefinitionPrefix = T11.ContextDefinitionPrefix;
+export type ContextDefinitionBase = T11.ContextDefinitionBase;
+export type ContextDefinitionVersion = T11.ContextDefinitionBase_ & {
+    subType: 'version';
+    version: string;
+};
+export type ContextDefinition = T11.ContextDefinition | ContextDefinitionVersion;
+export type Wildcard = T11.Wildcard;
+export type TermLiteralStr = T11.TermLiteralStr;
+export type TermLiteralLangStr = T11.TermLiteralLangStr;
+export type TermLiteralTyped = T11.TermLiteralTyped;
+export type TermLiteral = T11.TermLiteral;
+export type TermVariable = T11.TermVariable;
+export type TermIriFull = T11.TermIriFull;
+export type TermIriPrefixed = T11.TermIriPrefixed;
+export type TermIri = T11.TermIri;
+export type TermBlank = T11.TermBlank;
+export type TermTriple = T11.TermBase & {
+    subType: 'triple';
+    subject: Term;
+    predicate: TermIri | TermVariable;
+    object: Term;
+};
+export type Term = GraphTerm | TermVariable;
+export type GraphTerm = TermIri | TermBlank | TermLiteral | TermTriple;
+export {};

package/lib/sparql12Types.js.map

@@ -1 +1 @@
-{"version":3,"file":"sparql12Types.js","sourceRoot":"","sources":["sparql12Types.ts"],"names":[],"mappings":"","sourcesContent":["import type * as RDF from '@rdfjs/types';\nimport type { Patch } from '@traqula/core';\nimport type * as T11 from '@traqula/rules-sparql-1-1';\n\nexport type BaseQuadTerm = RDF.BaseQuad & { subject: Term; predicate: Term; object: Term };\nexport type GraphTerm = IriTerm | BlankTerm | LiteralTerm | BaseQuadTerm;\nexport type Term = GraphTerm | VariableTerm;\n\nexport type Expression = T11.Expression | BaseQuadTerm;\n\n// Overriding other types\nexport type Triple = Patch<T11.Triple, { subject: Term; object: Term }>;\n\nexport type IGraphNode = Patch<T11.IGraphNode, { triples: Triple[]; node: ITriplesNode['node'] | Term }>;\n\nexport type ITriplesNode = Patch<T11.ITriplesNode, { triples: Triple[] }>;\n\n/**\n * Overrides {@link T11.Pattern}\n */\nexport type Pattern =\n  | BgpPattern\n  | BlockPattern\n  | FilterPattern\n  | BindPattern\n  | ValuesPattern\n  | Omit<SelectQuery, 'prefixes'>;\n\nexport type FunctionCallExpression = Patch<T11.FunctionCallExpression, { args: Expression[] }>;\n\nexport type BgpPattern = Patch<T11.BgpPattern, { triples: Triple[] }>;\n\nexport type GraphQuads = Patch<T11.GraphQuads, { triples: Triple[] }>;\n\nexport type VariableTerm = T11.VariableTerm;\nexport type IriTerm<IRI extends string = string> = T11.IriTerm<IRI>;\nexport type LiteralTerm = T11.LiteralTerm;\nexport type BlankTerm = T11.BlankTerm;\n\nexport type PropertyPath = NegatedPropertySet | {\n  type: 'path';\n  pathType: '|' | '/' | '^' | '+' | '*' | '?';\n  items: (IriTerm | PropertyPath)[];\n};\n\n/**\n * Overrides {@link T11.SparqlQuery}\n */\nexport type SparqlQuery = Query | Update | Pick<Update, 'base' | 'prefixes'>;\n\n/**\n * Overrides {@link T11.Query}\n */\nexport type Query = SelectQuery | ConstructQuery | AskQuery | DescribeQuery;\n\nexport type SelectQuery = Patch<T11.SelectQuery, BaseQuery>;\n\nexport type Grouping = Patch<T11.Grouping, { expression: Expression }>;\n\nexport type Ordering = Patch<T11.Ordering, { expression: Expression }>;\n\nexport type ConstructQuery = Patch<T11.ConstructQuery, BaseQuery & { template?: Triple[] | undefined }>;\n\nexport type AskQuery = Patch<T11.AskQuery, BaseQuery>;\n\nexport type DescribeQuery = Patch<T11.DescribeQuery, BaseQuery>;\n\nexport type Update = Patch<T11.Update, { updates: UpdateOperation }>;\n\n/**\n * Overrides {@link T11.UpdateOperation}\n */\nexport type UpdateOperation = InsertDeleteOperation | ManagementOperation;\n\n/**\n * Overrides {@link T11.InsertDeleteOperation}\n */\nexport type InsertDeleteOperation = InsertOperation | DeleteOperation | ModifyOperation | DeleteWhereOperation;\n\nexport type InsertOperation = Patch<T11.InsertOperation, { insert: Quads[] }>;\n\nexport type DeleteOperation = Patch<T11.DeleteOperation, { delete: Quads[] }>;\n\nexport type ModifyOperation = Patch<T11.ModifyOperation, {\n  insert: Quads[];\n  delete: Quads[];\n  where: Pattern[];\n}>;\n\nexport type DeleteWhereOperation = Patch<T11.DeleteWhereOperation, { delete: Quads[] }>;\n\n/**\n * Overrides {@link T11.Quads}\n */\nexport type Quads = BgpPattern | GraphQuads;\n\n/**\n * Overrides {@link T11.ManagementOperation}\n */\nexport type ManagementOperation =\n  | CopyMoveAddOperation\n  | LoadOperation\n  | CreateOperation\n  | ClearDropOperation;\n\nexport type CopyMoveAddOperation = T11.CopyMoveAddOperation;\nexport type LoadOperation = T11.LoadOperation;\nexport type CreateOperation = T11.CreateOperation;\nexport type ClearDropOperation = T11.ClearDropOperation;\nexport type GraphOrDefault = T11.GraphOrDefault;\nexport type GraphReference = T11.GraphReference;\nexport type Variable = T11.Variable;\n\nexport type VariableExpression = Patch<T11.VariableExpression, { expression: Expression }>;\n\nexport type BaseQuery = Patch<T11.BaseQuery, {\n  where?: Pattern[] | undefined;\n  values?: ValuePatternRow[] | undefined;\n  having?: Expression[] | undefined;\n  group?: Grouping[] | undefined;\n  order: Ordering[] | undefined;\n}>;\n\nexport type IriTermOrElt = T11.IriTermOrElt;\nexport type NegatedPropertySet = T11.NegatedPropertySet;\n\nexport type GroupPattern = Patch<T11.GroupPattern, { patterns: Pattern[] }>;\nexport type GraphPattern = Patch<T11.GraphPattern, { patterns: Pattern[] }>;\nexport type MinusPattern = Patch<T11.MinusPattern, { patterns: Pattern[] }>;\nexport type ServicePattern = Patch<T11.ServicePattern, { patterns: Pattern[] }>;\n\n/**\n * Overrides {@link T11.BlockPattern}\n */\nexport type BlockPattern =\n  | OptionalPattern\n  | UnionPattern\n  | GroupPattern\n  | GraphPattern\n  | MinusPattern\n  | ServicePattern;\n\nexport type OptionalPattern = Patch<T11.OptionalPattern, { patterns: Pattern[] }>;\nexport type UnionPattern = Patch<T11.UnionPattern, { patterns: Pattern[] }>;\n\n/**\n * Overrides {@link T11.ValuePatternRow}\n */\nexport type ValuePatternRow = Record<string, IriTerm | BlankTerm | LiteralTerm | BaseQuery | undefined>;\n\nexport type FilterPattern = Patch<T11.FilterPattern, { expression: Expression }>;\nexport type BindPattern = Patch<T11.BindPattern, { expression: Expression }>;\nexport type ValuesPattern = Patch<T11.ValuesPattern, { values: ValuePatternRow[] }>;\nexport type BaseExpression = T11.BaseExpression;\n\nexport type OperationExpression = Patch<T11.OperationExpression, BaseExpression & {\n  args: Expression[] | [Pattern];\n}>;\nexport type AggregateExpression = Patch<T11.AggregateExpression, BaseExpression & {\n  expression: Expression | T11.Wildcard;\n}>;\n"]}
+{"version":3,"file":"sparql12Types.js","sourceRoot":"","sources":["sparql12Types.ts"],"names":[],"mappings":"","sourcesContent":["import type { Localized, Node, Patch } from '@traqula/core';\nimport type * as T11 from '@traqula/rules-sparql-1-1';\n\nexport type Sparql12Nodes =\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 = T11.GraphRefBase;\nexport type GraphRefDefault = T11.GraphRefDefault;\nexport type GraphRefNamed = T11.GraphRefNamed;\nexport type GraphRefAll = T11.GraphRefAll;\nexport type GraphRefSpecific = T11.GraphRefSpecific;\nexport type GraphRef = T11.GraphRef;\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 * Both subject and predicate of the triples do not have a string manifestation.\n */\nexport type TripleCollectionList = TripleCollectionBase & {\n  subType: 'list';\n  identifier: TermBlank;\n};\n/**\n * The subject of the triples does not have a string manifestation.\n */\nexport type TripleCollectionBlankNodeProperties = Patch<T11.TripleCollectionBlankNodeProperties, {\n  triples: TripleNesting[];\n  identifier: TermBlank | TermVariable | TermIri;\n}>;\nexport type TripleCollectionReifiedTriple = TripleCollectionBase & {\n  subType: 'reifiedTriple';\n  identifier: TermVariable | TermIri | TermBlank;\n};\n\nexport type TripleCollection =\n  | TripleCollectionList\n  | TripleCollectionBlankNodeProperties\n  | TripleCollectionReifiedTriple;\n\n// https://www.w3.org/TR/sparql11-query/#rGraphNode\nexport type GraphNode = Term | TripleCollection;\nexport type Annotation = TripleCollectionBlankNodeProperties | TermVariable | TermIri | TermBlank;\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  annotations?: Annotation[];\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 =\n  | Expression\n  | (Localized & { descending: boolean; expression: Expression });\nexport type SolutionModifierOrder = SolutionModifierBase & {\n  subType: 'order';\n  orderDefs: Ordering[];\n};\nexport type SolutionModifierLimitOffset = T11.SolutionModifierLimitOffset;\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};\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  | TermTriple;\n\nexport type PropertyPathChain = T11.PropertyPathChain;\nexport type PathModified = T11.PathModified;\nexport type PathNegatedElt = T11.PathNegatedElt;\nexport type PathAlternativeLimited = T11.PathAlternativeLimited;\nexport type PathNegated = T11.PathNegated;\n// [[88]](https://www.w3.org/TR/sparql11-query/#rPath)\nexport type Path = T11.Path;\n\nexport type ContextDefinitionPrefix = T11.ContextDefinitionPrefix;\nexport type ContextDefinitionBase = T11.ContextDefinitionBase;\nexport type ContextDefinitionVersion = T11.ContextDefinitionBase_ & {\n  subType: 'version';\n  version: string;\n};\nexport type ContextDefinition = T11.ContextDefinition | ContextDefinitionVersion;\n\nexport type Wildcard = T11.Wildcard;\nexport type TermLiteralStr = T11.TermLiteralStr;\nexport type TermLiteralLangStr = T11.TermLiteralLangStr;\nexport type TermLiteralTyped = T11.TermLiteralTyped;\nexport type TermLiteral = T11.TermLiteral;\nexport type TermVariable = T11.TermVariable;\nexport type TermIriFull = T11.TermIriFull;\nexport type TermIriPrefixed = T11.TermIriPrefixed;\nexport type TermIri = T11.TermIri;\nexport type TermBlank = T11.TermBlank;\n\nexport type TermTriple = T11.TermBase & {\n  subType: 'triple';\n  subject: Term;\n  predicate: TermIri | TermVariable;\n  object: Term;\n};\n\nexport type Term = GraphTerm | TermVariable;\nexport type GraphTerm = TermIri | TermBlank | TermLiteral | TermTriple;\n"]}

package/lib/validator.d.ts

@@ -0,0 +1,2 @@
+import type { TermLiteral } from './sparql12Types';
+export declare function langTagHasCorrectDomain(literal: TermLiteral): void;

package/lib/validator.js

@@ -0,0 +1,17 @@
+import { Factory } from '@traqula/rules-sparql-1-1';
+const F = new Factory();
+function isLangDir(dir) {
+    return dir === 'ltr' || dir === 'rtl';
+}
+export function langTagHasCorrectDomain(literal) {
+    if (F.isTermLiteralLangStr(literal)) {
+        const dirSplit = literal.langOrIri.split('--');
+        if (dirSplit.length > 1) {
+            const [_, direction] = dirSplit;
+            if (!isLangDir(direction)) {
+                throw new Error(`language direction "${direction}" of literal "${JSON.stringify(literal)}" is not is required range 'ltr' | 'rtl'.`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=validator.js.map

package/lib/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","sourceRoot":"","sources":["validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAGpD,MAAM,CAAC,GAAG,IAAI,OAAO,EAAE,CAAC;AAExB,SAAS,SAAS,CAAC,GAAW;IAC5B,OAAO,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK,CAAC;AACxC,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,OAAoB;IAC1D,IAAI,CAAC,CAAC,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC;QACpC,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC/C,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,CAAE,CAAC,EAAE,SAAS,CAAE,GAAG,QAAQ,CAAC;YAClC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC;gBAC1B,MAAM,IAAI,KAAK,CAAC,uBAAuB,SAAS,iBAAiB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,2CAA2C,CAAC,CAAC;YACvI,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC","sourcesContent":["import { Factory } from '@traqula/rules-sparql-1-1';\nimport type { TermLiteral } from './sparql12Types';\n\nconst F = new Factory();\n\nfunction isLangDir(dir: string): dir is 'ltr' | 'rtl' {\n  return dir === 'ltr' || dir === 'rtl';\n}\n\nexport function langTagHasCorrectDomain(literal: TermLiteral): void {\n  if (F.isTermLiteralLangStr(literal)) {\n    const dirSplit = literal.langOrIri.split('--');\n    if (dirSplit.length > 1) {\n      const [ _, direction ] = dirSplit;\n      if (!isLangDir(direction)) {\n        throw new Error(`language direction \"${direction}\" of literal \"${JSON.stringify(literal)}\" is not is required range 'ltr' | 'rtl'.`);\n      }\n    }\n  }\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@traqula/rules-sparql-1-2",
   "type": "module",
-  "version": "0.0.1-alpha.176+9400dc5",
+  "version": "0.0.1-alpha.9+427f381",
   "description": "Traqula Lexer and Grammar Rules for sparql 1.2",
   "lsd:module": true,
   "license": "MIT",
@@ -38,11 +38,8 @@
     "build:transpile": " node \"../../node_modules/esbuild/bin/esbuild\" --format=cjs --bundle --log-level=error --outfile=lib/index.cjs lib/index.ts"
   },
   "dependencies": {
-    "@traqula/core": "^0.0.1-alpha.176+9400dc5",
-    "@traqula/rules-sparql-1-1": "^0.0.1-alpha.176+9400dc5"
+    "@traqula/core": "^0.0.1-alpha.9+427f381",
+    "@traqula/rules-sparql-1-1": "^0.0.1-alpha.9+427f381"
   },
-  "devDependencies": {
-    "@rdfjs/types": "^2.0.0"
-  },
-  "gitHead": "9400dc5f8bda1d8c2b3d1f4cf56b308995744ba0"
+  "gitHead": "427f3819138dd557621cae40c761213573e60017"
 }