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

package/lib/factoryMixins/ContextFactory.d.ts

@@ -0,0 +1,38 @@
+import type { CoreFactory, SubTyped, SourceLocation } from '@traqula/core';
+import type { ContextDefinitionBase, ContextDefinitionPrefix, TermIriFull } from '../RoundTripTypes';
+import type { Constructor } from './mixins';
+type NodeType = 'contextDef';
+export declare function ContextFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase): {
+    new (...args: any[]): {
+        contextDefinitionPrefix(loc: SourceLocation, key: string, value: TermIriFull): ContextDefinitionPrefix;
+        isContextDefinitionPrefix(contextDef: object): contextDef is SubTyped<NodeType, "prefix">;
+        contextDefinitionBase(loc: SourceLocation, value: TermIriFull): ContextDefinitionBase;
+        isContextDefinitionBase(contextDef: object): contextDef is SubTyped<NodeType, "base">;
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is import("@traqula/core").Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & TBase;
+export {};

package/lib/factoryMixins/ContextFactory.js

@@ -0,0 +1,30 @@
+const nodeType = 'contextDef';
+// eslint-disable-next-line ts/explicit-function-return-type
+export function ContextFactoryMixin(Base) {
+    return class ContextFactory extends Base {
+        contextDefinitionPrefix(loc, key, value) {
+            return {
+                type: nodeType,
+                subType: 'prefix',
+                key,
+                value,
+                loc,
+            };
+        }
+        isContextDefinitionPrefix(contextDef) {
+            return this.isOfSubType(contextDef, nodeType, 'prefix');
+        }
+        contextDefinitionBase(loc, value) {
+            return {
+                type: 'contextDef',
+                subType: 'base',
+                value,
+                loc,
+            };
+        }
+        isContextDefinitionBase(contextDef) {
+            return this.isOfSubType(contextDef, nodeType, 'base');
+        }
+    };
+}
+//# sourceMappingURL=ContextFactory.js.map

package/lib/factoryMixins/ContextFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextFactory.js","sourceRoot":"","sources":["ContextFactory.ts"],"names":[],"mappings":"AASA,MAAM,QAAQ,GAAa,YAAY,CAAC;AAExC,4DAA4D;AAC5D,MAAM,UAAU,mBAAmB,CAAyC,IAAW;IACrF,OAAO,MAAM,cAAe,SAAQ,IAAI;QAC/B,uBAAuB,CAAC,GAAmB,EAAE,GAAW,EAAE,KAAkB;YACjF,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,QAAQ;gBACjB,GAAG;gBACH,KAAK;gBACL,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,yBAAyB,CAAC,UAAkB;YACjD,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC1D,CAAC;QAEM,qBAAqB,CAAC,GAAmB,EAAE,KAAkB;YAClE,OAAO;gBACL,IAAI,EAAE,YAAY;gBAClB,OAAO,EAAE,MAAM;gBACf,KAAK;gBACL,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,uBAAuB,CAAC,UAAkB;YAC/C,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QACxD,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import type { CoreFactory, SubTyped, SourceLocation } from '@traqula/core';\nimport type {\n  ContextDefinitionBase,\n  ContextDefinitionPrefix,\n  TermIriFull,\n} from '../RoundTripTypes';\nimport type { Constructor } from './mixins';\n\ntype NodeType = 'contextDef';\nconst nodeType: NodeType = 'contextDef';\n\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function ContextFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase) {\n  return class ContextFactory extends Base {\n    public contextDefinitionPrefix(loc: SourceLocation, key: string, value: TermIriFull): ContextDefinitionPrefix {\n      return {\n        type: nodeType,\n        subType: 'prefix',\n        key,\n        value,\n        loc,\n      };\n    }\n\n    public isContextDefinitionPrefix(contextDef: object): contextDef is SubTyped<NodeType, 'prefix'> {\n      return this.isOfSubType(contextDef, nodeType, 'prefix');\n    }\n\n    public contextDefinitionBase(loc: SourceLocation, value: TermIriFull): ContextDefinitionBase {\n      return {\n        type: 'contextDef',\n        subType: 'base',\n        value,\n        loc,\n      };\n    }\n\n    public isContextDefinitionBase(contextDef: object): contextDef is SubTyped<NodeType, 'base'> {\n      return this.isOfSubType(contextDef, nodeType, 'base');\n    }\n  };\n}\n"]}

package/lib/factoryMixins/ExpressionFactory.d.ts

@@ -0,0 +1,60 @@
+import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';
+import type { Expression, ExpressionAggregate, ExpressionAggregateDefault, ExpressionAggregateOnWildcard, ExpressionAggregateSeparator, ExpressionFunctionCall, ExpressionOperation, ExpressionPatternOperation, PatternGroup, TermIri, Wildcard } from '../RoundTripTypes';
+import type { Constructor } from './mixins';
+type NodeType = 'expression';
+export declare function ExpressionFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase): {
+    new (...args: any[]): {
+        isExpressionPure(obj: object): obj is Typed<NodeType>;
+        formatOperator(operator: string): string;
+        expressionOperation<Args extends Expression[]>(operator: string, args: Args, loc: SourceLocation): ExpressionOperation & {
+            args: Args;
+        };
+        isExpressionOperator(obj: object): obj is SubTyped<NodeType, "operation">;
+        expressionFunctionCall<Args extends Expression[]>(functionOp: TermIri, args: Args, distinct: boolean, loc: SourceLocation): ExpressionFunctionCall & {
+            args: Args;
+        };
+        isExpressionFunctionCall(obj: object): obj is SubTyped<NodeType, "functionCall">;
+        expressionPatternOperation(operator: string, args: PatternGroup, loc: SourceLocation): ExpressionPatternOperation;
+        isExpressionPatternOperation(obj: object): obj is SubTyped<NodeType, "patternOperation">;
+        aggregate(aggregation: string, distinct: boolean, arg: Expression, separator: undefined, loc: SourceLocation): ExpressionAggregateDefault;
+        aggregate(aggregation: string, distinct: boolean, arg: Wildcard, separator: undefined, loc: SourceLocation): ExpressionAggregateOnWildcard;
+        aggregate(aggregation: string, distinct: boolean, arg: Expression, separator: string, loc: SourceLocation): ExpressionAggregateSeparator;
+        aggregate(aggregation: string, distinct: boolean, arg: Expression | Wildcard, separator: string | undefined, loc: SourceLocation): ExpressionAggregate;
+        isExpressionAggregate(obj: object): obj is SubTyped<NodeType, "aggregate">;
+        isExpressionAggregateSeparator(obj: object): obj is SubTyped<NodeType, "aggregate"> & {
+            separator: string;
+        };
+        isExpressionAggregateOnWildcard(obj: object): obj is SubTyped<NodeType, "aggregate"> & {
+            expression: [Typed<"wildcard">];
+        };
+        isExpressionAggregateDefault(obj: object): obj is SubTyped<NodeType, "aggregate"> & {
+            expression: [Expression];
+        };
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & TBase;
+export {};

package/lib/factoryMixins/ExpressionFactory.js

@@ -0,0 +1,83 @@
+const nodeType = 'expression';
+// eslint-disable-next-line ts/explicit-function-return-type
+export function ExpressionFactoryMixin(Base) {
+    return class ExpressionFactory extends Base {
+        isExpressionPure(obj) {
+            return this.isOfType(obj, nodeType);
+        }
+        formatOperator(operator) {
+            return operator.toLowerCase().replaceAll(' ', '');
+        }
+        expressionOperation(operator, args, loc) {
+            return {
+                type: nodeType,
+                subType: 'operation',
+                operator: this.formatOperator(operator),
+                args,
+                loc,
+            };
+        }
+        isExpressionOperator(obj) {
+            return this.isOfSubType(obj, nodeType, 'operation');
+        }
+        expressionFunctionCall(functionOp, args, distinct, loc) {
+            return {
+                type: 'expression',
+                subType: 'functionCall',
+                function: functionOp,
+                args,
+                distinct,
+                loc,
+            };
+        }
+        isExpressionFunctionCall(obj) {
+            return this.isOfSubType(obj, nodeType, 'functionCall');
+        }
+        expressionPatternOperation(operator, args, loc) {
+            return {
+                type: nodeType,
+                subType: 'patternOperation',
+                operator: this.formatOperator(operator),
+                args,
+                loc,
+            };
+        }
+        isExpressionPatternOperation(obj) {
+            return this.isOfSubType(obj, nodeType, 'patternOperation');
+        }
+        aggregate(aggregation, distinct, arg, separator, loc) {
+            const base = {
+                type: 'expression',
+                subType: 'aggregate',
+                aggregation: this.formatOperator(aggregation),
+                distinct,
+                loc,
+            };
+            if (this.isOfType(arg, 'wildcard')) {
+                return { ...base, expression: [arg] };
+            }
+            if (separator === undefined) {
+                return { ...base, expression: [arg] };
+            }
+            return { ...base, expression: [arg], separator };
+        }
+        isExpressionAggregate(obj) {
+            return this.isOfSubType(obj, nodeType, 'aggregate');
+        }
+        isExpressionAggregateSeparator(obj) {
+            return this.isOfSubType(obj, nodeType, 'aggregate') &&
+                typeof obj.separator === 'string';
+        }
+        isExpressionAggregateOnWildcard(obj) {
+            const casted = obj;
+            return this.isOfSubType(obj, nodeType, 'aggregate') && Array.isArray(casted.expression) &&
+                casted.expression.length === 1 && this.isOfType(casted.expression[0], 'wildcard');
+        }
+        isExpressionAggregateDefault(obj) {
+            const casted = obj;
+            return this.isOfSubType(obj, nodeType, 'operation') && Array.isArray(casted.expression) &&
+                casted.expression.length === 1 && !this.isOfType(casted.expression[0], 'wildcard');
+        }
+    };
+}
+//# sourceMappingURL=ExpressionFactory.js.map

package/lib/factoryMixins/ExpressionFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressionFactory.js","sourceRoot":"","sources":["ExpressionFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';\nimport type {\n  Expression,\n  ExpressionAggregate,\n  ExpressionAggregateDefault,\n  ExpressionAggregateOnWildcard,\n  ExpressionAggregateSeparator,\n  ExpressionFunctionCall,\n  ExpressionOperation,\n  ExpressionPatternOperation,\n  PatternGroup,\n  TermIri,\n  Wildcard,\n} from '../RoundTripTypes';\nimport type { Constructor } from './mixins';\n\ntype NodeType = 'expression';\nconst nodeType: NodeType = 'expression';\n\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function ExpressionFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase) {\n  return class ExpressionFactory extends Base {\n    public isExpressionPure(obj: object): obj is Typed<NodeType> {\n      return this.isOfType(obj, nodeType);\n    }\n\n    public formatOperator(operator: string): string {\n      return operator.toLowerCase().replaceAll(' ', '');\n    }\n\n    public expressionOperation<Args extends Expression[]>(\n      operator: string,\n      args: Args,\n      loc: SourceLocation,\n    ): ExpressionOperation & { args: Args } {\n      return {\n        type: nodeType,\n        subType: 'operation',\n        operator: this.formatOperator(operator),\n        args,\n        loc,\n      };\n    }\n\n    public isExpressionOperator(obj: object): obj is SubTyped<NodeType, 'operation'> {\n      return this.isOfSubType(obj, nodeType, 'operation');\n    }\n\n    public expressionFunctionCall<Args extends Expression[]>(\n      functionOp: TermIri,\n      args: Args,\n      distinct: boolean,\n      loc: SourceLocation,\n    ): ExpressionFunctionCall & { args: Args } {\n      return {\n        type: 'expression',\n        subType: 'functionCall',\n        function: functionOp,\n        args,\n        distinct,\n        loc,\n      };\n    }\n\n    public isExpressionFunctionCall(obj: object): obj is SubTyped<NodeType, 'functionCall'> {\n      return this.isOfSubType(obj, nodeType, 'functionCall');\n    }\n\n    public expressionPatternOperation(\n      operator: string,\n      args: PatternGroup,\n      loc: SourceLocation,\n    ): ExpressionPatternOperation {\n      return {\n        type: nodeType,\n        subType: 'patternOperation',\n        operator: this.formatOperator(operator),\n        args,\n        loc,\n      };\n    }\n\n    public isExpressionPatternOperation(obj: object): obj is SubTyped<NodeType, 'patternOperation'> {\n      return this.isOfSubType(obj, nodeType, 'patternOperation');\n    }\n\n    public aggregate(\n      aggregation: string,\n      distinct: boolean,\n      arg: Expression,\n      separator: undefined,\n      loc: SourceLocation\n    ): ExpressionAggregateDefault;\n    public aggregate(\n      aggregation: string,\n      distinct: boolean,\n      arg: Wildcard,\n      separator: undefined,\n      loc: SourceLocation\n    ): ExpressionAggregateOnWildcard;\n    public aggregate(\n      aggregation: string,\n      distinct: boolean,\n      arg: Expression,\n      separator: string,\n      loc: SourceLocation\n    ): ExpressionAggregateSeparator;\n    public aggregate(\n      aggregation: string,\n      distinct: boolean,\n      arg: Expression | Wildcard,\n      separator: string | undefined,\n      loc: SourceLocation,\n    ): ExpressionAggregate;\n    public aggregate(\n      aggregation: string,\n      distinct: boolean,\n      arg: Expression | Wildcard,\n      separator: string | undefined,\n      loc: SourceLocation,\n    ): ExpressionAggregate {\n      const base = <const> {\n        type: 'expression',\n        subType: 'aggregate',\n        aggregation: this.formatOperator(aggregation),\n        distinct,\n        loc,\n      };\n      if (this.isOfType(arg, 'wildcard')) {\n        return { ...base, expression: [ arg ]} satisfies ExpressionAggregateOnWildcard;\n      }\n      if (separator === undefined) {\n        return { ...base, expression: [ arg ]} satisfies ExpressionAggregateDefault;\n      }\n      return { ...base, expression: [ arg ], separator } satisfies ExpressionAggregateSeparator;\n    }\n\n    public isExpressionAggregate(obj: object): obj is SubTyped<NodeType, 'aggregate'> {\n      return this.isOfSubType(obj, nodeType, 'aggregate');\n    }\n\n    public isExpressionAggregateSeparator(obj: object): obj is SubTyped<NodeType, 'aggregate'> & { separator: string } {\n      return this.isOfSubType(obj, nodeType, 'aggregate') &&\n        typeof (<{ separator?: unknown }> obj).separator === 'string';\n    }\n\n    public isExpressionAggregateOnWildcard(obj: object):\n      obj is SubTyped<NodeType, 'aggregate'> & { expression: [Typed<'wildcard'>]} {\n      const casted = <{ expression?: unknown }> obj;\n      return this.isOfSubType(obj, nodeType, 'aggregate') && Array.isArray(casted.expression) &&\n        casted.expression.length === 1 && this.isOfType(casted.expression[0], 'wildcard');\n    }\n\n    public isExpressionAggregateDefault(obj: object):\n      obj is SubTyped<NodeType, 'aggregate'> & { expression: [Expression]} {\n      const casted = <{ expression?: unknown }> obj;\n\n      return this.isOfSubType(obj, nodeType, 'operation') && Array.isArray(casted.expression) &&\n        casted.expression.length === 1 && !this.isOfType(casted.expression[0], 'wildcard');\n    }\n  };\n}\n"]}

package/lib/factoryMixins/GraphRefFactory.d.ts

@@ -0,0 +1,43 @@
+import type { CoreFactory, SubTyped, SourceLocation, Typed } from '@traqula/core';
+import type { GraphRefAll, GraphRefDefault, GraphRefNamed, GraphRefSpecific, TermIri } from '../RoundTripTypes';
+import type { Constructor } from './mixins';
+type NodeType = 'graphRef';
+export declare function GraphRefFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase): {
+    new (...args: any[]): {
+        isGraphRef(obj: object): obj is Typed<NodeType>;
+        graphRefDefault(loc: SourceLocation): GraphRefDefault;
+        isGraphRefDefault(graphRef: object): graphRef is SubTyped<NodeType, "default">;
+        graphRefNamed(loc: SourceLocation): GraphRefNamed;
+        isGraphRefNamed(graphRef: object): graphRef is SubTyped<NodeType, "named">;
+        graphRefAll(loc: SourceLocation): GraphRefAll;
+        isGraphRefAll(graphRef: object): graphRef is SubTyped<NodeType, "all">;
+        graphRefSpecific(graph: TermIri, loc: SourceLocation): GraphRefSpecific;
+        isGraphRefSpecific(graphRef: object): graphRef is SubTyped<NodeType, "specific">;
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & TBase;
+export {};

package/lib/factoryMixins/GraphRefFactory.js

@@ -0,0 +1,51 @@
+const nodeType = 'graphRef';
+// eslint-disable-next-line ts/explicit-function-return-type
+export function GraphRefFactoryMixin(Base) {
+    return class GraphRefFactory extends Base {
+        isGraphRef(obj) {
+            return this.isOfType(obj, nodeType);
+        }
+        graphRefDefault(loc) {
+            return {
+                type: nodeType,
+                subType: 'default',
+                loc,
+            };
+        }
+        isGraphRefDefault(graphRef) {
+            return this.isOfSubType(graphRef, nodeType, 'default');
+        }
+        graphRefNamed(loc) {
+            return {
+                type: nodeType,
+                subType: 'named',
+                loc,
+            };
+        }
+        isGraphRefNamed(graphRef) {
+            return this.isOfSubType(graphRef, nodeType, 'named');
+        }
+        graphRefAll(loc) {
+            return {
+                type: nodeType,
+                subType: 'all',
+                loc,
+            };
+        }
+        isGraphRefAll(graphRef) {
+            return this.isOfSubType(graphRef, nodeType, 'all');
+        }
+        graphRefSpecific(graph, loc) {
+            return {
+                type: nodeType,
+                subType: 'specific',
+                graph,
+                loc,
+            };
+        }
+        isGraphRefSpecific(graphRef) {
+            return this.isOfSubType(graphRef, nodeType, 'specific');
+        }
+    };
+}
+//# sourceMappingURL=GraphRefFactory.js.map

package/lib/factoryMixins/GraphRefFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphRefFactory.js","sourceRoot":"","sources":["GraphRefFactory.ts"],"names":[],"mappings":"AAWA,MAAM,QAAQ,GAAa,UAAU,CAAC;AAEtC,4DAA4D;AAC5D,MAAM,UAAU,oBAAoB,CAAyC,IAAW;IACtF,OAAO,MAAM,eAAgB,SAAQ,IAAI;QAChC,UAAU,CAAC,GAAW;YAC3B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACtC,CAAC;QAEM,eAAe,CAAC,GAAmB;YACxC,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,SAAS;gBAClB,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,iBAAiB,CAAC,QAAgB;YACvC,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QACzD,CAAC;QAEM,aAAa,CAAC,GAAmB;YACtC,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,OAAO;gBAChB,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,eAAe,CAAC,QAAgB;YACrC,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QACvD,CAAC;QAEM,WAAW,CAAC,GAAmB;YACpC,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,KAAK;gBACd,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,aAAa,CAAC,QAAgB;YACnC,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QACrD,CAAC;QAEM,gBAAgB,CAAC,KAAc,EAAE,GAAmB;YACzD,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,UAAU;gBACnB,KAAK;gBACL,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,kBAAkB,CAAC,QAAgB;YACxC,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;QAC1D,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import type { CoreFactory, SubTyped, SourceLocation, Typed } from '@traqula/core';\nimport type {\n  GraphRefAll,\n  GraphRefDefault,\n  GraphRefNamed,\n  GraphRefSpecific,\n  TermIri,\n} from '../RoundTripTypes';\nimport type { Constructor } from './mixins';\n\ntype NodeType = 'graphRef';\nconst nodeType: NodeType = 'graphRef';\n\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function GraphRefFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase) {\n  return class GraphRefFactory extends Base {\n    public isGraphRef(obj: object): obj is Typed<NodeType> {\n      return this.isOfType(obj, nodeType);\n    }\n\n    public graphRefDefault(loc: SourceLocation): GraphRefDefault {\n      return {\n        type: nodeType,\n        subType: 'default',\n        loc,\n      };\n    }\n\n    public isGraphRefDefault(graphRef: object): graphRef is SubTyped<NodeType, 'default'> {\n      return this.isOfSubType(graphRef, nodeType, 'default');\n    }\n\n    public graphRefNamed(loc: SourceLocation): GraphRefNamed {\n      return {\n        type: nodeType,\n        subType: 'named',\n        loc,\n      };\n    }\n\n    public isGraphRefNamed(graphRef: object): graphRef is SubTyped<NodeType, 'named'> {\n      return this.isOfSubType(graphRef, nodeType, 'named');\n    }\n\n    public graphRefAll(loc: SourceLocation): GraphRefAll {\n      return {\n        type: nodeType,\n        subType: 'all',\n        loc,\n      };\n    }\n\n    public isGraphRefAll(graphRef: object): graphRef is SubTyped<NodeType, 'all'> {\n      return this.isOfSubType(graphRef, nodeType, 'all');\n    }\n\n    public graphRefSpecific(graph: TermIri, loc: SourceLocation): GraphRefSpecific {\n      return {\n        type: nodeType,\n        subType: 'specific',\n        graph,\n        loc,\n      };\n    }\n\n    public isGraphRefSpecific(graphRef: object): graphRef is SubTyped<NodeType, 'specific'> {\n      return this.isOfSubType(graphRef, nodeType, 'specific');\n    }\n  };\n}\n"]}

package/lib/factoryMixins/PathFactory.d.ts

@@ -0,0 +1,51 @@
+import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';
+import type { Path, PathAlternativeLimited, PathModified, PathNegated, PathNegatedElt, PropertyPathChain, TermIri } from '../RoundTripTypes';
+import type { Constructor } from './mixins';
+type NodeType = 'path';
+type RawNegatedElt = SubTyped<NodeType, '^'> & {
+    items: [SubTyped<'term', 'namedNode'>];
+};
+export declare function PathFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase): {
+    new (...args: any[]): {
+        isPathPure(obj: object): obj is Typed<NodeType>;
+        path(subType: "|", items: (TermIri | PathNegatedElt)[], loc: SourceLocation): PathAlternativeLimited;
+        path(subType: "!", items: [TermIri | PathNegatedElt | PathAlternativeLimited], loc: SourceLocation): PathNegated;
+        path(subType: "^", items: [TermIri], loc: SourceLocation): PathNegatedElt;
+        path(subType: PathModified["subType"], item: [Path], loc: SourceLocation): PathModified;
+        path(subType: "|" | "/", items: Path[], loc: SourceLocation): PropertyPathChain;
+        isPathOfType<T extends U[], U extends string>(obj: object, subTypes: T): obj is SubTyped<NodeType, U>;
+        isPathChain(obj: object): obj is SubTyped<NodeType, "|" | "/">;
+        isPathModified(obj: object): obj is SubTyped<NodeType, "?" | "*" | "+" | "^">;
+        isPathNegatedElt(obj: object): obj is RawNegatedElt;
+        isPathNegated(obj: object): obj is SubTyped<NodeType, "!">;
+        isPathAlternativeLimited(obj: object): obj is SubTyped<NodeType, "|"> & {
+            items: (SubTyped<"term", "namedNode"> | RawNegatedElt)[];
+        };
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & TBase;
+export {};

package/lib/factoryMixins/PathFactory.js

@@ -0,0 +1,68 @@
+const nodeType = 'path';
+// eslint-disable-next-line ts/explicit-function-return-type
+export function PathFactoryMixin(Base) {
+    return class PathFactory extends Base {
+        isPathPure(obj) {
+            return this.isOfType(obj, nodeType);
+        }
+        path(subType, items, loc) {
+            const base = {
+                type: nodeType,
+                loc,
+                items,
+            };
+            if (subType === '|' || subType === '/') {
+                return {
+                    ...base,
+                    subType,
+                };
+            }
+            if ((subType === '?' || subType === '*' || subType === '+' || subType === '^') && items.length === 1) {
+                return {
+                    ...base,
+                    subType,
+                    items: items,
+                };
+            }
+            if (subType === '^' && items.length === 1 && !this.isPathPure(items[0])) {
+                return {
+                    ...base,
+                    subType,
+                    items: items,
+                };
+            }
+            if (subType === '!' && items.length === 1 && (this.isPathAlternativeLimited(items[0]) || !this.isPathPure(items[0]) || this.isPathNegatedElt(items[0]))) {
+                return {
+                    ...base,
+                    subType,
+                    items: items,
+                };
+            }
+            throw new Error('Invalid path type');
+        }
+        isPathOfType(obj, subTypes) {
+            return this.isOfType(obj, nodeType) && subTypes.includes(obj.subType);
+        }
+        isPathChain(obj) {
+            return this.isOfSubType(obj, nodeType, '/') || this.isOfSubType(obj, nodeType, '|');
+        }
+        isPathModified(obj) {
+            return this.isOfSubType(obj, nodeType, '?') || this.isOfSubType(obj, nodeType, '*') ||
+                this.isOfSubType(obj, nodeType, '+') || this.isOfSubType(obj, nodeType, '^');
+        }
+        isPathNegatedElt(obj) {
+            const casted = obj;
+            return this.isOfSubType(obj, nodeType, '^') && Array.isArray(casted.items) && casted.items.length === 1 &&
+                typeof casted.items[0] === 'object' && (casted.items[0] ?? false) && !this.isPathPure(casted.items[0]);
+        }
+        isPathNegated(obj) {
+            return this.isOfSubType(obj, nodeType, '!');
+        }
+        isPathAlternativeLimited(obj) {
+            const casted = obj;
+            return this.isOfSubType(obj, nodeType, '|') && Array.isArray(casted.items) &&
+                casted.items.every(item => !this.isPathPure(item) || this.isPathNegatedElt(item));
+        }
+    };
+}
+//# sourceMappingURL=PathFactory.js.map

package/lib/factoryMixins/PathFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathFactory.js","sourceRoot":"","sources":["PathFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';\nimport type {\n  Path,\n  PathAlternativeLimited,\n  PathModified,\n  PathNegated,\n  PathNegatedElt,\n  PropertyPathChain,\n  TermIri,\n} from '../RoundTripTypes';\nimport type { Constructor } from './mixins';\n\ntype NodeType = 'path';\nconst nodeType: NodeType = 'path';\n\ntype RawNegatedElt = SubTyped<NodeType, '^'> & { items: [SubTyped<'term', 'namedNode'>]};\n\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function PathFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase) {\n  return class PathFactory extends Base {\n    public isPathPure(obj: object): obj is Typed<NodeType> {\n      return this.isOfType(obj, nodeType);\n    }\n\n    public path(\n      subType: '|',\n      items: (TermIri | PathNegatedElt)[],\n      loc: SourceLocation\n    ): PathAlternativeLimited;\n    public path(\n      subType: '!',\n      items: [TermIri | PathNegatedElt | PathAlternativeLimited],\n      loc: SourceLocation\n    ): PathNegated;\n    public path(subType: '^', items: [TermIri], loc: SourceLocation): PathNegatedElt;\n    public path(subType: PathModified['subType'], item: [Path], loc: SourceLocation): PathModified;\n    public path(subType: '|' | '/', items: Path[], loc: SourceLocation):\n    PropertyPathChain;\n    public path(\n      subType: (PropertyPathChain | PathModified | PathNegated)['subType'],\n      items: Path[],\n      loc: SourceLocation,\n    ): Path {\n      const base = <const>{\n        type: nodeType,\n        loc,\n        items,\n      };\n      if (subType === '|' || subType === '/') {\n        return {\n          ...base,\n          subType,\n        } satisfies PropertyPathChain;\n      }\n      if ((subType === '?' || subType === '*' || subType === '+' || subType === '^') && items.length === 1) {\n        return {\n          ...base,\n          subType,\n          items: <[Path]>items,\n        } satisfies PathModified;\n      }\n      if (subType === '^' && items.length === 1 && !this.isPathPure(items[0])) {\n        return {\n          ...base,\n          subType,\n          items: <[TermIri]>items,\n        } satisfies PathNegatedElt;\n      }\n      if (subType === '!' && items.length === 1 && (\n        this.isPathAlternativeLimited(items[0]) || !this.isPathPure(items[0]) || this.isPathNegatedElt(items[0]))) {\n        return {\n          ...base,\n          subType,\n          items: <[TermIri | PathNegatedElt | PathAlternativeLimited]>items,\n        } satisfies PathNegated;\n      }\n      throw new Error('Invalid path type');\n    }\n\n    public isPathOfType<T extends U[], U extends string>(obj: object, subTypes: T): obj is SubTyped<NodeType, U> {\n      return this.isOfType(obj, nodeType) && subTypes.includes(<any>(<{ subType?: unknown }>obj).subType);\n    }\n\n    public isPathChain(obj: object): obj is SubTyped<NodeType, '|' | '/'> {\n      return this.isOfSubType(obj, nodeType, '/') || this.isOfSubType(obj, nodeType, '|');\n    }\n\n    public isPathModified(obj: object): obj is SubTyped<NodeType, '?' | '*' | '+' | '^'> {\n      return this.isOfSubType(obj, nodeType, '?') || this.isOfSubType(obj, nodeType, '*') ||\n        this.isOfSubType(obj, nodeType, '+') || this.isOfSubType(obj, nodeType, '^');\n    }\n\n    public isPathNegatedElt(obj: object): obj is RawNegatedElt {\n      const casted: { items?: unknown } = obj;\n      return this.isOfSubType(obj, nodeType, '^') && Array.isArray(casted.items) && casted.items.length === 1 &&\n        typeof casted.items[0] === 'object' && (casted.items[0] ?? false) && !this.isPathPure(casted.items[0]);\n    }\n\n    public isPathNegated(obj: object): obj is SubTyped<NodeType, '!'> {\n      return this.isOfSubType(obj, nodeType, '!');\n    }\n\n    public isPathAlternativeLimited(obj: object):\n      obj is SubTyped<NodeType, '|'> & { items: (SubTyped<'term', 'namedNode'> | RawNegatedElt)[] } {\n      const casted: { items?: unknown } = obj;\n      return this.isOfSubType(obj, nodeType, '|') && Array.isArray(casted.items) &&\n        casted.items.every(item => !this.isPathPure(item) || this.isPathNegatedElt(item));\n    }\n  };\n}\n"]}

package/lib/factoryMixins/Patternfactory.d.ts

@@ -0,0 +1,55 @@
+import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';
+import type { BasicGraphPattern, Expression, Pattern, PatternBgp, PatternBind, PatternFilter, PatternGraph, PatternGroup, PatternMinus, PatternOptional, PatternService, PatternUnion, PatternValues, TermIri, TermVariable, ValuePatternRow } from '../RoundTripTypes';
+import type { Constructor } from './mixins';
+type NodeType = 'pattern';
+export declare function PatternFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase): {
+    new (...args: any[]): {
+        isPattern(obj: object): obj is Typed<NodeType>;
+        patternBgp(triples: BasicGraphPattern, loc: SourceLocation): PatternBgp;
+        isPatternBgp(obj: object): obj is SubTyped<NodeType, "bgp">;
+        patternGroup(patterns: Pattern[], loc: SourceLocation): PatternGroup;
+        isPatternGroup(obj: object): obj is SubTyped<NodeType, "group">;
+        patternGraph(name: TermIri | TermVariable, patterns: Pattern[], loc: SourceLocation): PatternGraph;
+        isPatternGraph(obj: object): obj is SubTyped<NodeType, "graph">;
+        patternOptional(patterns: Pattern[], loc: SourceLocation): PatternOptional;
+        isPatternOptional(obj: object): obj is SubTyped<NodeType, "optional">;
+        patternValues(values: ValuePatternRow[], loc: SourceLocation): PatternValues;
+        isPatternValues(obj: object): obj is SubTyped<NodeType, "values">;
+        patternFilter(expression: Expression, loc: SourceLocation): PatternFilter;
+        isPatternFilter(obj: object): obj is SubTyped<NodeType, "filter">;
+        patternBind(expression: Expression, variable: TermVariable, loc: SourceLocation): PatternBind;
+        isPatternBind(obj: object): obj is SubTyped<NodeType, "bind">;
+        patternUnion(patterns: PatternGroup[], loc: SourceLocation): PatternUnion;
+        isPatternUnion(obj: object): obj is SubTyped<NodeType, "union">;
+        patternMinus(patterns: Pattern[], loc: SourceLocation): PatternMinus;
+        isPatternMinus(obj: object): obj is SubTyped<NodeType, "minus">;
+        patternService(name: TermIri | TermVariable, patterns: Pattern[], silent: boolean, loc: SourceLocation): PatternService;
+        isPatternService(obj: object): obj is SubTyped<NodeType, "service">;
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & TBase;
+export {};