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

package/lib/factoryMixins/UpdateOperationFactory.js

@@ -0,0 +1,126 @@
+const nodeType = 'updateOperation';
+// eslint-disable-next-line ts/explicit-function-return-type
+export function UpdateOperationFactoryMixin(Base) {
+    return class UpdateOperationFactory extends Base {
+        isUpdateOperation(obj) {
+            return this.isOfType(obj, nodeType);
+        }
+        updateOperationLoad(loc, source, silent, destination) {
+            return {
+                type: nodeType,
+                subType: 'load',
+                silent,
+                source,
+                ...(destination && { destination }),
+                loc,
+            };
+        }
+        isUpdateOperationLoad(obj) {
+            return this.isOfSubType(obj, nodeType, 'load');
+        }
+        updateOperationClearDrop(subType, silent, destination, loc) {
+            return {
+                type: 'updateOperation',
+                subType,
+                silent,
+                destination,
+                loc,
+            };
+        }
+        updateOperationClear(destination, silent, loc) {
+            return this.updateOperationClearDrop('clear', silent, destination, loc);
+        }
+        ;
+        isUpdateOperationClear(obj) {
+            return this.isOfSubType(obj, nodeType, 'clear');
+        }
+        updateOperationDrop(destination, silent, loc) {
+            return this.updateOperationClearDrop('drop', silent, destination, loc);
+        }
+        isUpdateOperationDrop(obj) {
+            return this.isOfSubType(obj, nodeType, 'drop');
+        }
+        updateOperationCreate(destination, silent, loc) {
+            return {
+                type: 'updateOperation',
+                subType: 'create',
+                silent,
+                destination,
+                loc,
+            };
+        }
+        isUpdateOperationCreate(obj) {
+            return this.isOfSubType(obj, nodeType, 'create');
+        }
+        updateOperationAddMoveCopy(subType, source, destination, silent, loc) {
+            return {
+                type: 'updateOperation',
+                subType,
+                silent,
+                source,
+                destination,
+                loc,
+            };
+        }
+        updateOperationAdd(source, destination, silent, loc) {
+            return this.updateOperationAddMoveCopy('add', source, destination, silent, loc);
+        }
+        isUpdateOperationAdd(obj) {
+            return this.isOfSubType(obj, nodeType, 'add');
+        }
+        updateOperationMove(source, destination, silent, loc) {
+            return this.updateOperationAddMoveCopy('move', source, destination, silent, loc);
+        }
+        isUpdateOperationMove(obj) {
+            return this.isOfSubType(obj, nodeType, 'move');
+        }
+        updateOperationCopy(source, destination, silent, loc) {
+            return this.updateOperationAddMoveCopy('copy', source, destination, silent, loc);
+        }
+        isUpdateOperationCopy(obj) {
+            return this.isOfSubType(obj, nodeType, 'copy');
+        }
+        updateOperationInsDelDataWhere(subType, data, loc) {
+            return {
+                type: 'updateOperation',
+                subType,
+                data,
+                loc,
+            };
+        }
+        updateOperationInsertData(data, loc) {
+            return this.updateOperationInsDelDataWhere('insertdata', data, loc);
+        }
+        isUpdateOperationInsertData(obj) {
+            return this.isOfSubType(obj, nodeType, 'insertdata');
+        }
+        updateOperationDeleteData(data, loc) {
+            return this.updateOperationInsDelDataWhere('deletedata', data, loc);
+        }
+        isUpdateOperationDeleteData(obj) {
+            return this.isOfSubType(obj, nodeType, 'deletedata');
+        }
+        updateOperationDeleteWhere(data, loc) {
+            return this.updateOperationInsDelDataWhere('deletewhere', data, loc);
+        }
+        isUpdateOperationDeleteWhere(obj) {
+            return this.isOfSubType(obj, nodeType, 'deletewhere');
+        }
+        updateOperationModify(loc, insert, del, where, from, graph) {
+            return {
+                type: 'updateOperation',
+                subType: 'modify',
+                insert: insert ?? [],
+                delete: del ?? [],
+                graph,
+                where,
+                from,
+                loc,
+            };
+        }
+        isUpdateOperationModify(obj) {
+            return this.isOfSubType(obj, nodeType, 'modify');
+        }
+    };
+}
+//# sourceMappingURL=UpdateOperationFactory.js.map

package/lib/factoryMixins/UpdateOperationFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateOperationFactory.js","sourceRoot":"","sources":["UpdateOperationFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CoreFactory, SourceLocation, SubTyped, Typed } from '@traqula/core';\nimport type {\n  DatasetClauses,\n  GraphRef,\n  GraphRefDefault,\n  GraphRefSpecific,\n  PatternGroup,\n  Quads,\n  TermIri,\n  UpdateOperationAdd,\n  UpdateOperationClear,\n  UpdateOperationCopy,\n  UpdateOperationCreate,\n  UpdateOperationDeleteData,\n  UpdateOperationDeleteWhere,\n  UpdateOperationDrop,\n  UpdateOperationInsertData,\n  UpdateOperationLoad,\n  UpdateOperationModify,\n  UpdateOperationMove,\n} from '../RoundTripTypes';\nimport type { Constructor } from './mixins';\n\ntype NodeType = 'updateOperation';\nconst nodeType: NodeType = 'updateOperation';\n\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function UpdateOperationFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase) {\n  return class UpdateOperationFactory extends Base {\n    public isUpdateOperation(obj: object): obj is Typed<NodeType> {\n      return this.isOfType(obj, nodeType);\n    }\n\n    public updateOperationLoad(\n      loc: SourceLocation,\n      source: TermIri,\n      silent: boolean,\n      destination?: GraphRefSpecific | undefined,\n    ): UpdateOperationLoad {\n      return {\n        type: nodeType,\n        subType: 'load',\n        silent,\n        source,\n        ...(destination && { destination }),\n        loc,\n      };\n    }\n\n    public isUpdateOperationLoad(obj: object): obj is SubTyped<NodeType, 'load'> {\n      return this.isOfSubType(obj, nodeType, 'load');\n    }\n\n    public updateOperationClearDrop(subType: 'clear', silent: boolean, destination: GraphRef, loc: SourceLocation):\n    UpdateOperationClear;\n    public updateOperationClearDrop(subType: 'drop', silent: boolean, destination: GraphRef, loc: SourceLocation):\n    UpdateOperationDrop;\n    public updateOperationClearDrop(\n      subType: 'clear' | 'drop',\n      silent: boolean,\n      destination: GraphRef,\n      loc: SourceLocation\n    ): UpdateOperationClear | UpdateOperationDrop;\n    public updateOperationClearDrop(\n      subType: 'clear' | 'drop',\n      silent: boolean,\n      destination: GraphRef,\n      loc: SourceLocation,\n    ): UpdateOperationClear | UpdateOperationDrop {\n      return {\n        type: 'updateOperation',\n        subType,\n        silent,\n        destination,\n        loc,\n      };\n    }\n\n    public updateOperationClear(\n      destination: GraphRef,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationClear {\n      return this.updateOperationClearDrop('clear', silent, destination, loc);\n    };\n\n    public isUpdateOperationClear(obj: object): obj is SubTyped<NodeType, 'clear'> {\n      return this.isOfSubType(obj, nodeType, 'clear');\n    }\n\n    public updateOperationDrop(\n      destination: GraphRef,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationDrop {\n      return this.updateOperationClearDrop('drop', silent, destination, loc);\n    }\n\n    public isUpdateOperationDrop(obj: object): obj is SubTyped<NodeType, 'drop'> {\n      return this.isOfSubType(obj, nodeType, 'drop');\n    }\n\n    public updateOperationCreate(\n      destination: GraphRefSpecific,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationCreate {\n      return {\n        type: 'updateOperation',\n        subType: 'create',\n        silent,\n        destination,\n        loc,\n      };\n    }\n\n    public isUpdateOperationCreate(obj: object): obj is SubTyped<NodeType, 'create'> {\n      return this.isOfSubType(obj, nodeType, 'create');\n    }\n\n    public updateOperationAddMoveCopy(\n      subType: 'add',\n      source: GraphRefDefault | GraphRefSpecific,\n      destination: GraphRefDefault | GraphRefSpecific,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationAdd;\n    public updateOperationAddMoveCopy(\n      subType: 'move',\n      source: GraphRefDefault | GraphRefSpecific,\n      destination: GraphRefDefault | GraphRefSpecific,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationMove ;\n    public updateOperationAddMoveCopy(\n      subType: 'copy',\n      source: GraphRefDefault | GraphRefSpecific,\n      destination: GraphRefDefault | GraphRefSpecific,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationCopy;\n    public updateOperationAddMoveCopy(\n      subType: 'add' | 'move' | 'copy',\n      source: GraphRefDefault | GraphRefSpecific,\n      destination: GraphRefDefault | GraphRefSpecific,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationAdd | UpdateOperationMove | UpdateOperationCopy;\n    public updateOperationAddMoveCopy(\n      subType: 'add' | 'move' | 'copy',\n      source: GraphRefDefault | GraphRefSpecific,\n      destination: GraphRefDefault | GraphRefSpecific,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationAdd | UpdateOperationMove | UpdateOperationCopy {\n      return {\n        type: 'updateOperation',\n        subType,\n        silent,\n        source,\n        destination,\n        loc,\n      };\n    }\n\n    public updateOperationAdd(\n      source: GraphRefDefault | GraphRefSpecific,\n      destination: GraphRefDefault | GraphRefSpecific,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationAdd {\n      return this.updateOperationAddMoveCopy('add', source, destination, silent, loc);\n    }\n\n    public isUpdateOperationAdd(obj: object): obj is SubTyped<NodeType, 'add'> {\n      return this.isOfSubType(obj, nodeType, 'add');\n    }\n\n    public updateOperationMove(\n      source: GraphRefDefault | GraphRefSpecific,\n      destination: GraphRefDefault | GraphRefSpecific,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationMove {\n      return this.updateOperationAddMoveCopy('move', source, destination, silent, loc);\n    }\n\n    public isUpdateOperationMove(obj: object): obj is SubTyped<NodeType, 'move'> {\n      return this.isOfSubType(obj, nodeType, 'move');\n    }\n\n    public updateOperationCopy(\n      source: GraphRefDefault | GraphRefSpecific,\n      destination: GraphRefDefault | GraphRefSpecific,\n      silent: boolean,\n      loc: SourceLocation,\n    ): UpdateOperationCopy {\n      return this.updateOperationAddMoveCopy('copy', source, destination, silent, loc);\n    }\n\n    public isUpdateOperationCopy(obj: object): obj is SubTyped<NodeType, 'copy'> {\n      return this.isOfSubType(obj, nodeType, 'copy');\n    }\n\n    public updateOperationInsDelDataWhere(subType: 'insertdata', data: Quads[], loc: SourceLocation):\n    UpdateOperationInsertData;\n    public updateOperationInsDelDataWhere(subType: 'deletedata', data: Quads[], loc: SourceLocation):\n    UpdateOperationDeleteData;\n    public updateOperationInsDelDataWhere(subType: 'deletewhere', data: Quads[], loc: SourceLocation):\n    UpdateOperationDeleteWhere;\n    public updateOperationInsDelDataWhere(\n      subType: 'insertdata' | 'deletedata' | 'deletewhere',\n      data: Quads[],\n      loc: SourceLocation,\n    ): UpdateOperationInsertData | UpdateOperationDeleteData | UpdateOperationDeleteWhere;\n    public updateOperationInsDelDataWhere(\n      subType: 'insertdata' | 'deletedata' | 'deletewhere',\n      data: Quads[],\n      loc: SourceLocation,\n    ): UpdateOperationInsertData | UpdateOperationDeleteData | UpdateOperationDeleteWhere {\n      return {\n        type: 'updateOperation',\n        subType,\n        data,\n        loc,\n      };\n    }\n\n    public updateOperationInsertData(data: Quads[], loc: SourceLocation): UpdateOperationInsertData {\n      return this.updateOperationInsDelDataWhere('insertdata', data, loc);\n    }\n\n    public isUpdateOperationInsertData(obj: object): obj is SubTyped<NodeType, 'insertdata'> {\n      return this.isOfSubType(obj, nodeType, 'insertdata');\n    }\n\n    public updateOperationDeleteData(data: Quads[], loc: SourceLocation): UpdateOperationDeleteData {\n      return this.updateOperationInsDelDataWhere('deletedata', data, loc);\n    }\n\n    public isUpdateOperationDeleteData(obj: object): obj is SubTyped<NodeType, 'deletedata'> {\n      return this.isOfSubType(obj, nodeType, 'deletedata');\n    }\n\n    public updateOperationDeleteWhere(data: Quads[], loc: SourceLocation): UpdateOperationDeleteWhere {\n      return this.updateOperationInsDelDataWhere('deletewhere', data, loc);\n    }\n\n    public isUpdateOperationDeleteWhere(obj: object): obj is SubTyped<NodeType, 'deletewhere'> {\n      return this.isOfSubType(obj, nodeType, 'deletewhere');\n    }\n\n    public updateOperationModify(\n      loc: SourceLocation,\n      insert: Quads[] | undefined,\n      del: Quads[] | undefined,\n      where: PatternGroup,\n      from: DatasetClauses,\n      graph?: TermIri | undefined,\n    ): UpdateOperationModify {\n      return {\n        type: 'updateOperation',\n        subType: 'modify',\n        insert: insert ?? [],\n        delete: del ?? [],\n        graph,\n        where,\n        from,\n        loc,\n      };\n    }\n\n    public isUpdateOperationModify(obj: object): obj is SubTyped<NodeType, 'modify'> {\n      return this.isOfSubType(obj, nodeType, 'modify');\n    }\n  };\n}\n"]}

package/lib/factoryMixins/mixins.d.ts

@@ -0,0 +1,14 @@
+/**
+ * We use mixins as explained by the official TypeScript documentation:
+ * https://www.typescriptlang.org/docs/handbook/mixins.html
+ */
+export type Constructor<T = object> = new (...args: any[]) => T;
+export type Mixin<Base = object, U extends Base = Base> = (superclass: Constructor<Base>) => Constructor<U>;
+export declare function asArg<T>(arg: T): FlatCall<T>;
+declare class FlatCall<Input> {
+    private input;
+    constructor(input: Input);
+    call<Out>(func: (input: Input) => Out): FlatCall<Out>;
+    returns(): Input;
+}
+export {};

package/lib/factoryMixins/mixins.js

@@ -0,0 +1,20 @@
+/**
+ * We use mixins as explained by the official TypeScript documentation:
+ * https://www.typescriptlang.org/docs/handbook/mixins.html
+ */
+export function asArg(arg) {
+    return new FlatCall(arg);
+}
+class FlatCall {
+    constructor(input) {
+        this.input = input;
+    }
+    call(func) {
+        this.input = func(this.input);
+        return this;
+    }
+    returns() {
+        return this.input;
+    }
+}
+//# sourceMappingURL=mixins.js.map

package/lib/factoryMixins/mixins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixins.js","sourceRoot":"","sources":["mixins.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,UAAU,KAAK,CAAI,GAAM;IAC7B,OAAO,IAAI,QAAQ,CAAI,GAAG,CAAC,CAAC;AAC9B,CAAC;AAED,MAAM,QAAQ;IACZ,YAA2B,KAAY;QAAZ,UAAK,GAAL,KAAK,CAAO;IAAG,CAAC;IACpC,IAAI,CAAM,IAA2B;QAC1C,IAAI,CAAC,KAAK,GAAqB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChD,OAAiC,IAAI,CAAC;IACxC,CAAC;IAEM,OAAO;QACZ,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;CACF","sourcesContent":["/**\n * We use mixins as explained by the official TypeScript documentation:\n * https://www.typescriptlang.org/docs/handbook/mixins.html\n */\n\nexport type Constructor<T = object> = new (...args: any[]) => T;\n\nexport type Mixin<Base = object, U extends Base = Base> = (superclass: Constructor<Base>) => Constructor<U>;\n\nexport function asArg<T>(arg: T): FlatCall<T> {\n  return new FlatCall<T>(arg);\n}\n\nclass FlatCall<Input> {\n  public constructor(private input: Input) {}\n  public call<Out>(func: (input: Input) => Out): FlatCall<Out> {\n    this.input = <Input> <unknown> func(this.input);\n    return <FlatCall<Out>> <unknown> this;\n  }\n\n  public returns(): Input {\n    return this.input;\n  }\n}\n"]}

package/lib/grammar/builtIn.d.ts

@@ -1,56 +1,56 @@
 import type { IOrAlt } from '@chevrotain/types';
 import type { ImplArgs } from '@traqula/core';
-import type { RuleDefExpressionFunctionX } from '../expressionHelpers';
-import type { AggregateExpression, Expression, SparqlGrammarRule, SparqlRule } from '../Sparql11types';
-export declare const builtInStr: RuleDefExpressionFunctionX<"builtInStr", [Expression]>;
-export declare const builtInLang: RuleDefExpressionFunctionX<"builtInLang", [Expression]>;
-export declare const builtInLangmatches: RuleDefExpressionFunctionX<"builtInLangmatches", [Expression, Expression]>;
-export declare const builtInDatatype: RuleDefExpressionFunctionX<"builtInDatatype", [Expression]>;
-export declare const builtInBound: RuleDefExpressionFunctionX<"builtInBound", [import("@rdfjs/types").Variable]>;
-export declare const builtInIri: RuleDefExpressionFunctionX<"builtInIri", [Expression]>;
-export declare const builtInUri: RuleDefExpressionFunctionX<"builtInUri", [Expression]>;
-export declare const builtInBnodeSparqlJs: RuleDefExpressionFunctionX<Uncapitalize<'builtInBnode'>, [] | [Expression]>;
-export declare const builtInRand: RuleDefExpressionFunctionX<"builtInRand", []>;
-export declare const builtInAbs: RuleDefExpressionFunctionX<"builtInAbs", [Expression]>;
-export declare const builtInCeil: RuleDefExpressionFunctionX<"builtInCeil", [Expression]>;
-export declare const builtInFloor: RuleDefExpressionFunctionX<"builtInFloor", [Expression]>;
-export declare const builtInRound: RuleDefExpressionFunctionX<"builtInRound", [Expression]>;
-export declare const builtInConcat: RuleDefExpressionFunctionX<"builtInConcat", Expression[]>;
-export declare const builtInStrlen: RuleDefExpressionFunctionX<"builtInStrlen", [Expression]>;
-export declare const builtInUcase: RuleDefExpressionFunctionX<"builtInUcase", [Expression]>;
-export declare const builtInLcase: RuleDefExpressionFunctionX<"builtInLcase", [Expression]>;
-export declare const builtInEncode_for_uri: RuleDefExpressionFunctionX<"builtInEncode_for_uri", [Expression]>;
-export declare const builtInContains: RuleDefExpressionFunctionX<"builtInContains", [Expression, Expression]>;
-export declare const builtInStrstarts: RuleDefExpressionFunctionX<"builtInStrstarts", [Expression, Expression]>;
-export declare const builtInStrends: RuleDefExpressionFunctionX<"builtInStrends", [Expression, Expression]>;
-export declare const builtInStrbefore: RuleDefExpressionFunctionX<"builtInStrbefore", [Expression, Expression]>;
-export declare const builtInStrafter: RuleDefExpressionFunctionX<"builtInStrafter", [Expression, Expression]>;
-export declare const builtInYear: RuleDefExpressionFunctionX<"builtInYear", [Expression]>;
-export declare const builtInMonth: RuleDefExpressionFunctionX<"builtInMonth", [Expression]>;
-export declare const builtInDay: RuleDefExpressionFunctionX<"builtInDay", [Expression]>;
-export declare const builtInHours: RuleDefExpressionFunctionX<"builtInHours", [Expression]>;
-export declare const builtInMinutes: RuleDefExpressionFunctionX<"builtInMinutes", [Expression]>;
-export declare const builtInSeconds: RuleDefExpressionFunctionX<"builtInSeconds", [Expression]>;
-export declare const builtInTimezone: RuleDefExpressionFunctionX<"builtInTimezone", [Expression]>;
-export declare const builtInTz: RuleDefExpressionFunctionX<"builtInTz", [Expression]>;
-export declare const builtInNow: RuleDefExpressionFunctionX<"builtInNow", []>;
-export declare const builtInUuid: RuleDefExpressionFunctionX<"builtInUuid", []>;
-export declare const builtInStruuid: RuleDefExpressionFunctionX<"builtInStruuid", []>;
-export declare const builtInMd5: RuleDefExpressionFunctionX<"builtInMd5", [Expression]>;
-export declare const builtInSha1: RuleDefExpressionFunctionX<"builtInSha1", [Expression]>;
-export declare const builtInSha256: RuleDefExpressionFunctionX<"builtInSha256", [Expression]>;
-export declare const builtInSha384: RuleDefExpressionFunctionX<"builtInSha384", [Expression]>;
-export declare const builtInSha512: RuleDefExpressionFunctionX<"builtInSha512", [Expression]>;
-export declare const builtInCoalesce: RuleDefExpressionFunctionX<"builtInCoalesce", Expression[]>;
-export declare const builtInIf: RuleDefExpressionFunctionX<"builtInIf", [Expression, Expression, Expression]>;
-export declare const builtInStrlang: RuleDefExpressionFunctionX<"builtInStrlang", [Expression, Expression]>;
-export declare const builtInStrdt: RuleDefExpressionFunctionX<"builtInStrdt", [Expression, Expression]>;
-export declare const builtInSameterm: RuleDefExpressionFunctionX<"builtInSameterm", [Expression, Expression]>;
-export declare const builtInIsiri: RuleDefExpressionFunctionX<"builtInIsiri", [Expression]>;
-export declare const builtInIsuri: RuleDefExpressionFunctionX<"builtInIsuri", [Expression]>;
-export declare const builtInIsblank: RuleDefExpressionFunctionX<"builtInIsblank", [Expression]>;
-export declare const builtInIsliteral: RuleDefExpressionFunctionX<"builtInIsliteral", [Expression]>;
-export declare const builtInIsnumeric: RuleDefExpressionFunctionX<"builtInIsnumeric", [Expression]>;
+import type { Expression, ExpressionAggregate, ExpressionAggregateDefault, ExpressionAggregateOnWildcard, ExpressionAggregateSeparator } from '../RoundTripTypes';
+import type { SparqlGrammarRule, SparqlRule } from '../Sparql11types';
+export declare const builtInStr: import(".").RuleDefExpressionFunctionX<"builtInStr", [Expression]>;
+export declare const builtInLang: import(".").RuleDefExpressionFunctionX<"builtInLang", [Expression]>;
+export declare const builtInLangmatches: import(".").RuleDefExpressionFunctionX<"builtInLangmatches", [Expression, Expression]>;
+export declare const builtInDatatype: import(".").RuleDefExpressionFunctionX<"builtInDatatype", [Expression]>;
+export declare const builtInBound: import(".").RuleDefExpressionFunctionX<"builtInBound", [import("..").TermVariable]>;
+export declare const builtInIri: import(".").RuleDefExpressionFunctionX<"builtInIri", [Expression]>;
+export declare const builtInUri: import(".").RuleDefExpressionFunctionX<"builtInUri", [Expression]>;
+export declare const builtInBnodeSparqlJs: import(".").RuleDefExpressionFunctionX<"builtInBnode", [] | [Expression]>;
+export declare const builtInRand: import(".").RuleDefExpressionFunctionX<"builtInRand", []>;
+export declare const builtInAbs: import(".").RuleDefExpressionFunctionX<"builtInAbs", [Expression]>;
+export declare const builtInCeil: import(".").RuleDefExpressionFunctionX<"builtInCeil", [Expression]>;
+export declare const builtInFloor: import(".").RuleDefExpressionFunctionX<"builtInFloor", [Expression]>;
+export declare const builtInRound: import(".").RuleDefExpressionFunctionX<"builtInRound", [Expression]>;
+export declare const builtInConcat: import(".").RuleDefExpressionFunctionX<"builtInConcat", Expression[]>;
+export declare const builtInStrlen: import(".").RuleDefExpressionFunctionX<"builtInStrlen", [Expression]>;
+export declare const builtInUcase: import(".").RuleDefExpressionFunctionX<"builtInUcase", [Expression]>;
+export declare const builtInLcase: import(".").RuleDefExpressionFunctionX<"builtInLcase", [Expression]>;
+export declare const builtInEncode_for_uri: import(".").RuleDefExpressionFunctionX<"builtInEncode_for_uri", [Expression]>;
+export declare const builtInContains: import(".").RuleDefExpressionFunctionX<"builtInContains", [Expression, Expression]>;
+export declare const builtInStrstarts: import(".").RuleDefExpressionFunctionX<"builtInStrstarts", [Expression, Expression]>;
+export declare const builtInStrends: import(".").RuleDefExpressionFunctionX<"builtInStrends", [Expression, Expression]>;
+export declare const builtInStrbefore: import(".").RuleDefExpressionFunctionX<"builtInStrbefore", [Expression, Expression]>;
+export declare const builtInStrafter: import(".").RuleDefExpressionFunctionX<"builtInStrafter", [Expression, Expression]>;
+export declare const builtInYear: import(".").RuleDefExpressionFunctionX<"builtInYear", [Expression]>;
+export declare const builtInMonth: import(".").RuleDefExpressionFunctionX<"builtInMonth", [Expression]>;
+export declare const builtInDay: import(".").RuleDefExpressionFunctionX<"builtInDay", [Expression]>;
+export declare const builtInHours: import(".").RuleDefExpressionFunctionX<"builtInHours", [Expression]>;
+export declare const builtInMinutes: import(".").RuleDefExpressionFunctionX<"builtInMinutes", [Expression]>;
+export declare const builtInSeconds: import(".").RuleDefExpressionFunctionX<"builtInSeconds", [Expression]>;
+export declare const builtInTimezone: import(".").RuleDefExpressionFunctionX<"builtInTimezone", [Expression]>;
+export declare const builtInTz: import(".").RuleDefExpressionFunctionX<"builtInTz", [Expression]>;
+export declare const builtInNow: import(".").RuleDefExpressionFunctionX<"builtInNow", []>;
+export declare const builtInUuid: import(".").RuleDefExpressionFunctionX<"builtInUuid", []>;
+export declare const builtInStruuid: import(".").RuleDefExpressionFunctionX<"builtInStruuid", []>;
+export declare const builtInMd5: import(".").RuleDefExpressionFunctionX<"builtInMd5", [Expression]>;
+export declare const builtInSha1: import(".").RuleDefExpressionFunctionX<"builtInSha1", [Expression]>;
+export declare const builtInSha256: import(".").RuleDefExpressionFunctionX<"builtInSha256", [Expression]>;
+export declare const builtInSha384: import(".").RuleDefExpressionFunctionX<"builtInSha384", [Expression]>;
+export declare const builtInSha512: import(".").RuleDefExpressionFunctionX<"builtInSha512", [Expression]>;
+export declare const builtInCoalesce: import(".").RuleDefExpressionFunctionX<"builtInCoalesce", Expression[]>;
+export declare const builtInIf: import(".").RuleDefExpressionFunctionX<"builtInIf", [Expression, Expression, Expression]>;
+export declare const builtInStrlang: import(".").RuleDefExpressionFunctionX<"builtInStrlang", [Expression, Expression]>;
+export declare const builtInStrdt: import(".").RuleDefExpressionFunctionX<"builtInStrdt", [Expression, Expression]>;
+export declare const builtInSameterm: import(".").RuleDefExpressionFunctionX<"builtInSameterm", [Expression, Expression]>;
+export declare const builtInIsiri: import(".").RuleDefExpressionFunctionX<"builtInIsiri", [Expression]>;
+export declare const builtInIsuri: import(".").RuleDefExpressionFunctionX<"builtInIsuri", [Expression]>;
+export declare const builtInIsblank: import(".").RuleDefExpressionFunctionX<"builtInIsblank", [Expression]>;
+export declare const builtInIsliteral: import(".").RuleDefExpressionFunctionX<"builtInIsliteral", [Expression]>;
+export declare const builtInIsnumeric: import(".").RuleDefExpressionFunctionX<"builtInIsnumeric", [Expression]>;
 export declare function builtInCallList(SUBRULE: ImplArgs['SUBRULE']): IOrAlt<Expression>[];
 /**
  * [[121]](https://www.w3.org/TR/sparql11-query/#rBuiltInCall)
@@ -59,31 +59,31 @@ export declare const builtInCall: SparqlGrammarRule<'builtInCall', Expression>;
 /**
  * [[122]](https://www.w3.org/TR/sparql11-query/#rBuiltInCall)
  */
-export declare const regexExpression: RuleDefExpressionFunctionX<"builtInRegex", [Expression, Expression] | [Expression, Expression, Expression]>;
+export declare const regexExpression: import(".").RuleDefExpressionFunctionX<"builtInRegex", [Expression, Expression] | [Expression, Expression, Expression]>;
 /**
  * [[123]](https://www.w3.org/TR/sparql11-query/#rBuiltInCall)
  */
-export declare const substringExpression: RuleDefExpressionFunctionX<"builtInSubstr", [Expression, Expression] | [Expression, Expression, Expression]>;
+export declare const substringExpression: import(".").RuleDefExpressionFunctionX<"builtInSubstr", [Expression, Expression] | [Expression, Expression, Expression]>;
 /**
  * [[124]](https://www.w3.org/TR/sparql11-query/#rBuiltInCall)
  */
-export declare const strReplaceExpression: RuleDefExpressionFunctionX<"builtInReplace", [Expression, Expression, Expression] | [Expression, Expression, Expression, Expression]>;
+export declare const strReplaceExpression: import(".").RuleDefExpressionFunctionX<"builtInReplace", [Expression, Expression, Expression] | [Expression, Expression, Expression, Expression]>;
 /**
  * [[125]](https://www.w3.org/TR/sparql11-query/#rBuiltInCall)
  */
-export declare const existsFunc: RuleDefExpressionFunctionX<"builtInExists", [import("..").Pattern]>;
+export declare const existsFunc: SparqlGrammarRule<"builtInExists", import("..").ExpressionPatternOperation>;
 /**
  * [[126]](https://www.w3.org/TR/sparql11-query/#rBuiltInCall)
  */
-export declare const notExistsFunc: RuleDefExpressionFunctionX<"builtInNotexists", [import("..").Pattern]>;
-export declare const aggregateCount: import(".").RuleDefExpressionAggregatorX<"builtInCount">;
+export declare const notExistsFunc: SparqlGrammarRule<"builtInNotexists", import("..").ExpressionPatternOperation>;
+export declare const aggregateCount: SparqlGrammarRule<'builtInCount', ExpressionAggregateOnWildcard | ExpressionAggregateDefault>;
 export declare const aggregateSum: import(".").RuleDefExpressionAggregatorX<"builtInSum">;
 export declare const aggregateMin: import(".").RuleDefExpressionAggregatorX<"builtInMin">;
 export declare const aggregateMax: import(".").RuleDefExpressionAggregatorX<"builtInMax">;
 export declare const aggregateAvg: import(".").RuleDefExpressionAggregatorX<"builtInAvg">;
 export declare const aggregateSample: import(".").RuleDefExpressionAggregatorX<"builtInSample">;
-export declare const aggregateGroup_concat: SparqlGrammarRule<'builtInGroup_concat', AggregateExpression>;
+export declare const aggregateGroup_concat: SparqlGrammarRule<'builtInGroup_concat', ExpressionAggregateDefault | ExpressionAggregateSeparator>;
 /**
  * [[127]](https://www.w3.org/TR/sparql11-query/#rBuiltInCall)
  */
-export declare const aggregate: SparqlRule<'aggregate', AggregateExpression>;
+export declare const aggregate: SparqlRule<'aggregate', ExpressionAggregate>;

package/lib/grammar/builtIn.js

@@ -1,8 +1,8 @@
 import { unCapitalize, } from '@traqula/core';
-import { baseAggregateFunc, funcExpr1, funcExpr2, funcExpr2or3, funcExpr3, funcExpr3or4, funcExprList1, funcGroupGraphPattern, funcNil1, funcVar1, } from '../expressionHelpers';
+import { funcExprOrNil1, baseAggregateFunc, funcExpr1, funcExpr2, funcExpr2or3, funcExpr3, funcExpr3or4, funcExprList1, funcGroupGraphPattern, funcNil1, funcVar1, } from '../expressionHelpers';
 import * as l from '../lexer';
 import { expression } from './expression';
-import { string } from './literals';
+import { string, stringEscapedLexical } from './literals';
 export const builtInStr = funcExpr1(l.builtIn.str);
 export const builtInLang = funcExpr1(l.builtIn.lang);
 export const builtInLangmatches = funcExpr2(l.builtIn.langmatches);
@@ -10,35 +10,7 @@ export const builtInDatatype = funcExpr1(l.builtIn.datatype);
 export const builtInBound = funcVar1(l.builtIn.bound);
 export const builtInIri = funcExpr1(l.builtIn.iri);
 export const builtInUri = funcExpr1(l.builtIn.uri);
-// Todo: so ugly, just to be compatible with sparqlJS
-export const builtInBnodeSparqlJs = {
-    name: 'builtInBnode',
-    impl: ({ CONSUME, OR, SUBRULE }) => () => {
-        const operator = CONSUME(l.builtIn.bnode);
-        const args = OR([
-            {
-                ALT: () => {
-                    CONSUME(l.symbols.LParen);
-                    const arg = SUBRULE(expression, undefined);
-                    CONSUME(l.symbols.RParen);
-                    return [arg];
-                },
-            },
-            {
-                ALT: () => {
-                    CONSUME(l.terminals.nil);
-                    return [];
-                },
-            },
-        ]);
-        return {
-            type: 'operation',
-            operator: operator.image,
-            args,
-        };
-    },
-};
-// Export const builtInBnode = funcExprOrNil1(l.builtIn.bnode);
+export const builtInBnodeSparqlJs = funcExprOrNil1(l.builtIn.bnode);
 export const builtInRand = funcNil1(l.builtIn.rand);
 export const builtInAbs = funcExpr1(l.builtIn.abs);
 export const builtInCeil = funcExpr1(l.builtIn.ceil);
@@ -174,7 +146,29 @@ export const existsFunc = funcGroupGraphPattern(l.builtIn.exists);
  * [[126]](https://www.w3.org/TR/sparql11-query/#rBuiltInCall)
  */
 export const notExistsFunc = funcGroupGraphPattern(l.builtIn.notexists);
-export const aggregateCount = baseAggregateFunc(l.builtIn.count);
+export const aggregateCount = {
+    name: unCapitalize(l.builtIn.count.name),
+    impl: ({ ACTION, CONSUME, SUBRULE, OR, OPTION }) => (C) => {
+        const operatorToken = CONSUME(l.builtIn.count);
+        CONSUME(l.symbols.LParen);
+        const distinctToken = OPTION(() => CONSUME(l.distinct));
+        const expressionVal = OR([
+            { ALT: () => {
+                    const starToken = CONSUME(l.symbols.star);
+                    return ACTION(() => C.factory.wildcard(C.factory.sourceLocation(starToken)));
+                } },
+            { ALT: () => SUBRULE(expression, undefined) },
+        ]);
+        const closeToken = CONSUME(l.symbols.RParen);
+        return ACTION(() => {
+            const F = C.factory;
+            if (C.factory.isWildcard(expressionVal)) {
+                return F.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, undefined, C.factory.sourceLocation(operatorToken, closeToken));
+            }
+            return F.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, undefined, C.factory.sourceLocation(operatorToken, closeToken));
+        });
+    },
+};
 export const aggregateSum = baseAggregateFunc(l.builtIn.sum);
 export const aggregateMin = baseAggregateFunc(l.builtIn.min);
 export const aggregateMax = baseAggregateFunc(l.builtIn.max);
@@ -182,25 +176,22 @@ export const aggregateAvg = baseAggregateFunc(l.builtIn.avg);
 export const aggregateSample = baseAggregateFunc(l.builtIn.sample);
 export const aggregateGroup_concat = {
     name: unCapitalize(l.builtIn.groupConcat.name),
-    impl: ({ CONSUME, OPTION1, SUBRULE, OPTION2 }) => () => {
-        CONSUME(l.builtIn.groupConcat);
+    impl: ({ ACTION, CONSUME, OPTION1, SUBRULE, OPTION2 }) => (C) => {
+        const operatorToken = CONSUME(l.builtIn.groupConcat);
         CONSUME(l.symbols.LParen);
-        const distinct = OPTION1(() => CONSUME(l.distinct));
+        const distinctToken = OPTION1(() => CONSUME(l.distinct));
         const expr = SUBRULE(expression, undefined);
-        const separator = OPTION2(() => {
+        const sep = OPTION2(() => {
             CONSUME(l.symbols.semi);
             CONSUME(l.separator);
             CONSUME(l.symbols.equal);
             return SUBRULE(string, undefined);
-        }) ?? ' ';
-        CONSUME(l.symbols.RParen);
-        return {
-            type: 'aggregate',
-            aggregation: 'group_concat',
-            expression: expr,
-            distinct: Boolean(distinct),
-            separator,
-        };
+        });
+        const closeToken = CONSUME(l.symbols.RParen);
+        return ACTION(() => {
+            const F = C.factory;
+            return F.aggregate(operatorToken.image, Boolean(distinctToken), expr, sep?.value ?? ' ', F.sourceLocation(operatorToken, closeToken));
+        });
     },
 };
 /**
@@ -233,22 +224,24 @@ export const aggregate = {
         });
         return result;
     },
-    gImpl: ({ SUBRULE }) => (ast) => {
-        const builder = [ast.aggregation, '('];
-        if (ast.distinct) {
-            builder.push('DISTINCT');
-        }
-        if ('termType' in ast.expression && ast.expression.termType === 'Wildcard') {
-            builder.push('*');
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => {
+            PRINT_WORD(ast.aggregation, '(');
+            if (ast.distinct) {
+                PRINT_WORD('DISTINCT');
+            }
+        });
+        const arg = ast.expression[0];
+        if (F.isWildcard(arg)) {
+            F.printFilter(ast, () => PRINT_WORD('*'));
         }
         else {
-            builder.push(SUBRULE(expression, ast.expression, undefined));
+            SUBRULE(expression, arg, undefined);
         }
-        if (ast.separator !== undefined && ast.separator !== ' ') {
-            builder.push(';', 'SEPARATOR', '=', SUBRULE(string, ast.separator, undefined));
+        if (F.isExpressionAggregateSeparator(ast)) {
+            F.printFilter(ast, () => PRINT_WORD(';', 'SEPARATOR', '=', stringEscapedLexical(ast.separator)));
         }
-        builder.push(')');
-        return builder.join(' ');
+        F.printFilter(ast, () => PRINT_WORD(')'));
     },
 };
 //# sourceMappingURL=builtIn.js.map