@traqula/rules-sparql-1-1 0.0.22 → 0.0.24

package/dist/cjs/lib/factoryMixins/ExpressionFactory.js

@@ -1,105 +1,86 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var ExpressionFactory_exports = {};
-__export(ExpressionFactory_exports, {
-  ExpressionFactoryMixin: () => ExpressionFactoryMixin
-});
-module.exports = __toCommonJS(ExpressionFactory_exports);
-const nodeType = "expression";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressionFactoryMixin = ExpressionFactoryMixin;
+const nodeType = 'expression';
+// eslint-disable-next-line ts/explicit-function-return-type
 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 === void 0) {
-        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");
-    }
-  };
+    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');
+        }
+    };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ExpressionFactoryMixin
-});
+//# sourceMappingURL=ExpressionFactory.js.map

package/dist/cjs/lib/factoryMixins/ExpressionFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressionFactory.js","sourceRoot":"","sources":["../../../../lib/factoryMixins/ExpressionFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AstCoreFactory, 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 '../Sparql11types.js';\nimport type { Constructor } from './mixins.js';\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<AstCoreFactory>>(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/dist/cjs/lib/factoryMixins/GraphRefFactory.js

@@ -1,76 +1,54 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var GraphRefFactory_exports = {};
-__export(GraphRefFactory_exports, {
-  GraphRefFactoryMixin: () => GraphRefFactoryMixin
-});
-module.exports = __toCommonJS(GraphRefFactory_exports);
-const nodeType = "graphRef";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphRefFactoryMixin = GraphRefFactoryMixin;
+const nodeType = 'graphRef';
+// eslint-disable-next-line ts/explicit-function-return-type
 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");
-    }
-  };
+    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');
+        }
+    };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  GraphRefFactoryMixin
-});
+//# sourceMappingURL=GraphRefFactory.js.map

package/dist/cjs/lib/factoryMixins/GraphRefFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphRefFactory.js","sourceRoot":"","sources":["../../../../lib/factoryMixins/GraphRefFactory.ts"],"names":[],"mappings":";;AAcA,oDAuDC;AA1DD,MAAM,QAAQ,GAAa,UAAU,CAAC;AAEtC,4DAA4D;AAC5D,SAAgB,oBAAoB,CAA4C,IAAW;IACzF,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 { AstCoreFactory, SubTyped, SourceLocation, Typed } from '@traqula/core';\nimport type {\n  GraphRefAll,\n  GraphRefDefault,\n  GraphRefNamed,\n  GraphRefSpecific,\n  TermIri,\n} from '../Sparql11types.js';\nimport type { Constructor } from './mixins.js';\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<AstCoreFactory>>(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/dist/cjs/lib/factoryMixins/PathFactory.js

@@ -1,90 +1,71 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var PathFactory_exports = {};
-__export(PathFactory_exports, {
-  PathFactoryMixin: () => PathFactoryMixin
-});
-module.exports = __toCommonJS(PathFactory_exports);
-const nodeType = "path";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathFactoryMixin = PathFactoryMixin;
+const nodeType = 'path';
+// eslint-disable-next-line ts/explicit-function-return-type
 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
-        };
-      }
-      if (subType === "^" && items.length === 1 && !this.isPathPure(items[0])) {
-        return {
-          ...base,
-          subType,
-          items
-        };
-      }
-      if (subType === "!" && items.length === 1 && (this.isPathAlternativeLimited(items[0]) || !this.isPathPure(items[0]) || this.isPathNegatedElt(items[0]))) {
-        return {
-          ...base,
-          subType,
-          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));
-    }
-  };
+    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));
+        }
+    };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PathFactoryMixin
-});
+//# sourceMappingURL=PathFactory.js.map

package/dist/cjs/lib/factoryMixins/PathFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathFactory.js","sourceRoot":"","sources":["../../../../lib/factoryMixins/PathFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AstCoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';\nimport type {\n  Path,\n  PathAlternativeLimited,\n  PathModified,\n  PathNegated,\n  PathNegatedElt,\n  PropertyPathChain,\n  TermIri,\n} from '../Sparql11types.js';\nimport type { Constructor } from './mixins.js';\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<AstCoreFactory>>(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"]}